Java 并发与多线程

2019/04/10 10:10
阅读数 59

Java 并发与多线程

基本概念

并发与并行

  1. 并发:指两个或多个事件在同一时间间隔内发生 。当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状。这种方式称之为并发(Concurrent)
  2. 并行:指两个或者多个事件在同一时刻发生 。当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时,另一个CPU可以执行另一个线程,两个线程互不抢占CPU资源,可以同时进行,这种方式称之为并行(Parallel)

进程与线程

  1. 一个程序可能有多个进程,一个进程由多个线程和共享资源组成
  2. 进程:拥有资源的基本单位
  3. 线程:独立调度分派的基本单位

线程

创建线程

Thread

  1. 继承 Thread 类(Thread 实现了 Runnable 接口)
  2. 重写 run 方法
  3. start() 方法启动线程

Runnable

  1. 实现 Runnable 接口
  2. 重写 run 方法
  3. new Thread(Runnable target),new Thread(Runnable target,String name)

多个 Thread 实例共用一个 Runnable,这些线程的 run 方法相同,可以共享相同的数据

但是存在线程同步问题

public class RunnableTest implements Runnable
{
    private int ticket = 10;
    public void run()
    {
        while (true)
        {
            if (ticket > 0)
            {
                System.out.println(Thread.currentThread().getName() + "售出" + ticket + "号票");
                ticket--;
            }
            else System.exit(0);
        }
    }
    public static void main(String[] args)
    {
        RunnableTest rt = new RunnableTest();
        Thread t1 = new Thread(rt, "1号窗口");
        Thread t2 = new Thread(rt, "2号窗口");
        t1.start();
        t2.start();
    }
}

print

1号窗口售出10号票
1号窗口售出9号票
1号窗口售出8号票
1号窗口售出7号票
2号窗口售出7号票
2号窗口售出5号票
1号窗口售出6号票
2号窗口售出4号票
1号窗口售出3号票
2号窗口售出2号票
1号窗口售出1号票

匿名类

匿名类可以方便的访问方法的局部变量,但是必须声明为 final,因为匿名类和普通局部变量生命周期不一致

jdk7 中已不再需要显示声明为 final,实际上被虚拟机自动隐式声明了

public static void main(String[] args)
{
    new Thread( )
    {
        public void run( )
        {
            //内容
        }
    }.start( );
    new Thread(new Runnable( )
    {
        public void run( )
        {
            //内容
        }
	}).start( );
}

Callable

  1. 创建 Callable 的实现类,并冲写 call() 方法,该方法为线程执行体,并且该方法有返回值

  2. 创建 Callable 实现类的实例,并用 FutuerTask 类来包装 Callable 对象,该 FutuerTask 封装了 Callable 对象 call() 方法的返回值

  3. 实例化 FutuerTask 类,参数为 FutuerTask 接口实现类的对象来启动线程

  4. 通过 FutuerTask 类的对象的 get() 方法来获取线程结束后的返回值

    public class CallableTest implements Callable<Integer>
    {
        //重写执行体 call( )
        public Integer call( ) throws Exception
        {
            int i = 0;
            for (; i < 10; i++)
            {
               //
            }
            return i;
        }
        public static void main(String[] args)
        {
            Callable call = new CallableTest( );
            FutureTask<Integer> f = new FutureTask<Integer>(call);
            Thread t = new Thread(f);
            t.start( );
            //得到返回值
            try
            {
                System.out.println("返回值:" + f.get( ));
            }
            catch (Exception e)
            {
                e.printStackTrace( );
            }
        }
    }
    

    print

    返回值:10
    

线程方法

  1. 线程执行体:run()

  2. 启动线程:start()

  3. Thread 类方法

    方法 描述
    public final void setName(String name) 改变线程名称
    public final void setPriority(int priority) 设置优先级
    public final void setDaemon(boolean on) 设为守护线程,当只剩下守护线程时自动结束
    public final boolean isAlive() 测试线程是否处于活动状态
    public static void yield() 暂停当前线程(回到就绪状态)
    public static void sleep(long millisec) 进入休眠状态
    public final void join() 暂停当前线程,等待调用该方法线程执行完毕
    public final void join(long millisec) 暂停当前线程指定时间
    public static Thread currentThread() 返回对当前正在执行的线程对象的引用

