【基础】Java 并发编程（上）

JUC 概述

什么是 JUC？

JUC 指 Java 提供的三大并发编程包，即：

• java.util.concurrent

• java.util.concurrent.atomic

• java.util.concurrent.locks

线程与进程

• 进程就是一个程序，如 windows 系统中运行的 .exe 程序，可以在任务管理器中查看

• 线程是由进程控制和开启的，Java 中默认有两个线程：main 主线程以及 GC 线程

并发与并行

• 并发是指对线程操作同一资源，即在很短的时间内让各个线程交替运行。并发编程的本质是充分利用 CPU 资源

• 并行是指多核多线程同时运行

线程基础概述

线程的状态

状态	简介
NWE	新生态，新创建的线程在还未调用 start() 方法时所处的状态
RUNNABLE	运行态，处于该状态的线程可能正在运行，也可能正在等待 CPU 资源
BLOCKED	阻塞态，当线程准备执行同步方法或访问加锁的公共内存空间时，需要申请相应的锁，申请锁的等待会使线程进入阻塞状态
WAITING	等待态，线程调用 Object.wait() 或者 Thread.join() 方法后会进入该状态，处于该状态的线程在等待其他线程将其唤醒
TIMED_WAITING	超时等待态，与上一状态一致，只不过该状态存在一个超时时间，若等待时间超过设置的超时时间则自动唤醒
TERMINATED	消亡态，run() 方法执行结束则表示线程处于消亡状态

线程的活性故障

由于资源稀缺或程序自身的问题导致线程一直处于非运行状态且其处理的任务一直无法完成的现象称为线程的活性故障，常见的活性故障包括死锁、锁死、活锁以及线程饥饿

活性故障	简介
死锁	死锁是最常见的活性故障，其起因是多个线程相互持有对方所需的资源而导致永远相互等待，死锁的形成需要符合四个必要条件
锁死	线程锁死指处于等待状态的线程的唤醒条件永远无法成立而导致该线程一直处于非运行状态，其与死锁的不同在于，即使四个必要条件都没有发生仍然有可能形成锁死
活锁	活锁是一种特殊的活性故障，指线程一直处于运行状态但是其执行的任务却没有任何进展，比如一个线程一直在申请所需的资源但却无法申请成功
线程饥饿	线程饥饿指线程一直无法获取其所需的资源而导致任务一直无法进行，在线程的非公平调度模式下，就有可能出现线程饥饿的问题

死锁的必要条件

条件	描述
互斥	某种资源仅允许一个线程访问
不可抢占	某种资源被某一线程占有后其他线程不可抢夺被占有的资源
占有且等待	某线程本身占有一部分必须资源并且等待其他线程释放另外的必须资源
循环等待	没有个线程都占有着其他线程运行所必须的资源

避免死锁的方法

打破上述四个死锁的必要条件即可有效的避免死锁的发生

方法	描述
打破互斥	将独占型资源改造为虚拟资源
打破不可抢占	当某一线程占有一个独占型资源且无法申请得到另一个独占型资源时，则释放原来占有的资源
打破占有且等待	采用资源预先分配策略，在程序执行前申请所需的全部资源，若资源满足则运行，不满足则等待
打破循环等待	采用资源有序分配策略，对线程进行编号，所有线程根据序号递增的次序申请资源

线程锁死的分类

• 信号丢失锁死：没有相应的通知线程来唤醒等待线程，导致其一直处于等待状态。该情况一般是等待线程在执行等待命令之前没有对唤醒条件进行判断，可能此时唤醒条件已经成立，因此此后无其他条件可以唤醒该线程；

• 嵌套监视器锁死：由于嵌套锁导致等待线程永远无法被唤醒。比如一个线程只释放了内层锁，即执行 Y.wait()，但是没有释放外层锁 X，但是唤醒线程必须先获取到锁 X 才能通过 Y.notifyAll() 唤醒等待线程，导致嵌套等待；

公平调度与非公平调度

• 公平调度：按照申请的先后顺序授予资源的独占权。
  • 优点：吞吐率较高，单位时间内可以为更多的申请者调配资源；不会出现线程饥饿的现象；
  • 缺点：资源申请者申请资源所需的时间偏差可能较大；
