【JUC】复习指南

JUC复习指南：

JUC有哪些知识点？

什么是Juc
Lock接口
线程间通信
集合的线程安全问题
多线程锁
Callable接口
JUC三大辅助类 CountDownLatch CyclicBarrier Semaphore
读写锁 ReetrantReadWriteLOck
阻塞队列
ThreadPool线程池
Fork/join
CompletableFuture

中断机制
LockSupport
JMM
volatile
CAS
原子类
ThreadLocal
synchronized之锁升级
AQS
StampedLock

Q：什么是Juc

是 java.util .concurrent 工具包的简称，这是一个处理线程的工具包，JDK 1.5 开始出现的

Q:线程的状态

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         新建态，线程尚未执行
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         
         可运行态，可以理解为操作系统本地线程的就绪态
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         
         阻塞态，一个等待获得同步监视器，准备进入同步带模块的线程
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         
         等待态，必须满足上述方法调用逻辑的情况下才能成为此状态
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         
          超时等待态，必须满足上述方法调用逻辑的情况下才能成为此状态
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         终结态，线程完成执行任务。
         */
        TERMINATED;
    }

和操作系统里对进程、线程状态的描述还是有区别的

操作系统中进程五态和线程的状态是类似的主要关注的就是 就绪阻塞执行。

Q ：wait/sleep 的区别

（1）sleep 是 Thread 的静态方法，wait 是 Object 的方法，任何对象实例都能调用。

（2）sleep 不会释放锁，它也不需要占用锁。wait 会释放锁，但调用它的前提是当前线程占有锁(即代码要在 synchronized 中)。

（3）它们都可以被 interrupted 方法中断。

Q:多线程并发问题的异步性问题

请注意，我问题中的【异步性】是操作系统的特性，它指的是

操作系统对于进程/作业的调度顺序在业务层面来看是不确定的(并不是从具体调度算法的角度看)，在并发执行任务的场景下，就可能出现这些现象：

一个任务多次被执行，但是其他任务始终没用被执行
理想希望任务按照一定的顺序执行，但实际执行中任务是乱序的。

在操作系统中，解决上述问题的办法，就是同步与互斥机制。

同步互斥机制在实现原理上基本就是硬件层面和软件层面，具体实现有原语、互斥锁，信号量，管程等机制。

同步是一种直接制约关系，它强调的是对进程/线程的工作顺序、传递信息进行控制，协调。

互斥是间接制约关系 它表现的是多个进程/线程对临界资源的访问关系，一者访问，其余等待。

在java中，对于并发执行产生的异步性问题，也有它自己的具体实现方案。除此之外，Java所说的异步处理任务，和操作系统异步性的概念是不一样的。

java的异步处理任务，是通过Java的某些API或外部中间件，使得的多个任务的执行互相不再发生干涉，简而言之，就是：

你干你的事，我干我的事，你干完给我一个结果通知，而不是让我干等你的执行结果，再开始工作。

但是请注意一点：不管是开发上的异步处理，同步、互斥，他们并不是在任何场景下都能用的，要根据具体业务场景来具体设计。

比如生产者-消费者模型下，缓冲区(容量是1)内必须要写满数据，消费者才能执行，缓冲区内为空，生产者才能生产。二者不可以同时访问缓冲区。

这个模型就是典型的同步+互斥。并不适合用异步处理。

那怎么用异步来改善这个模型呢？

假设当前的生产者执行的速率很快，消费者的执行速率很慢，此时就存在一个速度差。

为了缓解这个问题，我们可与模拟计算机网络的流量控制的思想，为消费者创建接收缓存队列(容量大于5)，

假设生产速度是消费速度的5倍，缓冲区内很快塞满了，消费者一个一个的去消费，就可能让生产者一直等待。但是有了接收缓存队列后，生产者可以保持运行，也不必等待消费者必须把缓冲区的内容消费了，生产者可以生产到缓存队列满了再停等，减少了系统的停等时间。

进一步的，可以设计一个滑动窗口算法，让二者的发送和接收的速率达到一个平衡点。

通过一个缓存队列，把生产者和消费者的直接制约关系破坏，打破同步，形成异步关系，可以有效提高CPU的利用率，减少空等时间，提高了系统吞吐量。

java关于异步的一个API CompletableFuture，在后面再详细介绍。

Q：管程

管程实际上操作系统的一种进程同步工具。管程可以保证进程互斥，降低由于信号量pv操作不当引发的死锁问题

同一时间内，只有一个进程可以在管程内活动。

管程有自己的共享数据结构和具体过程

共享数据结构抽象的标识系统的共享资源，而对该数据结构执行的一组操作，可以定义为一组过程。进程对于共享资源的申请、释放等操作，都是通过这些过程来实现的。这组过程可以根据资源共享的情况，或接收或阻塞进程的访问，确保每次仅仅有一个进程使用共享资源，这样就实现对共享资源的统一管理，实现互斥。

简单来说，管程的定义结构如下：

管程的名称
局部于管程内的共享数据结构
对该数据结构进行操作的一组过程
对局部于管程内的数据结构的初始值语句

除了上面对管程的定义外，管程还具有条件变量

当一个进程进入管程后，其他所有尝试获取管程的进程会被阻塞，被加入该管程的阻塞队列。

直到该进程用完管程，释放资源，并且唤醒处于阻塞队列中的进程。

monitor Demo{
    共享数据结构 S;
    condition x;
    init_code(){...}
    
    take_away(){
        if(S<0) x.wait();
      	//若资源足够，则不用阻塞，直接进行分配
    }
    
    give_back(){
        归还资源 进一步处理；
        if(阻塞队列里有进程等待) x.signal() //唤醒一个进程
    }
}

现在我们回到java的管程——synchronized 同步监视器

JVM 中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程 (monitor)对象，管程(monitor)会随着 java 对象一同创建和销毁

执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程.

我们可以看到，JVM中的管程是线程粒度的，毕竟，一个JVM只对应一个工作进程。