上次更新：2020-02-24

前言

一般我们说并发编程，其实就是让我们的程序执行的更快，我们可以用多线程的，一个线程干活变成多个线程干活。但由于线程是由CPU分配资源进行调度的，多个线程执行一个任务会变得不可控。

拿数钱这个活来说吧，原来一个线程数数2万耗费2秒，该线程的CPU分配的资源用完了，就标记下，当前数到1万了，等再分配到资源后，继续从刚才1万的位置开始数。现在为了加快速度，把数钱这个任务分开，让2个线程数2万，每个线程数1万，这样只要1秒。

  1. // 有问题
  2. static int totalMoney = 0;
  3. public static void main(String[] args) throws Exception {
  4.     final int count = 10000;
  5.     Thread thread1 = new Thread(() -> {
  6.         for (int i = 0; i < count; i++) {
  7.             totalMoney++;
  8.         }
  9.     });
  10.     Thread thread2 = new Thread(() -> {
  11.         for (int i = 0; i < count; i++) {
  12.             totalMoney++;
  13.         }
  14.     });
  16.     thread1.start();
  17.     thread2.start();
  18.     thread1.join();
  19.     thread2.join();
  20.     // 结果小于2万
  21.     System.out.println(totalMoney);
  22. }

理想很美好，现实很骨感。上述结果最后得到的是小于2万的。但是要解决数钱这个问题，有很多种手段，这就要学习并发编程了。

上面啰里啰嗦的说了一大堆，总结起来并发编程有三个核心问题：分工、同步和互斥

  • 分工：将一个任务拆成若干个子任务去完成
  • 同步：子任务有的执行快，有的执行慢，如何保证大家的步调一致
  • 互斥：上述两步是为了提供程序的性能，互斥是为了解决程序的正确性

将一个大问题拆解成三个小问题，逐个攻破。

一些基本的理论，不会再去讲，网上有很多了，假设读者已经知道这几点：

  1. 什么是进程
  2. 什么是线程
  3. 进程、线程的关系
  4. 线程的几种状态
  5. 并行和并发的概念

Java内存模型

有必要了解下一些约定好的规则。

Happens-Before规则

它约束了编译器的优化行为，前面一个操作的结果对后续操作是可见的，提出了六项规则：

1. 顺序性原则

程序中某个变量的更该对于后续一定是可见的

2. volatile 变量原则

对一个volatile变量的写操作对后续这个volatile变量读操作是可见的

3. 传递性

如果 A Happens-Before B，且 B Happens-Before C，那么 A Happens-Before C

4. 管程中锁的规则

一个锁的解锁 Happens-Before 于后续对这个锁的加锁

5. start()规则

主线程 A 启动子线程 B 后，子线程 B 能够看到主线程在启动子线程 B 前的操作

6. join()规则

线程A等待线程B完成（调用了线程B的join()方法），线程B完成后，线程A能看到线程B的操作

使用