• 非公平调度：在该策略中，资源的持有线程释放该资源的时候，等待队列中一个线程会被唤醒，而该线程从被唤醒到其继续执行可能需要一段时间。在该段时间内，新来的线程（活跃线程）可以先被授予该资源的独占权。
  • 优点：线程申请资源所需的时间偏差较小；适合在资源的持有线程占用资源的时间相对长或者资源的平均申请时间间隔相对长的情况下，或者对资源申请所需的时间偏差有所要求的情况下使用；
  • 缺点：吞吐率较小；

多线程中常用函数

方法	描述
sleep()	Thread 类的静态方法，当前线程将睡眠 n 毫秒，线程进入阻塞状态。当睡眠时间到了，会解除阻塞，进入可运行状态，等待 CPU 的到来。睡眠不释放锁（如果有的话）
wait()	Object 的方法，必须与 synchronized 关键字一起使用，线程进入阻塞状态，当 notify() 或者 notifyall() 被调用后，会解除阻塞。但是，只有重新占用互斥锁之后才会进入可运行状态。睡眠时，会释放互斥锁
join()	线程调用该方法后，会进入阻塞，等待被调用 join() 的线程执行完毕，再继续执行
yield()	该方法使得线程放弃当前分得的 CPU 时间。但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间

原子性、可见性以及有序性

多线程下的数据安全主要体现在原子性、可见性以及有效性

• 原子性：指一系列的操作要么同时发生，要么就没有发生，其它线程无法观测到操作的中间过程（类似事务）。注意一点：原子操作+原子操作不一定还是原子操作；

• 可见性：指一个线程对共享变量的更新是否对其他的线程可见；

• 有序性：指其他线程看到的某线程对共享变量的执行顺序；

锁的基本使用

synchronized

关键字 synchronized 的使用示例

public class SynchronizedDemo {
    public static void main(String[] args) {
        // 实例化资源类
        final Ticket ticket = new Ticket();

        // 创建三个线程执行方法，三个线程抢夺 CPU，即抢到钥匙后可以在给定的 CPU 时间块内执行相应的方法
        new Thread(()->{
            for (int i = 0; i < 1000; i ++) {
                ticket.sale();
            }
        }, "售票窗口1").start();

        new Thread(()->{
            for (int i = 0; i < 1000; i ++) {
                ticket.sale();
            }
        }, "售票窗口2").start();

        new Thread(()->{
            for (int i = 0; i < 1000; i ++) {
                ticket.sale();
            }
        }, "售票窗口3").start();

    }
}

/**
 * 内部资源类
 */
class Ticket {

    private int number = 1000;

    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票，剩余" + number);
        }
    }

}

Lock

Lock 是一个接口，Java 为我们提供了以下几个常用的实现类

• ReentrantLock

• ReentrantReadWriteLock.ReadLock

• ReentrantReadWriteLock.WriteLock

可重入锁 ReentrantLock

可重入锁 ReentrantLock 最为常用，其有两个构造方法，分别提供了公平锁和非公平锁

    // 非公平锁：可以插队
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    // 公平锁：存在先来后到
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

可重入锁 ReentrantLock 使用示例

public class ReentrantLockDemo {
    public static void main(String[] args) {
        // 实例化资源类
        final Ticket2 ticket = new Ticket2();

        // 创建三个线程执行方法
        new Thread(()->{
            for (int i = 0; i < 1000; i ++) {
                ticket.sale();
            }
        }, "售票窗口1").start();

        new Thread(()->{
            for (int i = 0; i < 1000; i ++) {
                ticket.sale();
            }
        }, "售票窗口2").start();

        new Thread(()->{
            for (int i = 0; i < 1000; i ++) {
                ticket.sale();
            }
        }, "售票窗口3").start();

    }

}

/**
 * 内部资源类
 */
class Ticket2 {

    private int number = 1000;

    /**
     * Lock锁的使用：
     * 1. new ReentrantLock() // 实例化锁对象
     * 2. lock.lock();        // 加锁
     * 3. lock.unlock();      // 解锁
     */
    Lock lock = new ReentrantLock();