线程状态

  1. 就绪状态:

    • start() 方法进入就绪状态,等待虚拟机调度
    • 运行状态调用 yield 方法会进入就绪状态
    • lock 池中的线程获得锁后进入就绪状态
  2. 运行状态:就绪状态经过线程调度进去运行状态

  3. 阻塞状态:

    • 休眠:调用 sleep 方法
    • 对象 wait 池:调用 wait 或 join 方法,被 notify 后进入 lock 池
    • 对象 lock 池:未获得锁
  4. 死亡状态:run 方法执行完毕

    graph TB
    	T(新线程)--start方法-->A(就绪状态)
    	A--线程调度-->B(运行状态)
    	B--yield方法-->A
    	B--sleep方法-->D(阻塞:休眠)
    	B--wait或join方法-->E(阻塞:wait池)
    	B--未获得锁-->F(阻塞:lock池)
    	B--run方法执行完-->C(死亡状态)
    	D--时间到-->A
    	E--notify方法-->F
    	F--获得锁-->A
    

线程同步

保证程序原子性、可见性、有序性的过程

阻塞同步

基于加锁争用的悲观并发策略

synchronized

  1. synchronized 含义

    • 使用 synchronized 可以锁住某一对象, 当其他线程也想锁住该对象以执行某段代码时,必须等待已经持有锁的线程释放锁

    • 释放锁的方式有互斥代码执行完毕、抛出异常、锁对象调用 wait 方法

  2. 不同的使用方式代表不同的锁粒度

    • 修饰普通方法 = synchronized(this)
    • 修饰静态方法 = synchronized(X.class)
    • 修饰代码块(对象 extends Object)

ReentrantLock

  1. 创建 Lock 锁

    ReentrantLock 实现了 Lock 接口, Lock lock = new ReentrantLock()

  2. Lock 含义

    • 使用 lock() 方法表示当前线程占有 lock 对象

    • 释放该对象要显示掉用 unlock() 方法 ,多在 finally 块中进行释放

  3. trylock 方法

    • synchronized 会一直等待锁,而 Lock 提供了 trylock 方法,在指定时间内试图占用
    • 使用 trylock, 释放锁时要判断,若占用失败,unlock 会抛出异常
  4. Lock 的线程交互

    • 通过 lock 对象得到一个 Condition 对象,Condition condition = lock.newCondition()

    • 调用这个Condition对象的:await,signal,signalAll 方法

  5. 示例

    public class LockTest
    {
        public static void log(String msg)//日志方法
        {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = new Date( );
            String dateStr = sdf.format(date);
            System.out.println(dateStr + " " + Thread.currentThread( ).getName( ) + " " + msg);
        }
        public static void main(String[] args)
        {
            Lock lock = new ReentrantLock( );
            new Thread("t1")
            {
                public void run( )
                {
                    boolean flag = false;
                    try
                    {
                        log("线程已启动");
                        log("尝试占有lock");
                        flag = lock.tryLock(1, TimeUnit.SECONDS);
                        if (flag)
                        {
                            log("成功占有lock");
                            log("执行3秒业务操作");
                            Thread.sleep(3000);
                        }
                        else
                        {
                            log("经过1秒钟尝试,占有lock失败,放弃占有");
                        }
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace( );
                    }
                    finally
                    {
                        if (flag)
                        {
                            log("释放lock");
                            lock.unlock( );
                        }
                    }
                    log("线程结束");
                }
            }.start( );
            try
            {
                //先让 t1 先执行两秒
                Thread.sleep(2000);
            }
            catch (InterruptedException e1)
            {
                e1.printStackTrace( );
            }
            new Thread("t2")
            {
                public void run( )
                {
                    boolean flag = false;
                    try
                    {
                        log("线程启动");
                        log("尝试占有lock");
    
                        flag = lock.tryLock(1, TimeUnit.SECONDS);
                        if (flag)
                        {
                            log("成功占有lock");
                            log("执行3秒的业务操作");
                            Thread.sleep(3000);
                        }
                        else
                        {
                            log("经过1秒钟的尝试,占有lock失败,放弃占有");
                        }
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace( );
                    }
                    finally
                    {
                        if (flag)
                        {
                            log("释放lock");
                            lock.unlock( );
                        }
                    }
                    log("线程结束");
                }
            }.start( );
        }
    }
    

    print

    2019-11-07 15:50:01 t1 线程已启动
    2019-11-07 15:50:01 t1 尝试占有lock
    2019-11-07 15:50:01 t1 成功占有lock
    2019-11-07 15:50:01 t1 执行3秒业务操作
    2019-11-07 15:50:03 t2 线程启动
    2019-11-07 15:50:03 t2 尝试占有lock
    2019-11-07 15:50:04 t2 经过1秒钟的尝试,占有lock失败,放弃占有
    2019-11-07 15:50:04 t2 线程结束
    2019-11-07 15:50:04 t1 释放lock
    2019-11-07 15:50:04 t1 线程结束
    
  6. synchronized 和 Lock 区别

    • synchronized 是关键字,Lock 是接口, synchronized是内置的语言实现,Lock是代码层面的实现
    • synchronized 执行完毕自动释放锁,Lock 需要显示 unlock()
    • synchronized 会一直等待,尝试占用锁,Lock 可以使用 trylock,在一段时间内尝试占用,时间到占用失败则放弃

