Java并发编程，你须要知道的

时间 2019-11-17

标签 java 并发编程须要知道栏目 Java 繁體版

原文原文链接

本文大纲

1.并发编程三要素

原子性 原子，即一个不可再被分割的颗粒。在Java中原子性指的是一个或多个操做要么所有执行成功要么所有执行失败。
有序性 程序执行的顺序按照代码的前后顺序执行。（处理器可能会对指令进行重排序）
可见性 当多个线程访问同一个变量时，若是其中一个线程对其做了修改，其余线程能当即获取到最新的值。

2. 线程的五大状态

建立状态 当用 new 操做符建立一个线程的时候
就绪状态 调用 start 方法，处于就绪状态的线程并不必定立刻就会执行 run 方法，还须要等待CPU的调度
运行状态 CPU 开始调度线程，并开始执行 run 方法
阻塞状态 线程的执行过程当中因为一些缘由进入阻塞状态好比：调用 sleep 方法、尝试去获得一个锁等等
死亡状态 run 方法执行完或者执行过程当中遇到了一个异常

3.悲观锁与乐观锁

悲观锁：每次操做都会加锁，会形成线程阻塞。
乐观锁：每次操做不加锁而是假设没有冲突而去完成某项操做，若是由于冲突失败就重试，直到成功为止，不会形成线程阻塞。

4.线程之间的协做

4.1 wait/notify/notifyAll

这一组是 Object 类的方法须要注意的是：这三个方法都必须在同步的范围内调用html

wait 阻塞当前线程，直到 notify 或者 notifyAll 来唤醒java

wait有三种方式的调用
wait()
必要要由 notify 或者 notifyAll 来唤醒
wait(long timeout)
在指定时间内，若是没有notify或notifAll方法的唤醒，也会自动唤醒。
wait(long timeout,long nanos)
本质上仍是调用一个参数的方法
public final void wait(long timeout, int nanos) throws InterruptedException {
      if (timeout < 0) {
             throw new IllegalArgumentException("timeout value is negative");
       }
      if (nanos < 0 || nanos > 999999) {
              throw new IllegalArgumentException(
             "nanosecond timeout value out of range");
       }
       if (nanos > 0) {
             timeout++;
       }
       wait(timeout);
}
              
复制代码

notify 只能唤醒一个处于 wait 的线程
notifyAll 唤醒所有处于 wait 的线程

4.2 sleep/yield/join

这一组是 Thread 类的方法面试

sleep 让当前线程暂停指定时间，只是让出CPU的使用权，并不释放锁编程

yield 暂停当前线程的执行，也就是当前CPU的使用权，让其余线程有机会执行，不能指定时间。会让当前线程从运行状态转变为就绪状态，此方法在生产环境中不多会使用到，官方在其注释中也有相关的说明缓存

/**
      * A hint to the scheduler that the current thread is willing to yield
      * its current use of a processor. The scheduler is free to ignore this
      * hint.
      *
      * <p> Yield is a heuristic attempt to improve relative progression
      * between threads that would otherwise over-utilise a CPU. Its use
      * should be combined with detailed profiling and benchmarking to
      * ensure that it actually has the desired effect.
      *
      * <p> It is rarely appropriate to use this method. It may be useful
      * for debugging or testing purposes, where it may help to reproduce
      * bugs due to race conditions. It may also be useful when designing
      * concurrency control constructs such as the ones in the
      * {@link java.util.concurrent.locks} package.
      */
      
复制代码

join 等待调用 join 方法的线程执行结束，才执行后面的代码其调用必定要在 start 方法以后（看源码可知）使用场景：当父线程须要等待子线程执行结束才执行后面内容或者须要某个子线程的执行结果会用到 join 方法多线程

5.valitate 关键字

5.1 定义

java编程语言容许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保经过排他锁单独得到这个变量。Java语言提供了volatile，在某些状况下比锁更加方便。若是一个字段被声明成volatile，java线程内存模型确保全部线程看到这个变量的值是一致的。并发

valitate是轻量级的synchronized，不会引发线程上下文的切换和调度，执行开销更小。app

5.2 原理