    public void sale() {
        lock.lock(); // 加锁
        try {
            // 业务代码
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票，剩余" + number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 解锁
        }
    }

}

读写锁 ReentrantReadWriteLock

ReentrantReadWriteLock 维护一对关联的锁，一个用于只读操作，一个用于写操作

读写锁 ReentrantReadWriteLock 使用示例

public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {
        // 加读写锁，只允许单线程写，允许多线程读
        MyCacheLock cache = new MyCacheLock();

        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                cache.put(temp + "", temp);
            }, "写入线程" + i).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                cache.get(temp + "");
            }, "读取线程" + i).start();
        }
    }

}

class MyCacheLock {
    private final Map<String, Object> map = new HashMap<>();

    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入完成...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取完成...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

比较 synchronied 与 ReentrantLock

synchronized	ReentrantLock
Java 内置的关键字	java.util.concurrent 包下提供的一套互斥锁
可以修饰方法和代码块	只能修饰代码块，需要配合 try/finally 代码块来完成
无法获取锁的状态	可以判断是否获取了锁
自动释放锁	必须手动释放锁，否则会形成死锁
非公平锁	可以设置公平锁或非公平锁
只能随机唤醒一个或唤醒全部线程	一个锁可以绑定多个条件，ReentranLock 提供了一个 Condition 类，可以实现分组唤醒需要唤醒的线程
适合处理少量代码的同步问题	适合处理大量代码的同步问题

synchronized 关键字

synchronized 是 Java 中的一个关键字，是一个内部锁。它可以使用在方法上和方法块上，表示同步方法和同步代码块。

在多线程环境下，同步方法或者同步代码块在同一时刻只允许有一个线程在执行，其余线程都在等待获取锁，也就是实现了整体并发中的局部串行。

synchronized 的底层实现

synchronized 又称为内置锁，使用 synchronized 修饰的代码块在字节码引擎中执行时，是通过锁对象的 monitor 的取用和释放实现的。

monitor 内置于任意一个对象，因此任何对象都可以作为锁对象使用。

synchronized 修饰的同步代码块的执行过程如下：

• 在进入代码块时，执行 monitorenter()，将计数器 +1；执行结束释放锁时，执行 monitorexit()，并将计数器 -1

• 线程在获取锁时，判断计数器的数值，若为 0，则表示当前锁空闲，可以占用；否则则进入等待状态

synchronized 锁的目标

1. synchronized 锁的是方法的调用者

   public class SynchronizedDemo01 {
       /**
        * synchronized 锁的是方法的调用者，即实例化的对象，故两个方法使用的是一把锁，故谁先拿到，谁先执行
        * 该 demo 中，首先执行“发短信”，然后执行“打电话”
        */
       public static void main(String[] args) {
   
           Phone01 phone = new Phone01();
   
           new Thread(()->{
               phone.sendMsg();
           }).start();
   
           try {
               TimeUnit.SECONDS.sleep(1);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
   
           new Thread(()->{
               phone.call();
           }).start();
       }
   }
   
   class Phone01 {
       public synchronized void sendMsg() {
           try {
               TimeUnit.SECONDS.sleep(5);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("发短信");
       }
       public synchronized void call() {
           System.out.println("打电话");
       }
   }
   

2. 普通方法不受锁的影响

   public class SynchronizedDemo02 {
       /**
        * 普通方法不受锁的影响，故执行普通方法的线程可以立即执行，而不需要等待获取锁
        * 该 demo 中，首先执行“hello~”，然后执行“发短信”，最后执行"打电话"
        */
       public static void main(String[] args) {
   
           Phone02 phone = new Phone02();
   
           new Thread(()->{
               phone.sendMsg();
           }).start();
   
           try {
               TimeUnit.SECONDS.sleep(1);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
   
           new Thread(()->{
               phone.call();
           }).start();
   
           new Thread(()-> {
               phone.hello();
           }).start();
       }
   }
   
   class Phone02 {
       public synchronized void sendMsg() {
           try {
               TimeUnit.SECONDS.sleep(5);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("发短信");
       }
       public synchronized void call() {
           System.out.println("打电话");
       }
       public void hello() {
           System.out.println("hello~");
       }
   }
   

3. 静态的同步方法，锁的是 Class