非阻塞同步

非阻塞同步是一种基于冲突检测和数据更新的乐观并发策略

actomic 类

  1. 原子操作

    • 原子操作是不可中断的操作,必须一次性执行完成
    • 赋值操作是原子操作,但 a++ 不是原子操作, 而是取值、加一、赋值三个步骤
    • 一个线程取 i 的值后,还没来得及加一,第二个线程也来取值,就产生了线程安全问题
  2. actomic 类的使用

    • jdk6 以后,新增包 java.util.concurrent.atomic,里面有各种原子类,比如 AtomicInteger
    • AtomicInteger 提供了各种自增,自减等方法,这些方法都是原子性的。换句话说,自增方法 incrementAndGet 是线程安全的
    • 10000 个线程做 value 加一的操作,用 a++ 方式得出不准确的结果,用原子类 AtomicInteger 的 addAndGet() 方法得出正确结果
    public class ThreadTest
    {
        static int value1 = 0;
        static AtomicInteger value2 = new AtomicInteger(0);//原子整型类
        public static void main(String[] args)
        {
            for (int i = 0; i < 100000; i++)
            {
                new Thread( )
                {
                    public void run( )
                    {
                        value1++;
                    }
                }.start( );
                new Thread( )
                {
                    public void run( )
                    {
                        value2.addAndGet(1);//value++的原子操作
                    }
                }.start( );
            }
            while (Thread.activeCount( ) > 2)
            {
                Thread.yield( );
            }
            System.out.println(value1);
            System.out.println(value2);
        }
    }
    

    print

    99996
    100000
    

无同步方案

如果一个方法不涉及共享数据,那么他天生就是线程安全的

可重入代码

可以在代码执行的任何时刻中断它,转而去执行另外一段代码,在控制权返回之后,原来的程序不会出现任何的错误

  1. 一个方法返回结果是可以预测的,输入了相同的数据,就能返回相同的结果,那这个方法就具有可重入性,也就是线程安全的

  2. 栈封闭是一种可重用代码

    多个线程访问同一个方法的局部变量时,不会出现线程安全问题,因为局部变量保存在虚拟机栈中,属于线程的私有区域,所以不会出现线程安全性

    public class ThreadTest
    {
        static void add( )
        {
            int value = 0;
            for (int i = 0; i < 1000; i++)
            {
                value++;
            }
            System.out.println(value);
        }
    
        public static void main(String[] args)
        {
            ExecutorService threadPool = Executors.newCachedThreadPool( );
            threadPool.execute(( ) -> add( ));
            threadPool.execute(( ) -> add( ));
            threadPool.shutdown( );
        }
    }
    

    print

    1000
    1000
    

线程本地存储

  1. 把共享数据的可见范围限制在同一个线程之内,即便无同步也能做到避免数据争用

  2. 使用 java.lang.ThreadLocal 类来实现线程本地存储功能

    • ThreadLocal 变量是一个不同线程可以拥有不同值的变量,所有的线程可以共享一个ThreadLocal对象
    • 任意一个线程的 ThreadLocal 值发生变化,不会影响其他的线程
    • 用set()和get()方法对ThreadLocal变量进行赋值和查看其值
    public class ThreadLocalDemo
    {
        public static void main(String[] args)
        {
            ThreadLocal threadLocal1 = new ThreadLocal( );
            Thread t1 = new Thread(( ) ->
            {
                threadLocal1.set(1);
                try
                {
                    Thread.sleep(3000);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace( );
                }
                System.out.println(threadLocal1.get( ));
            });
            Thread t2 = new Thread(( ) -> threadLocal1.set(2));
            t1.start( );
            t2.start( );
        }
    }
    

    print

    1
    
  3. ThreadLocal 原理

    • 每个线程都有一个 ThreadLocal.ThreadLocalMap 对象,调用 threadLocal1.set(T value) 方法时,将 threadLoacl1 和 value 键值对存入 map
    • ThreadLocalMap 底层数据结构可能导致内存泄露,尽可能在使用 ThreadLocal 后调用 remove()方法

