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操作不当引发的死锁问题

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

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

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

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

1. 管程的名称

2. 局部于管程内的共享数据结构

3. 对该数据结构进行操作的一组过程

4. 对局部于管程内的数据结构的初始值语句

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

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

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

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只对应一个工作进程。