使用volitate修饰的变量在汇编阶段，会多出一条lock前缀指令
它确保指令重排序时不会把其后面的指令排到内存屏障以前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操做已经所有完成
它会强制将对缓存的修改操做当即写入主存
若是是写操做，它会致使其余CPU里缓存了该内存地址的数据无效

5.3 做用

内存可见性 多线程操做的时候，一个线程修改了一个变量的值，其余线程能当即看到修改后的值异步

防止重排序 即程序的执行顺序按照代码的顺序执行（处理器为了提升代码的执行效率可能会对代码进行重排序）编程语言

并不能保证操做的原子性（好比下面这段代码的执行结果必定不是100000）

public class testValitate {
    public volatile int inc = 0;
    public void increase() {
        inc = inc + 1;
    }
    public static void main(String[] args) {
        final testValitate test = new testValitate();
        for (int i = 0; i < 100; i++) {
            new Thread() {
                public void run() {
                    for (int j = 0; j < 1000; j++)
                        test.increase();
                }
            }.start();
        }
        while (Thread.activeCount() > 2) {  //保证前面的线程都执行完
            Thread.yield();
        }
        System.out.println(test.inc);
     }
   }
复制代码

6. synchronized 关键字

确保线程互斥的访问同步代码

6.1 定义

synchronized 是JVM实现的一种锁，其中锁的获取和释放分别是 monitorenter 和 monitorexit 指令，该锁在实现上分为了偏向锁、轻量级锁和重量级锁，其中偏向锁在 java1.6 是默认开启的，轻量级锁在多线程竞争的状况下会膨胀成重量级锁，有关锁的数据都保存在对象头中

6.2 原理

加了 synchronized 关键字的代码段，生成的字节码文件会多出 monitorenter 和 monitorexit 两条指令（利用javap -verbose 字节码文件可看到关，关于这两条指令的文档以下：

monitorenter Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows: • If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor. • If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count. • If another thread already owns the monitor associated with objectref, the thread blocks until the monitor's entry count is zero, then tries again to gain ownership.
monitorexit The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref. The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

加了 synchronized 关键字的方法，生成的字节码文件中会多一个 ACC_SYNCHRONIZED 标志位，当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，若是设置了，执行线程将先获取monitor，获取成功以后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其余任何线程都没法再得到同一个monitor对象。其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需经过字节码来完成。

6.3 关于使用

修饰普通方法同步对象是实例对象
修饰静态方法同步对象是类自己
修饰代码块能够本身设置同步对象

6.4 缺点

会让没有获得锁的资源进入Block状态，争夺到资源以后又转为Running状态，这个过程涉及到操做系统用户模式和内核模式的切换，代价比较高。Java1.6为 synchronized 作了优化，增长了从偏向锁到轻量级锁再到重量级锁的过分，可是在最终转变为重量级锁以后，性能仍然较低。

7. CAS

AtomicBoolean，AtomicInteger，AtomicLong以及 Lock 相关类等底层就是用 CAS实现的，在必定程度上性能比 synchronized 更高。

7.1 什么是CAS

CAS全称是Compare And Swap，即比较替换，是实现并发应用到的一种技术。操做包含三个操做数 —— 内存位置（V）、预期原值（A）和新值(B)。若是内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。不然，处理器不作任何操做。

7.2 为何会有CAS

若是只是用 synchronized 来保证同步会存在如下问题 synchronized 是一种悲观锁，在使用上会形成必定的性能问题。在多线程竞争下，加锁、释放锁会致使比较多的上下文切换和调度延时，引发性能问题。一个线程持有锁会致使其它全部须要此锁的线程挂起。

7.3 实现原理

Java不能直接的访问操做系统底层，是经过native方法（JNI）来访问。CAS底层经过Unsafe类实现原子性操做。

7.4 存在的问题

ABA问题