死锁

死锁条件

  1. 互斥条件
  2. 请求与保持条件
  3. 不可剥夺条件
  4. 循环等待条件(环路条件)

Java死锁示例

public static void main(String[] args)
{
    Object o1 = new Object( );
    Object o2 = new Object( );

    Thread t1 = new Thread( )
    {
        public void run( )
        {
            synchronized (o1)//占有 o1
            {
                System.out.println("t1 已占有 O1");
                try
                {
                    Thread.sleep(1000);//停顿1000毫秒,另一个线程有足够的时间占有 o1
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace( );
                }
                System.out.println("t1 试图占有 o2");
                System.out.println("t1 等待中");
                synchronized (o2)
                {
                    System.out.println("t1 已占有 O2");
                }
            }
        }
    };
    Thread t2 = new Thread( )
    {
        public void run( )
        {
            synchronized (o2)  //占有 o2
            {
                System.out.println("t2 已占有 o2");
                try
                {
                    Thread.sleep(1000);//停顿1000毫秒,另一个线程有足够的时间占有 o2
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace( );
                }
                System.out.println("t2 试图占有 o1");
                System.out.println("t2 等待中");
                synchronized (o1)
                {
                    System.out.println("t2 已占有 O1");
                }
            }
        }
    };
    t1.start( );
    t2.start( );
}

print

t1 已占有 O1
t2 已占有 o2
t1 试图占有 o2
t1 等待中
t2 试图占有 o1
t2 等待中

线程通信

  1. Object 类方法

    方法 描述
    wait() 线程进入等待池
    notify() 唤醒等待当前线程锁的线程
    notifyAll() 唤醒所有线程,优先级高的优先唤醒

    为什么这些方法设置在 Object 对象上?

    表面上看,因为任何对象都可以加锁

    底层上说,java 多线程同步的 Object Monitor 机制,每个对象上都设置有类似于集合的数据结构,储存当前获得锁的线程、等待获得锁的线程(lock set)、等待被唤醒的线程(wait set)

  2. 生产者消费者模型

    • sleep 方法,让出 cpu,但不放下锁
    • wait 方法,进入锁对象的等待池,放下锁