   public class SynchronizedDemo03 {
       /**
        * static 修饰的静态同步方法，锁的是 Class 类
        * 该 demo 中，首先执行“打电话”，然后执行“玩游戏”，最后执行"发短信"
        */
       public static void main(String[] args) {
   
           Phone03 phone = new Phone03();
   
           new Thread(()->{
               phone.sendMsg();
           }).start();
   
           try {
               TimeUnit.SECONDS.sleep(1);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
   
           new Thread(()->{
               phone.call();
           }).start();
   
           try {
               TimeUnit.SECONDS.sleep(1);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
   
           new Thread(()-> {
               phone.game();
           }).start();
       }
   }
   
   class Phone03 {
       public synchronized void sendMsg() {
           try {
               TimeUnit.SECONDS.sleep(5);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("发短信");
       }
       public static synchronized void call() {
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("打电话");
       }
       public static synchronized void game() {
           System.out.println("玩游戏");
       }
   }
   

synchronized 锁的状态

状态	简介
无锁	无锁指对资源没有任何限制，所有的线程都可以访问并修改某一共享资源，但只有最后一个线程的修改结果被保留
偏向锁	偏向锁指一段同步代码一直被同一线程访问执行，即不存在多线程之间资源的竞争，则该线程在后续访问同步代码段时可以自动获得锁，以降低锁的获取带来的性能损耗
轻量级锁	若当前锁状态为偏向锁，此时存在其他线程访问同步代码段，此时偏向锁便会升级为轻量级锁，其他线程将通过自旋的方式尝试获取锁，线程不会阻塞
重量级锁	重量级锁指当某一个线程获取到锁时，其他所有等待获取该锁的线程将全部处于阻塞状态

synchronized 锁升级

synchronized 锁升级的原理主要依赖锁对象头中的 threadId 字段：

• 当线程第一次访问锁对象时，threadId 为空，此时为偏向锁，同时将 threadId 设置为线程 Id

• 当线程再次访问同步代码块时，首先判断锁对象的 threadId 与线程 Id 是否一致，若一致则直接获得锁；若不一致，则锁升级为轻量级锁，线程通过自旋等待获取锁

• 当自旋一定次数还没有获取锁时，轻量级锁升级为重量级锁

上述过程即 synchronized 锁升级的过程，锁升级的目的是降低锁的获取和释放过程中的性能损耗。

volatile 关键字

volatile 是一个轻量级的锁，在使用时可以将多个线程共享的一组状态变量合并成一个对象，使用 volatile 来修饰。

volatile 可以保证可见性和有序性，但是不能保证原子性：

• volatile 可以保证主内存和工作内存直接交互进行读写操作，从而保证可见性；

• volatile 仅能保证变量写操作的原子性，但不能保证读写操作的原子性；

• volatile 可以通过插入指令屏障的方式禁止指令重排序，典型案例是在单例模式中的使用；

线程池 ThreadLocal

线程池的优势包括降低资源的消耗、提高响应速度以及便于管理，其核心包括三大方法、七大参数以及四种拒绝策略。

Executors 工具类 - 三大方法

public class ExecutorsDemo {

    public static void main(String[] args) {
        // 创建单个线程的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        // 创建一个固定大小的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        // 创建一个大小可伸缩的线程池（遇强则强，遇弱则弱）
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        // 线程池的使用
        try {
            for (int i = 0; i < 100; i++) {
                // 使用线程池来创建线程
                fixedThreadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "--OK!");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池使用完毕要释放资源，关闭线程池
            fixedThreadPool.shutdown();
        }
    }

}

Executors 工具类构造线程池的源码：

    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

查看源码，发现三种方法构造的线程池都是通过创建 ThreadPoolExecutor 对象，通过传入不同的构造参数实现的。

ThreadPoolExecutor - 七大参数

使用 ThreadPoolExecutor 创建线程池的七大参数

    /**
     * corePoolSize：核心线程池大小
     * maximumPoolSize：最大核心线程池大小
     * keepAliveTime：超时时间(超过这个时间没人调用就会释放)
     * unit：超时单位
     * workQueue：阻塞队列
     * threadFactory：线程工厂(创建线程使用，一般不用动)
     * defaultHandler：拒绝策略
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

ThreadPoolExecutor 创建线程池并使用

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        // 可以理解为银行柜台办理业务的场景
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2, // 当前开放的柜台窗口数
                5, // 全部的柜台窗口数
                3, // 某一柜台的等待时间，超过后柜台关闭
                TimeUnit.SECONDS, // 超时时间的单位
                new LinkedBlockingQueue<>(3), // 等待区座位数
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy() // 拒绝策略
        );
        
        try {
            for (int i = 0; i < 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "--OK!");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }

}

ThreadPoolExecutor - 四种拒绝策略

策略	描述
ThreadPoolExecutor.AbortPolicy()	直接抛出异常
ThreadPoolExecutor.CallerRunsPolicy()	哪来的回哪去（交由主进程处理）
hreadPoolExecutor.DiscardPolicy()	直接丢掉任务，不会抛出异常
ThreadPoolExecutor.DiscardOldestPolicy():	尝试与最早的进行竞争，不会抛出异常

常见的阻塞队列

阻塞队列	数据结构	优点	缺点	适用场景
ArrayBlockingQueue	内部使用一个数组作为其存储空间，数组的存储空间是预先分配的	put 和 take 操作不会增加 GC 的负担（因为空间是预先分配的）	put 和 take 操作使用同一个锁，可能导致锁争用，导致较多的上下文切换	适合在生产者线程和消费者线程之间的并发程序较低的情况下使用
LinkedBlockingQueue	是一个无界队列(其实队列长度是Integer.MAX_VALUE)，内部存储空间是一个链表，并且链表节点所需的存储空间是动态分配的	put 和 take 操作使用两个显式锁(putLock 和 takeLock)	增加了 GC 的负担，因为空间是动态分配的	适合在生产者线程和消费者线程之间的并发程序较高的情况下使用
SynchronousQueue	可以被看做一种特殊的有界队列			生产者线程生产一个产品之后，会等待消费者线程来取走这个产品，才会接着生产下一个产品，适合在生产者线程和消费者线程之间的处理能力相差不大的情况下使用

线程池中阻塞队列的作用

队列用先进先出的特点。当放入一个元素时，会放在队列的末尾；取出元素时，会在队列的头部取出。

而当队列为空或队列满的时候，采用阻塞队列会自动帮我们处理这种情况：

• 当阻塞队列为空时，从队列中取出元素的操作就会被阻塞
• 当阻塞队列为满时，往队列中放入元素的操作就会被阻塞
• 一旦空队列有数据了或者满队列有空余位置了，被阻塞的线程就会自动唤醒

所以，采用阻塞队列，我们不需要关心线程何时被阻塞何时被唤醒，一切有阻塞队列自动帮我们完成，我们只需要关心具体的业务逻辑即可。

线程池的处理流程

当我们向线程池提交任务的时候，需要遵循一定的排队策略，具体策略如下：

• 如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队
• 如果运行的线程等于或者多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不是添加新线程
• 如果无法将请求加入队列，即队列已经满了，则创建新的线程，除非创建此线程超出 maxinumPoolSize，在这种情况下，将根据拒绝策略处理

为什么当有任务到来时要先添加队列而不是先创建最大线程？

因为线程的创建和销毁是十分消耗资源的，会影响整体效率。

举例：

一个企业有 10 个正式工 (core)，当任务数量超过正式工人数时，工厂领导( 线程池) 首先不是扩招工人，而是还是使用这 10 个人，将任务稍微积压一下，即先放到队列中 (代价低)。10 个正式工慢慢干，迟早可以完成。

如果任务继续增加，超过正式工的加班忍耐度 (队列满了)，此时就需要招聘外包 (临时工) 来协助工作。

若外包 + 正式工还是不能完成任务，此时就会根据拒绝策略进行相应的处理。
为满时，往队列中放入元素的操作就会被阻塞

• 一旦空队列有数据了或者满队列有空余位置了，被阻塞的线程就会自动唤醒

所以，采用阻塞队列，我们不需要关心线程何时被阻塞何时被唤醒，一切有阻塞队列自动帮我们完成，我们只需要关心具体的业务逻辑即可。