什么是ABA问题？好比有一个 int 类型的值 N 是 1。此时有三个线程想要去改变它：
```
线程A ：但愿给 N 赋值为 2
线程B： 但愿给 N 赋值为 2
线程C： 但愿给 N 赋值为 1
复制代码
```
此时线程A和线程B同时获取到N的值1，线程A率先获得系统资源，将 N 赋值为 2，线程B因为某种缘由被阻塞住，线程C在线程A执行完后获得 N 的当前值2。此时的线程状态：
- 线程A成功给 N 赋值为2
- 线程B获取到 N 的当前值 1 但愿给他赋值为 2，处于阻塞状态
- 线程C获取到 N 的当前值2,但愿给他赋值为1，而后线程C成功给N赋值为1
- 最后线程B获得了系统资源，又从新恢复了运行状态，在阻塞以前线程B获取到的N的值是1，执行compare操做发现当前N的值与获取到的值相同（均为1），成功将N赋值为了2。
在这个过程当中线程B获取到N的值是一个旧值，虽然和当前N的值相等，可是实际上N的值已经经历了一次 1到2到1的改变。

上面这个例子就是典型的ABA问题

怎样去解决ABA问题
给变量加一个版本号便可，在比较的时候不只要比较当前变量的值还须要比较当前变量的版本号。Java中AtomicStampedReference 就解决了这个问题
循环时间长开销大在并发量比较高的状况下，若是许多线程反复尝试更新某一个变量，却又一直更新不成功，循环往复，会给CPU带来很大的压力。

CAS只能保证一个共享变量的原子操做

8. AbstractQueuedSynchronizer(AQS)

AQS抽象的队列式同步器，是一种基于状态（state）的链表管理方式。state 是用CAS去修改的。它是 java.util.concurrent 包中最重要的基石，要学习想学习 java.util.concurrent 包里的内容这个类是关键。 ReentrantLock、CountDownLatcher、Semaphore 实现的原理就是基于AQS。想知道他怎么实现以及实现原理能够参看这篇文章https://www.cnblogs.com/waterystone/p/4920797.html

9. Future

在并发编程咱们通常使用Runable去执行异步任务，然而这样作咱们是不能拿到异步任务的返回值的，可是使用Future 就能够。使用Future很简单，只需把Runable换成FutureTask便可。使用上比较简单，这里很少作介绍。

10. 线程池

若是咱们使用线程的时候就去建立一个线程，虽然简单，可是存在很大的问题。若是并发的线程数量不少，而且每一个线程都是执行一个时间很短的任务就结束了，这样频繁建立线程就会大大下降系统的效率，由于频繁建立线程和销毁线程须要时间。线程池经过复用能够大大减小线程频繁建立与销毁带来的性能上的损耗。

Java中线程池的实现类 ThreadPoolExecutor，其构造函数的每个参数的含义在注释上已经写得很清楚了，这里几个关键参数能够再简单说一下

corePoolSize ：核心线程数即一直保留在线程池中的线程数量，即便处于闲置状态也不会被销毁。要设置 allowCoreThreadTimeOut 为 true，才会被销毁。
maximumPoolSize：线程池中容许存在的最大线程数
keepAliveTime ：非核心线程容许的最大闲置时间，超过这个时间就会本地销毁。
workQueue：用来存听任务的队列。
- SynchronousQueue：这个队列会让新添加的任务当即获得执行，若是线程池中全部的线程都在执行，那么就会去建立一个新的线程去执行这个任务。当使用这个队列的时候，maximumPoolSizes通常都会设置一个最大值 Integer.MAX_VALUE
- LinkedBlockingQueue：这个队列是一个无界队列。怎么理解呢，就是有多少任务来咱们就会执行多少任务，若是线程池中的线程小于corePoolSize ,咱们就会建立一个新的线程去执行这个任务，若是线程池中的线程数等于corePoolSize，就会将任务放入队列中等待，因为队列大小没有限制因此也被称为无界队列。当使用这个队列的时候 maximumPoolSizes 不生效（线程池中线程的数量不会超过corePoolSize），因此通常都会设置为0。
- ArrayBlockingQueue：这个队列是一个有界队列。能够设置队列的最大容量。当线程池中线程数大于或者等于 maximumPoolSizes 的时候，就会把任务放到这个队列中，当当前队列中的任务大于队列的最大容量就会丢弃掉该任务交由 RejectedExecutionHandler 处理。

最后，本文主要对Java并发编程开发须要的知识点做了简单的讲解，这里每个知识点均可以用一篇文章去讲解，因为篇幅缘由不能对每个知识点都详细介绍，我相信经过本文你会对Java的并发编程会有更近一步的了解。若是您发现还有缺漏或者有错误的地方，能够在评论区补充，谢谢。