public class ProducerAndConsumer
{
    public static void main(String[] args)
    {
        Goods goods = new Goods();
        Thread producer = new Thread()//生产者线程
        {
            public void run()
            {
                while (true) goods.put();
            }
        };
        Thread consumer = new Thread()//消费者线程
        {
            public void run()
            {
                while (true) goods.take();
            }
        };
        consumer.start();
        producer.start();
    }
}
class Goods//商品类
{
    int num = 0;//商品数目
    int space = 10;//空位总数
    public synchronized void put()
    {
        if (num < space)//有空位可放,可以生产
        {
            num++;
            System.out.println("放入一个商品,现有" + num + "个商品," + (space - num) + "个空位");
            notify();//唤醒等待该锁的线程
        }
        else//无空位可放,等待空位
        {
            try
            {
                System.out.println("没有空位可放,等待拿出");
                wait();//进入该锁对象的等待池
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
    public synchronized void take()
    {
        if (num > 0)//有商品可拿
        {
            num--;
            System.out.println("拿出一个商品,现有" + num + "个商品," + (space - num) + "个空位");
            notify();//唤醒等待该锁的线程
        }
        else///等待生产产品
        {
            try
            {
                System.out.println("没有商品可拿,等待放入");
                wait();//进入该锁对象的等待池
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
}

print

没有商品可拿,等待放入
放入一个商品,现有1个商品,9个空位
放入一个商品,现有2个商品,8个空位
拿出一个商品,现有1个商品,9个空位
放入一个商品,现有2个商品,8个空位
放入一个商品,现有3个商品,7个空位
放入一个商品,现有4个商品,6个空位
拿出一个商品,现有3个商品,7个空位
放入一个商品,现有4个商品,6个空位
···

线程池

线程的启动和结束都是比较消耗时间和占用资源的,如果在系统中用到了很多的线程,大量的启动和结束动作会严重影响性能

线程池很像生产者消费者模式,消费的对象是一个一个的能够运行的任务

  1. 设计思路

    • 准备任务容器,可用 List,存放任务
    • 线程池类构造方法中创建多个执行者线程
    • 任务容器为空时,所有线程 wait
    • 当外部线程向任务容器加入任务,就会有执行者线程被 notify
    • 执行任务完毕后,没有接到新任务,就回归等待状态
  2. 实现一个线程池

    public class ThreadPool
    {
        int poolSize;// 线程池大小
        LinkedList<Runnable> tasks = new LinkedList<Runnable>();// 任务容器
        public ThreadPool(int poolSize)
        {
            this.poolSize = poolSize;
            synchronized (tasks)//启动 poolSize 个任务执行者线程
            {
                for (int i = 0; i < poolSize; i++)
                {
                    new ExecuteThread("执行者线程 " + i).start();
                }
            }
        }
        public void add(Runnable r)//添加任务
        {
            synchronized (tasks)
            {
                tasks.add(r);
                System.out.println("加入新任务");
                tasks.notifyAll();// 唤醒等待的任务执行者线程
            }
        }
        class ExecuteThread extends Thread//等待执行任务的线程
        {
            Runnable task;
            public ExecuteThread(String name)
            {
                super(name);
            }
            public void run()
            {
                System.out.println("启动:" + this.getName());
                while (true)
                {
                    synchronized (tasks)
                    {
                        while (tasks.isEmpty())
                        {
                            try
                            {
                                tasks.wait();
                            }
                            catch (InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                        }
                        task = tasks.removeLast();
                        tasks.notifyAll(); // 允许添加任务的线程可以继续添加任务
                    }
                    System.out.println(this.getName() + " 接到任务");
                    task.run();//执行任务
                }
            }
        }
        public static void main(String[] args)
        {
            ThreadPool pool = new ThreadPool(3);
            for (int i = 0; i < 5; i++)
            {
                Runnable task = new Runnable()//创建任务
                {
                    public void run()//任务内容
                    {
                        System.out.println(Thread.currentThread().getName()+" 执行任务");
                    }
                };
                pool.add(task);//加入任务
                try
                {
                    Thread.sleep(1000);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
    

    print

    main 加入新任务
    启动:执行者线程 0
    执行者线程 0 接到任务
    执行者线程 0 执行任务
    启动:执行者线程 1
    启动:执行者线程 2
    main 加入新任务
    执行者线程 2 接到任务
    执行者线程 2 执行任务
    main 加入新任务
    执行者线程 2 接到任务
    执行者线程 2 执行任务
    
  3. java 线程池类

    • 默认线程池类 ThreadPoolExecutor 在 java.util.concurrent 包下

      ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
      /*
      第一个参数 int 类型, 10 表示这个线程池初始化了 10 个线程在里面工作
      第二个参数 int 类型, 15 表示如果 10 个线程不够用了,就会自动增加到最多 15个 线程
      第三个参数 60 结合第四个参数 TimeUnit.SECONDS,表示经过 60 秒,多出来的线程还没有接到任务,就会回收,最后保持池子里就 10 个
      第五个参数 BlockingQueue 类型,new LinkedBlockingQueue() 用来放任务的集合
      */
      
    • execute() 方法添加新任务

      public class TestThread 
      {   
          public static void main(String[] args) throws InterruptedException 
          {
              ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
              threadPool.execute(new Runnable()
              {//添加任务
                  public void run() 
                  {
                      System.out.println("执行任务");
                  }    
              });
          }
      }
      
  4. java 中几种线程池

    java 线程池的顶级接口是 Executor ,子接口是 ExecutorService ,子接口使用更广泛

    Executors 类提供了一系列工厂方法用于创建线程池,返回的线程池实现了 ExecutorService 接口

    • newCachedThreadPool有缓冲的线程池,线程数 JVM 控制,有线程可使用时不会创建新线程
    • newFixedThreadPool,固定大小的线程池,任务量超过线程数时,任务存入等待队列
    • newScheduledThreadPool,创建一个线程池,可安排在给定延迟后运行命令或者定期地执行
    • newSingleThreadExecutor,只有一个线程,顺序执行多个任务,若意外终止,则会新创建一个
    ExecutorService threadPool = null;
    threadPool = Executors.newCachedThreadPool();//缓冲线程池
    threadPool = Executors.newFixedThreadPool(3);//固定大小的线程池
    threadPool = Executors.newScheduledThreadPool(2);//定时任务线程池
    threadPool = Executors.newSingleThreadExecutor();//单线程的线程池
    threadPool = new ThreadPoolExecutor(···);//默认线程池,多个可控参数
    

线程安全类

  1. StringBuffer:内部方法用 synchronized 修饰
  2. Vetort:继承于 AbstractList
  3. Stack:继承于 Vector
  4. HashTable:继承于 Dictionary,实现了 Map 接口
  5. Property:继承于 HashTable,实现了 Map 接口
  6. concurrentHashMap:分段加锁机制

原文出处:https://www.cnblogs.com/pgjett/p/12340772.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部