线程使用

  1. 继承 Thread 类

    1. class MyThread extends Thread {
    2.  @Override
    3.  public void run() {
    4.      System.out.println(Thread.currentThread().getName());
    5.  }
    6. }

  2. 实现 Runnable 接口

    1. class MyThread implements Runnable {
    2. @Override
    3. public void run() {
    4.    System.out.println(Thread.currentThread().getName());
    5. }
    6. }

  3. Callable

    1. class MyThread implements Callable {
    2.  @Override
    3.  public Object call() throws Exception {
    4.      System.out.println("hello world " + Thread.currentThread().getName());
    5.      return "hello world ";
    6.  }
    7. }

  4. Lambda 的形式

    1. new Thread(() -> 
    2.  System.out.println("hello world " + Thread.currentThread().getName()
    3. ).start();

线程休眠

sleep();阻塞，让出CPU资源

  1. Thread.sleep();

线程让出CPU资源

yield(); 当前线程愿意让出已获得的 CPU 执行资源，由系统重新进行调度。

  1. Thread.yield();

线程等待

join(); 会阻塞当前线程，直到另一线程执行结束

  1. public static void main(String[] args) {
  2.     Thread threadA = new Thread(() -> {
  3.     try {
  4.         Thread.sleep(1000);
  5.         } catch (Exception e) {
  6.         }
  7.         System.out.println("线程A执行结束");
  8.     });
  10.     Thread threadB = new Thread(() -> {
  11.     try {
  12.         // 这里会阻塞，直到线程A执行结束
  13.         threadA.join();
  14.         System.out.println("线程B开始执行");
  15.         } catch (Exception e) {
  16.     }
  17.     });
  18.     // 输出结果：
  19.     // 线程A执行结束
  20.     // 线程B开始执行
  21.     threadB.start();
  22.     threadA.start();
  23. }

wait()/notify()

这两个方法在 Object 类中，也就是说所有的类都有可以使用，用来等待和通知，调用前需要获取锁

  1. public static void main(String[] args) {
  2.     ObjectWaitNotify objectWaitNotify = new ObjectWaitNotify();
  4.     new Thread(() -> {
  5.         try {
  6.             System.out.println("等待中...");
  7.             synchronized (objectWaitNotify) {
  8.                 objectWaitNotify.wait();
  9.             }
  10.             System.out.println("被唤醒了，等待结束...");
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.     }).start();
  16.     new Thread(() -> {
  17.         try {
  18.             Thread.sleep(2000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         synchronized (objectWaitNotify) {
  23.             objectWaitNotify.notify();
  24.         }
  25.         System.out.println("唤醒...");
  26.     }).start();
  27. }

ThreadLocal

ThreadLocal，让每个线程可以有自己的局部空间，实现线程之间的隔离。本质是一个 Map, key 就是其本身，value 则存的数据，而且 key 的引用类型是 WeakReference，这样就保证了一旦该线程结束，下次GC就会被回收，从而防止内存泄漏。

典型应用就是Spring的事务管理器中。

  1. public static void main(String[] args) {
  2.     ThreadLocal<String> threadLocalA = new ThreadLocal<>();
  3.     ThreadLocal<String> threadLocalB = new ThreadLocal<>();
  4.     threadLocalA.set("A-1");
  5.     threadLocalB.set("B-1");
  6.     // 输出： A-1
  7.     System.out.println(threadLocalA.get());
  8.     // 输出： B-1
  9.     System.out.println(threadLocalB.get());
  10. }

final

被 final 关键字修饰的变量是不可以改变的，编译器可以使劲的优化。

volatile

它是一个关键字，用来修饰变量。通过插入内存屏障指令禁止编译器和CPU对程序进行重排序。
特性：

  1. 数据的可见性，一个线程修改了值，另一个线程可以马上得知。
  2. 禁止指令重排序

    可见性

    导致可见性的原因是缓存。每个线程都有自己的内存空间，volatile 的作用就是让线程操作该变量时不使用自己的内存，而是直接操作内存，这样每修改该变量，其它线程都能看得到，保证了数据的可见性。

重排序

导致有序性的原因是编译优化。为了性能优化，JMM 在不改变正确语义的前提下，会允许编译器和处理器对指令序列进行重排序。使用了 volatile 可以禁止重排序。比如在单例中的经典使用：

  1. public class DoubleCheckSingleton {
  2.     /**
  3.      *  volatile 禁止指令重排，可见性
  4.      */
  5.     private volatile static DoubleCheckSingleton doubleCheckSingleton;
  7.     private DoubleCheckSingleton () {
  8.     }
  10.     public static DoubleCheckSingleton getSingleton() {
  11.         if (null == doubleCheckSingleton) {
  12.             synchronized (DoubleCheckSingleton.class) {
  13.                 if (doubleCheckSingleton == null) {
  14.                     doubleCheckSingleton = new DoubleCheckSingleton();
  15.                 }
  16.             }
  17.         }
  18.         return doubleCheckSingleton;
  19.     }
  20. }

synchronized

synchronzied 保证线程同步，是可重入锁，会存在阻塞，导致线程的上下文切换。Java中每个对象都有对象都有一个对象头，锁的对象就是存放在这里面的。

反编译一个 class 文件： javap -verbose xxx.class 得到如下结果(截取部分片段)，会在 synchronized 块中插入 monitorenter 和 monitorexit：

  1. public static void main(String[] args) {
  2.     ThreadDemo demo = new ThreadDemo();
  3.     int i = 0;
  4.     synchronized (demo) {
  5.         i ++;
  6.     }
  7.     System.out.println(i);
  8. }
  9. //=============反编译后的============================
  10. 13: monitorenter        # 进入
  11. 14: iinc          2, 1
  12. 17: aload_3
  13. 18: monitorexit         # 退出

image.png

线程同步:

  1. public class SynchronizedDemo2 implements Runnable{
  3.     private int count = 5;
  5.     @Override
  6.     public synchronized void run() {
  7.         try {
  8.             // 为了效果，否则太快了
  9.             Thread.sleep(10);
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         count--;
  14.         // 打印结果每个count值不相等
  15.         System.out.println(count);
  16.     }
  18.     public static void main(String[] args) {
  19.         SynchronizedDemo2 s1 = new SynchronizedDemo2();
  21.         // 一个对象多次访问共享数据，需要在方法中加synchronized，对象锁来保证数据正确，
  22.         for (int i=0; i< 5; i++) {
  23.             new Thread(s1).start();
  24.         }
  25.     }
  26. }

ReentrantLock

用法比 Synchronized 更灵活，有多个构造方法可以使用，例如锁是否公平等等

  1. public class ReentrantLockDemo implements Runnable{
  2.     /**
  3.      * true设置为公平锁，反之
  4.      */
  5.     private ReentrantLock lock = new ReentrantLock(true);
  7.     @Override
  8.     public void run() {
  9.         for (int i=0; i<2; i++) {
  10.             try {
  11.                 // 先获取锁
  12.                 lock.lock();
  13.                 System.out.println(Thread.currentThread().getName() + " get lock!");
  14.                 Thread.sleep(1);
  15.             }catch (Exception e) {
  16.                 e.printStackTrace();
  17.             }finally {
  18.                 // 一定要在finally释放锁
  19.                 lock.unlock();
  20.             }
  21.         }
  22.     }
  23.     public static void main(String[] args) {
  24.         ReentrantLockDemo rntrt = new ReentrantLockDemo();
  25.         Thread t1 = new Thread(rntrt,"T1");
  26.         Thread t2 = new Thread(rntrt,"T2");
  27.         // 打印结果，交替获取锁
  28.         t1.start();
  29.         t2.start();
  30.     }
  31. }

Condition

通过 Lock 获取，提供的 await() 和 signal() 功能和 wait() 和 notify 类似，但是实现机制不一样，而且更灵活

  1. public class ConditionDemo {
  3.     public static void main(String[] args) {
  4.         WaitSignal waitSignal = new WaitSignal();
  6.         new Thread(() -> {
  7.             try {
  8.                 System.out.println("等待中...");
  9.                 waitSignal.await();
  10.                 System.out.println("被唤醒了，等待结束...");
  11.             } catch (Exception e) {
  12.                 e.printStackTrace();
  13.             }
  14.         }).start();
  16.         new Thread(() -> {
  17.             try {
  18.                 Thread.sleep(2000);
  19.             } catch (InterruptedException e) {
  20.                 e.printStackTrace();
  21.             }
  22.             waitSignal.signal();
  23.             System.out.println("唤醒");
  24.         }).start();
  26.     }
  27.     static class WaitSignal {
  29.         private final ReentrantLock lock;
  30.         private final Condition condition;
  32.         public WaitSignal() {
  33.             lock = new ReentrantLock();
  34.             condition = lock.newCondition();
  35.         }
  36.         public void await() throws InterruptedException {
  37.             // 先获取锁
  38.             lock.lock();
  39.             condition.await();
  40.             lock.unlock();
  41.         }
  42.         public void signal() {
  43.             lock.lock();
  44.             condition.signal();
  45.             lock.unlock();
  46.         }
  47.     }
  48. }

原子操作

J.U.C下 的 atomic 包提供了很多原子操作的类，使用上都类似，也好理解

  1. public class IntegerAtomicDemo {
  3.     public static void main(String[] args) throws InterruptedException {
  4.         AtomicLong atomicLong = new AtomicLong(100);
  5.         System.out.println(atomicLong.get());
  7.         atomicLong.set(101);
  8.         System.out.println(atomicLong.get());
  10.         System.out.println(atomicLong.compareAndSet(100, 102));
  11.         System.out.println(atomicLong.compareAndSet(101, 500));
  12.         System.out.println(atomicLong.incrementAndGet());
  13.         System.out.println(atomicLong.getAndIncrement());
  14.         System.out.println(atomicLong.get());
  15.     }
  16. }

CountDownLatch

线程协同工具，用“乘客到齐再发车”来形容再形象不过了

  1. public class CountDownLatchDemo {
  3.     public static void main(String[] args) {
  4.         try {
  5.             new CountDownLatchDemo().go();
  6.         } catch (InterruptedException e) {
  7.             e.printStackTrace();
  8.         }
  9.     }
  11.     private void go() throws InterruptedException {
  12.         CountDownLatch countDownLatch = new CountDownLatch(3);
  13.         new Thread(new Task(countDownLatch),"Thread1").start();
  15.         new Thread(new Task(countDownLatch),"Thread2").start();
  17.         new Thread(new Task(countDownLatch),"Thread3").start();
  19.         countDownLatch.await();
  20.         System.out.println("所有线程已经到达，主线程开始执行 " + System.currentTimeMillis());
  22.     }
  24.     class Task implements Runnable {
  25.         private CountDownLatch countDownLatch;
  27.         public Task(CountDownLatch countDownLatch) {
  28.             this.countDownLatch = countDownLatch;
  29.         }
  30.         @Override
  31.         public void run() {
  32.             System.out.println("线程" + Thread.currentThread().getName() + " 已到达 " + System.currentTimeMillis());
  33.             // 减一个
  34.             this.countDownLatch.countDown();
  35.         }
  36.     }
  37. }

CyclicBarrier

译为循环栅栏，和 CountDownLatch 类似，但是它可以循环使用

  1. public class CyclicBarrierDemo {
  4.     public static void main(String[] args) {
  5.         try {
  6.             new CyclicBarrierDemo().go();
  7.         } catch (InterruptedException e) {
  8.             e.printStackTrace();
  9.         }
  10.     }
  12.     private void go() throws InterruptedException {
  14.         // 第一个参数是要等待的数量，另一个是执行的操作
  15.         CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
  16.             @Override
  17.             public void run() {
  18.                 System.out.println("所有线程已经完成：" + System.currentTimeMillis());
  19.             }
  20.         });
  22.         new Thread(new Task(cyclicBarrier), "Thread1").start();
  23.         new Thread(new Task(cyclicBarrier), "Thread2").start();
  24.         new Thread(new Task(cyclicBarrier), "Thread3").start();
  25.         new Thread(new Task(cyclicBarrier), "Thread1").start();
  27.         cyclicBarrier.reset();
  28.         new Thread(new Task(cyclicBarrier), "Thread1").start();
  29.         new Thread(new Task(cyclicBarrier), "Thread2").start();
  30.         new Thread(new Task(cyclicBarrier), "Thread3").start();
  32.     }
  34.     class Task implements Runnable {
  35.         private CyclicBarrier cyclicBarrier;
  37.         public Task(CyclicBarrier cyclicBarrier) {
  38.             this.cyclicBarrier = cyclicBarrier;
  39.         }
  41.         @Override
  42.         public void run() {
  43.             System.out.println("线程" + Thread.currentThread().getName() + " 已到达 " + System.currentTimeMillis());
  44.             try {
  45.                 cyclicBarrier.await();
  46.             } catch (Exception e) {
  47.                 e.printStackTrace();
  48.             }
  50.         }
  51.     }
  52. }

Semaphore

译为：信号量，或许叫“许可证“更好理解，可以用来控制最大并发数

  1. public class SemaphoreDemo {
  3.     private static ExecutorService pool = new ThreadPoolExecutor(10, 10,
  4.             0L, TimeUnit.MILLISECONDS,
  5.             new LinkedBlockingQueue<Runnable>(),
  6.             new MyThreadFactory("my-test"));
  8.     public static void main(String[] args) {
  10.         // 设置最多同时获取的数量
  11.         Semaphore semaphore = new Semaphore(3);
  13.         //模拟用户访问
  14.         for (int i = 0; i < 10;  i++) {
  15.             final int No = i;
  16.             Runnable runnable = new Runnable() {
  17.                 @Override
  18.                 public void run() {
  20.                     try {
  21.                         // 拿到许可
  22.                         semaphore.acquire();
  23.                         System.out.println("Accessing: " + No);
  24.                         Thread.sleep(2000);
  25.                         // 释放
  26.                         semaphore.release();
  27.                     } catch (InterruptedException e) {
  28.                         e.printStackTrace();
  29.                     }
  30.                 }
  31.             };
  32.             // 放到线程池中执行,可以改变线程池的core数，观察结果
  33.             pool.execute(runnable);
  34.         }
  35.     }
  36. }

ConcurrentHashMap

在 JDK1.8 中，使用到了数组+链表+红黑树这三种结构；使用了 CAS 和 synchronized 来保证并发操作；其中 key 和 value 不能为 null；使用 synchronized 对每个链表的头结点加锁；如果链表节点大于等于8就会转换为红黑树；节点为6的时候又转为链表。

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

put 的过程：
将 key 相应的的 hash 值插入对应的数组中，如果该数组位置为 null，使用 CAS 插入，如果已经有值了就使用 synchronized 锁住，并追加到链表中，如果 Node 元素是红黑树类型，那么就插入到红黑树中。

get 的过程：
get 不涉及到并发，只要将 key 相应的 hash 从 Node 数组中获取，如果是链表或红黑树则需要遍历。

线程池

任何消耗资源且需要频繁重复创建的，理论上都可以用池化技术来优化，线程池也是基于这个理念。线程池使用的是生产者-消费者模型，线程池本身就是消费者。JDK中提供了多种类型的线程池：

  • CacheThreadPool，短时间内处理大量工作的线程池，会根据任务数量产生对应的线程，并试图缓存线程以便重复使用，如果限制 60 秒没被使用，则会被移除缓存
  • FixedThreadPool，创建一个数量固定的线程池，超出的任务会在队列中等待空闲的线程，可用于控制程序的最大并发数
  • SingleThreadPool，创建一个单线程线程池
  • ScheduledThreadPool，创建一个数量固定的线程池，支持执行定时性或周期性任务

执行过程：当一个任务进来，如果线程池中的线程小于核心线程数，那么就创建，如果线程池中的线程数大于核心线程数但是小于工作队列？？？

以定时任务线程池举例：

  1. public class SchedulerPoolDemo {
  3.     /**
  4.      * 创建工作线程数为1
  5.      * 默认使用AbortPolicy策略
  6.      */
  7.     public static void main(String[] args) {
  8.         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(1);
  9.         scheduledThreadPool.scheduleWithFixedDelay(() -> {
  10.             System.out.println("ThreadPool：" + LocalDateTime.now());
  11.         }, 1,1L, TimeUnit.SECONDS);
  12.     }
  15. }

线程池的参数：

corePoolSize
线程池核心线程数量，也就是该线程池无论如何都会保留的数量
maximumPoolSize
线程池的最大数量，如果workQueue满了且核心线程数小于该值，会创建新的线程，但不能超过它，当空闲下来该数量就会减少；如果核心线程等于该值，将执行拒绝策略
keepAliveTime 和 unit
时间单位，一个线程是空闲还是忙的状态，取决于这两个参数
workQueue
工作队列
threadFactory
创建线程的工厂
RejectedExecutionHandler handler
如果所有线程都在忙，工作队列也满了，就会执行该决绝策略。可以自定义拒绝策略，有：

  • CallerRunsPolicy:提交任务的线程自己去执行该任务。
  • AbortPolicy:默认的拒绝策略，会throws RejectedExecutionException。
  • DiscardPolicy:直接丢弃任务，没有任何异常抛出。
  • DiscardOldestPolicy:丢弃最老的任务，其实就是把最早进入工作队列的任务丢弃，然后把新任务加入 到工作队列。

注意事项：

  1. 使用有界队列，否则容易OOM
  2. 建议自定义拒绝策略
  3. 在线程池中执行的任务报错只会让该线程终止，而不会抛异常，一定要在业务逻辑中进行异常处理

一般使用线程池的任务可以分为两种: I/O密集型和CPU密集型，使用时workQueue要设置大小，否则可能会抛OOM异常。
其实目的都是为了将硬件的性能发挥极致，如果只是CPU计算型的话，那么几核CPU用多个个线程即可，顶多再加1个线程数，防止阻塞；I/O密集型只要算好I/O耗时和CPU计算时间，做到让CPU无缝切换。

I/O密集型计算场景：

最佳线程数 = CPU核数 * (1 +(I/O 耗时 / CPU 耗时))

CPU密集型计算场景：

最佳线程数 = CPU核数 + 1

虽然提供了Executors来方便的创建线程池，但是在阿里巴巴开发手册中不建议这样做，可能会出现OOM。所以还是使用 ThreadPoolExecutor 来创建，而且能让开发者更明确现线程池的运行规则。

线程工厂

如果你在排查问题使用过 jstack 这个命令就会知道线程的命名有多重要：
image.png

一般项目中我们都会实现 ThreadFactory 接口，自定义一个，例如看 Dubbo 中是如何自定义一个线程工厂：

  1. public class NamedThreadFactory implements ThreadFactory {
  3.     protected static final AtomicInteger POOL_SEQ = new AtomicInteger(1);
  5.     protected final AtomicInteger mThreadNum = new AtomicInteger(1);
  7.     protected final String mPrefix;
  9.     protected final boolean mDaemon;
  11.     protected final ThreadGroup mGroup;
  13.     public NamedThreadFactory() {
  14.         this("pool-" + POOL_SEQ.getAndIncrement(), false);
  15.     }
  17.     public NamedThreadFactory(String prefix) {
  18.         this(prefix, false);
  19.     }
  21.     public NamedThreadFactory(String prefix, boolean daemon) {
  22.         mPrefix = prefix + "-thread-";
  23.         mDaemon = daemon;
  24.         SecurityManager s = System.getSecurityManager();
  25.         mGroup = (s == null) ? Thread.currentThread().getThreadGroup() : s.getThreadGroup();
  26.     }
  28.     @Override
  29.     public Thread newThread(Runnable runnable) {
  30.         String name = mPrefix + mThreadNum.getAndIncrement();
  31.         Thread ret = new Thread(mGroup, runnable, name, 0);
  32.         ret.setDaemon(mDaemon);
  33.         return ret;
  34.     }
  36.     public ThreadGroup getThreadGroup() {
  37.         return mGroup;
  38.     }
  39. }

锁优化

自旋锁

当线程被阻塞，该线程就会被挂起，会发生上下文切换，也就是从用户态切换到内核态，性能影响大。所以有了自旋锁，发生阻塞时，不挂起，而是原地自旋等待，减少了上下文切换带来的性能开销

锁的分类

悲观锁

悲观锁认为对于同一个数据的并发操作，一定是会发生修改的。synchronized是典型的悲观锁

乐观锁

乐观锁正好和悲观锁相反，它获取数据的时候，并不担心数据被修改，每次获取数据的时候也不会加锁，只是在更新数据的时候，通过判断现有的数据是否和原数据一致来判断数据是否被其他线程操作。CAS就是乐观锁

共享锁

共享锁指定是可以同时被多个线程读取，但只能被一个线程修改

独占锁

只保证只能有一个线程能拿到锁，也叫排它锁

公平锁

抢占锁的机制，是否遵循FIFO顺序，非公平锁的性能比公平锁好，因为公平锁需要调度。
例如：ReentrantLock pairLock = new ReentrantLock(true);

非公平锁

不遵循FIFO顺序获得锁，例如：ReentrantLock pairLock = new ReentrantLock(false);

可重入锁

可重入锁指的是该线程获取了该锁之后，可以无限次的进入该锁锁住的代码

自旋锁

自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，但是循环会消耗 CPU 资源

常见面试题

优雅停止线程的方法是什么？

模拟出并发访问场景

线程的状态切换过程和相关方法的使用

使用wait()和notify()模拟阻塞队列

什么是CAS？

Compare And Swap，比较并交换，它有3个值，分别是内存中的V，预期值A和新的值B，先将内存位置中的值V与预期的值A进行比较，如果相等，那么将内存中的值V更新为新的值B。整个操作是原子的。

但它会出现ABA问题，可以使用版本号的来解决
它是乐观锁

什么是锁升级？

锁的状态有4中，分别是无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，会随着竞争而逐渐升级。

偏向锁

当一线程访问同步块的时候，会在对象头和栈帧中的锁记录存储偏向锁的线程 ID，以后该线程进入或者退出同步块时，不需要进行 CAS 操作来加锁或者解锁，只需要简单测试一下对象头的 Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示该线程获得了锁。如果测试失败，需要再测试一下 Mark Word 中偏向锁的标识是否设置为 1（表示当前是偏向锁） ，如果没有设置，则使用 CAS 竞争锁，如果设置了，则尝试使用 CAS 将对象头的偏向锁指向当前线程。

轻量级锁

线程在执行同步块之前，JVM 会先在当前线程的栈帧中创建用于存储锁的记录空间，并将对象头中的 MarkWord 字段复制到锁记录中，当前线程尝试使用 CAS 将对象头中的 Mark Word 替换成指向锁记录的指针。如果获得成功，当前线程获得了锁，如果失败，表示其他线程竞争锁，当前线程采用 CAS 来获取锁。

轻量级锁解锁的时候，会使用原子的 CAS 操作将 锁记录中的 Mark Word 替换会对象头，如果成功，表示没有竞争发送，如果失败，当前存在锁竞争，锁就会膨胀成重量级锁。一旦锁变成了重量级锁，就不会再恢复到轻量级锁，当锁处于这个状态下，其他线程试图获取锁是，都会被阻塞，当持有的线程释放锁之后会唤醒这些线程，被唤醒的线程开始新一轮的锁争抢

什么是内存泄漏？

当一个变量在代码中一直未被使用，占用内存，并且不能被GC回收，就是内存泄漏