Java并发系列之基础二

港控/mmm° 2022-05-16 01:57 126阅读 0赞

![这里写图片描述][70]

# 1. 并发编程三要素 #

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

# 2. 线程的五大状态 #

1.  创建状态：当用 new 操作符创建一个线程的时候
2.  就绪状态：调用 start 方法，处于就绪状态的线程并不一定马上就会执行 run 方法，还需要等待CPU的调度
3.  运行状态：CPU 开始调度线程，并开始执行 run 方法
4.  阻塞状态：线程的执行过程中由于一些原因进入阻塞状态比如：调用 sleep 方法、尝试去得到一个锁等等
5.  死亡状态：run 方法执行完 或者 执行过程中遇到了一个异常

# 3. 悲观锁与乐观锁 #

*  悲观锁：每次操作都会加锁，会造成线程阻塞。
 *  乐观锁：每次操作不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止，不会造成线程阻塞。

# 4. 线程之间的协作 #

## 4.1 wait/notify/notifyAll ##

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

*  1、wait：阻塞当前线程，直到 notify 或者 notifyAll 来唤醒

wait有三种方式的调用

*  wait()

必要要由 notify 或者 notifyAll 来唤醒

*  wait(long timeout)

在指定时间内，如果没有notify或notifAll方法的唤醒，也会自动唤醒。

*  wait(long timeout, long nanos)

本质上还是调用一个参数的方法

*  2、notify：只能唤醒一个处于 wait 的线程
 *  3、notifyAll：唤醒全部处于 wait 的线程

## 4.2 sleep/yield/join ##

Thread 类的方法

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

2、yield：暂停当前线程的执行，也就是当前CPU的使用权，让其他线程有机会执行，不能指定时间。会让当前线程从运行状态转变为就绪状态，此方法在生产环境中很少会使用到  
  
3、join：等待调用 join 方法的线程执行结束，才执行后面的代码其调用一定要在 start 方法之后（看源码可知）使用场景：当父线程需要等待子线程执行结束才执行后面内容或者需要某个子线程的执行结果会用到 join 方法

# 5. volatile 关键字 #

## 5.1 定义 ##

java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了`volatile`，在某些情况下比锁更加方便。如果一个字段被声明成volatile，java线程内存模型确保所有线程看到这个变量的值是一致的。

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

## 5.2 原理 ##

1.  使用volitate修饰的变量在汇编阶段，会多出一条lock前缀指令
2.  它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成
3.  它会强制将对缓存的修改操作立即写入主存4. 如果是写操作，它会导致其他CPU里缓存了该内存地址的数据无效

## 5.3 作用 ##

内存可见性多线程操作的时候，一个线程修改了一个变量的值 ，其他线程能立即看到修改后的值防止重排序即程序的执行顺序按照代码的顺序执行（处理器为了提高代码的执行效率可能会对代码进行重排序）

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

public class ValitateTest {
        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 字节码文件`可看到）。

加了 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。想知道他怎么实现以及实现原理 可以参看[这篇文章][Link 1]。

# 9. Future #

在并发编程我们一般使用Runnable去执行异步任务，然而这样做我们是不能拿到异步任务的返回值的，但是使用Future 就可以。使用Future很简单，只需把Runnable换成FutureTask即可。使用比较简单，这里不多做介绍。

# 10. 线程池 #

> 如果我们使用线程的时候就去创建一个线程，虽然简单，但是存在很大的问题。如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。线程池通过复用可以大大减少线程频繁创建与销毁带来的性能上的损耗。

由Executors使用工厂方法创建特定类型的ThreadPool，查看Executor源码：

public class Executors {
        public static ExecutorService newFixedThreadPool(int nThreads) {
                return new ThreadPoolExecutor(nThreads, nThreads,
                                              0L, TimeUnit.MILLISECONDS,
                                              new LinkedBlockingQueue<Runnable>());
            }
        public static ExecutorService newCachedThreadPool() {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }
        public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
        public static ExecutorService newSingleThreadExecutor() {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }
    }

可以看到其实各个ThreadPool都是由`ThreadPoolExecutor`实现的，只是根据不同的参数创建不同类型的线程池。

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

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

> 转载自 [《Java并发编程，你需要知道的》][Java]

[70]: /images/20220516/9a8bacb46ab74b88ab868e95d58c4c20.png
[Link 1]: https://www.cnblogs.com/waterystone/p/4920797.html
[Java]: https://blog.csdn.net/m0_37803704/article/details/79079732