一、 线程
1. 1 进程与线程
进程：是指一个内存中运行的应用程序。每个进程都有一个独立的内存空间；系统运行一个程序即是一个进程从创建、运行到消亡的过程。大部分程序可以同时运行多个实例进程（例如画图、记事本）等，也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程至少包含一个线程。例如上图，Firefox进程开启了11个子线程。
总之：一个程序运行后至少启动一个实例进程，一个进程中可包含多个线程 。
二者对比
- 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集。
- 进程拥有共享的资源，如内存空间供其内部的线程共享。
- 进程间通信较为复杂
- 同一台计算机的进程通信称为 IPC（Inter-process communication）。
- 不同计算机之间的进程通信需要遵守网络协议，例如 HTTP。
- 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量。
- 线程更轻量，线程上下文切换成本一般要比进程上下文切换成本低。
线程调度:
-
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
-
抢占式调度
优先级高的线程先使用 CPU，如果线程的优先级相同，那么会随机选择一个使用CPU(线程随机性)，Java中都为抢占式调度。
1. 2 并发与并行
- 并发：指两个或多个任务在同一时间段内发生。
- 并行：指两个或多个任务在同一时刻发生（同时发生）。
严格意义上来说，并行的多个任务是真实的同时执行，而对于并发来说，这个过程只是交替的，一会运行任务一,一会儿又运行任务二，系统会不停地在两者间切换。但对于外部观察者来说，即使多个任务是串行并发的，也会造成是多个任务并行执行的错觉（微观串行，宏观并行）。
实际上，如果系统内只有一个CPU，而现在而使用多线程或者多线程任务，那么真实环境中这些任务不可能真实并行的，毕竟一个CPU一次只能执行一条指令，这种情况下多线程或者多线程任务就是并发的，而不是并行，操作系统会不停的切换任务。真正的并行也只能够出现在拥有多个CPU的系统中（多核CPU）。
1. 3 同步与异步
同步是阻塞模式，异步是非阻塞模式。
同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，收到返回信息后才继续执行下去。
异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回式系统会通知进程进行处理，这样可以提高执行的效率。
1. 4 Thread创建线程
java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。该类中定义了有关线程的一些方法：
构造方法：
public Thread():分配一个新的线程对象。
public Thread(String name):分配一个指定名字的新的线程对象。
public Thread(Runnable target):分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
常用方法：
public String getName():获取当前线程名称。
public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run():此线程要执行的任务在此处定义代码。
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread():返回对当前正在执行的线程对象的引用。
通过继承Thread类来创建并启动多线程的步骤如下：
- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。
- 创建Thread子类的实例，即创建了线程对象。
- 调用线程对象的start()方法来启动该线程。
测试类：
public class ThreadTest {
public static void main(String[] args) {
System.out.println("main线程开始执行");
//创建自定义线程对象
MyThread mt = new MyThread("子线程");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 10; i++) {
System.out.println("main线程打印："+i);
}
}
}
自定义线程类：
public class MyThread extends Thread{
// 定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法，指定线程的名称
super(name);
}
/**
* 重写run方法，完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName()+"正在执行！打印："+i);
}
}
}
程序启动运行main方法，java虚拟机启动一个进程，主线程main启动，随后调用MyThread对象的start方法启动子线程。
在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间，进行方法的压栈和弹栈。
当行线程的任务结束，线程自动在栈内存中释放；当所有的执行线程都执行结束，进程也就结束了。
1. 5 Runnable创建线程
采用java.lang.Runnable开启线程也很常见，我们只需要重写接口中的run方法即可。
步骤如下：
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
的线程对象。
3. 调用线程对象的start()方法来启动线程。
代码如下：
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
// getName方法：获取线程的名字
// currentThread方法：获取当前所处的线程的对象
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
public class RunnableTest {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread(mr, "子线程");
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程 " + i);
}
}
}
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread
对象的start()方法来启动子线程。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现
Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程
编程的基础。
Tips：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。
而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。
实现Runnable接口比继承Thread类更具优势：
- Runnable接口适合资源共享。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。
扩充：在Java中，每次程序运行至少启动2个线程。一个是main主线程，一个是垃圾收集线程。因为每当使用java命令运行 Java 程序时，实际上都会启动一个Java虚拟机进程。
1. 6 匿名内部类创建线程
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
public class NoNameInnerClassThread {
public static void main(String[] args) {
// 1. 继承thread类实现多线程
new Thread() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--"
+ i);
}
}
}.start();
// 2. 实现runnable借口，创建多线程并启动
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--"
+ i);
}
}
}) {
}.start();
// 3. Thread匿名内部类的里面再一次重写run方法
// 在实际运行时的结果是 "World--i"。以thread的run方法为准,但是此处无意义。
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("Hello" + "--" + i);
}
}
}) {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("World" + "--" + i);
}
}
}.start();
}
}
二、线程安全
2. 1 Java内存模型（JMM）
在了解线程安全之前先来了解Java的内存模型，搞清楚线程是怎样工作的。
JMM(Java Memory Model)，是一种基于计算机内存模型（定义了共享内存系统中多线程程序读写操作行为的规范），屏蔽了各种硬件和操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。保证共享内存的原子性、可见性、有序性。
线程 0 、线程 1 和线程 2分别对主内存的变量进行读写操作。其中主内存中的变量为共享变量，也就是说此变量只此一份，多个线程间共享。但是线程不能直接读写主内存的共享变量，每个线程都有自己的工作内存，线程需要读写主内存的共享变量时需要先将该变量拷(read）到自己的工作内存，然后在自己的工作内存中对该变量进行所有操作，线程工作内存对变量副本完成操作之后需要将结果同步至主内存(write)。
Tips：线程的工作内存是线程私有内存，线程间无法互相访问对方的工作内存。
JMM存在三大特性：原子性、可见性、有序性。
原子性：
对共享内存的操作必须是要么全部执行直到执行结束，且中间过程不能被任何外部因素打断，要么就不执行。
可见性：
多线程操作共享内存时，执行结果能够及时的同步到共享内存，确保其他线程对此结果及时可见。
有序性：
程序的执行顺序按照代码顺序执行，在单线程环境下，程序的执行都是有序的，但是在多线程环境下，JMM 为了性能优化，编译器和处理器会对指令进行重排，程序的执行会变成无序。
就这样，JMM 规定了何时以及如何做线程工作内存与主内存之间的数据同步。
2. 2 线程安全
我们先来看一个实例：
假设电影院要电影“花木兰”的100张票，3售票窗口同时卖 “花木兰”电影票。
模拟100张票：
public class Ticket implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
//出票操作
try {
//模拟出票间隔时间
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name + "正在卖:" + ticket--);
}
}
}
}
测试类：
public class TicketTest {
public static void main(String[] args) {
//创建线程任务对象
Ticket ticket = new Ticket();
//创建三个窗口对象
Thread t1 = new Thread(ticket, "窗口1");
Thread t2 = new Thread(ticket, "窗口2");
Thread t3 = new Thread(ticket, "窗口3");
//同时卖票
t1.start();
t2.start();
t3.start();
}
}
结果中有一部分这样现象：
发现程序出现了两个问题：
-
出现了很多相同的票数，比如 4与9 这张票都被卖了两回。
-
出现了不存在的票，比如 0 票。
知道JMM内存模型之后，我们可以很轻松的分析出问题的症结所在。
在多线程场景下，图上三个线程 同时来操做共享内存里的同一个变量（ticket），主内存内的此变量数据容易被破坏。也就是说主内存内的此变量不是线程安全的。
我们都知道完成一次 ticket-- 相当于执行了：
int tmp = ticket - 1;
ticket = tmp;
在多线程环境下就会出现在执行完 int tmp = ticket - 1; 这行代码时就发生了线程切换，当线程再次切回来的时候，ticket 就会被重复赋值，导致出现上面的运行结果，出现相同票数或者不存在的票数。
Tips：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
2. 2 线程同步
要解决上述多线程并发访问一个资源的安全性问题，Java 提供了一系列的关键字和类。
（1）Synchronized关键字
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种方式：
- 同步代码块，只对这个
{ }区块的资源实行互斥访问，作用的对象是调用这个代码块的对象。
格式：
synchronized(同步锁){
// 需要同步操作的代码
}
同步锁：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。
- 锁对象 可以是任意类型。
- 多个线程对象 要使用同一把锁。
Tips：在任何时候，最多允许一个线程拥有同步，谁拿到锁就进入代码块，其他的线程只能等待 (BLOCKED)。
实例：
public class Ticket implements Runnable {
private int ticket = 100;
Object lock = new Object();
@Override
public void run() {
while (true) {
synchronized (lock) {
if (ticket > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name + "正在卖:" + ticket--);
}
}
}
}
}
-
同步方法，保证有线程执行该方法的时候，其他线程只能在方法外等着，作用的对象是调用这个代码块的对象。
格式：
public synchronized void method(){ // 可能会产生线程安全问题的代码 }Tips：对于非static方法，同步锁就是this。 对于static方法，我们使用当前方法所在类的字节码对象(类名.class)。
public class Ticket implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
sellTicket();
}
}
private synchronized void sellTicket() {
if (ticket > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name + "正在卖:" + ticket--);
}
}
}
（2）Lock
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
- public void lock() ：加同步锁。
- public void unlock() ：释放同步锁。
public class Ticket implements Runnable {
private int ticket = 100;
Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name + "正在卖:" + ticket--);
}
lock.unlock();
}
}
}
三、线程状态
3. 1 概述
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，
有几种状态呢？在API中java.lang.Thread.State枚举出了六种线程状态：
| 线程状态 | 导致状态发生条件 |
|---|---|
| NEW(新建) | 线程刚被创建，但是并未启动。还未调用start方法。 |
| Runnable(可 运行) | 线程可以在JVM中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器。 |
| Blocked(锁阻塞) | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。 |
| Waiting(无限 等待) | 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting(计时 等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。 |
Teminated( 终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
3. 2 新建状态(NEW)
即用new关键字创建一个线程，这个线程就处于新建状态。
Tips：实现Runnable接口或者继承Thread类来创建线程。
3. 3 运行状态(RUNNABLE)
RUNNABLE状态的线程，可以理解为其正在JVM中”执行“。这个"执行"，不一定是真的在运行， 也有可能是在等待CPU资源。
所以分为就绪和运行两种状态。
（1）就绪状态（READY)
当线程对象调用了start()方法之后，线程处于就绪状态，就绪意味着该线程已获得执行所需的所有资源，只要CPU分配执行权就能运行。
注意：
- 不允许对一个线程多次使用start方法。
- 线程执行完成之后，不能试图用start将其唤醒。
其他状态 —>就绪
- 线程调用start()，新建状态转化为就绪状态。
- 线程sleep(long)时间到，等待状态转化为就绪状态。
- 阻塞式IO操作结果返回，线程变为就绪状态。
- 其他线程调用join()方法，结束之后转化为就绪状态。
- 线程对象拿到对象锁之后，也会进入就绪状态。
（2）运行状态(RUNNING)
线程获取到CPU执行权后，真正开始执行run()方法的线程执行体时，意味着该线程就已经处于运行状态。对于单处理器，一个时刻只能有一个线程处于运行状态。
运行状态转变为就绪状态的情形：
- 线程失去处理器资源。线程不一定完整执行的，执行到一半，说不定就被别的线程抢走了。
- 调用yield()静态方法，暂时暂停当前线程，让系统的线程调度器重新调度一次，它自己完全有可能再次运行。
3. 4 阻塞状态(BLOCKED)
阻塞状态表示线程正等待监视器锁。
- 线程等待进入synchronized同步方法。
- 线程等待进入synchronized同步代码块。
例如，线程A和线程B使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态；当线程B取得到锁，就会从阻塞状态转变为就绪状态。
3. 5 等待状态(WAITING)
线程处于等待状态表示它需要等待其他线程的唤醒才能继续运行。
-
当前线程中调用wait()、join()、park()函数时，当前线程就会进入等待态。
-
进入等待态的线程会释放CPU执行权，并释放资源（如：锁）
举例：
public class WaitingTest {
public static Object obj = new Object();
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
synchronized (obj) {
try {
System.out.println(Thread.currentThread().getName() + "=== 调用wait方法，进入WAITING状态，释放锁对象");
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "=== 从WAITING状态醒来，获取到锁对象，继续执行");
}
}
}
}, "线程A").start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) { //每隔3秒 唤醒一次
try {
System.out.println(Thread.currentThread().getName() + "‐‐‐ 等待3秒钟");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj) {
System.out.println(Thread.currentThread().getName() + "‐‐‐ 获取到锁对象, 调用notify方法，释放锁对象");
obj.notify();
}
}
}
}, "线程B").start();
}
}
执行结果：
线程A=== 调用wait方法，进入WAITING状态，释放锁对象
线程B‐‐‐ 等待3秒钟
线程B‐‐‐ 获取到锁对象, 调用notify方法，释放锁对象
线程B‐‐‐ 等待3秒钟
线程A=== 从WAITING状态醒来，获取到锁对象，继续执行
... ...
通过上述案例我们会发现，线程A在调用了某个对象的 Object.wait方法后，需要会等待线程B调用此对象的
Object.notify()方法将其唤醒。
其实WAITING状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。比如A，B线程，如果A线程在RUNNABLE（可运行）状态中调用了wait()方法，那么线程A就进入了WAITING状态，同时失去了同步锁。假如此时线程B获取到了同步锁，在运行状态中调用了notify()方法，那么就会将无限等待的A线程唤醒。需要注意的是，线程A获取到锁对象后就进入RUNNABLE（可运行）状态；如果没有获取锁对象，那么就进入到BLOCKED（阻塞状态）。
运行—>等待
- 当前线程运行过程中，其他线程调用
join方法，当前线程将会进入等待状态。 - 当前线程对象调用
wait()方法。 LockSupport.park()：出于线程调度的目的禁用当前线程。
等待—>就绪
- 等待的线程被其他线程对象唤醒，
notify()和notifyAll()。 LockSupport.unpark(Thread)，与上面park方法对应，给出许可证，解除等待状态。
3. 6 超时等待状态(TIMED_WAITING)
区别于WAITING，它可以在指定的时间自行返回，到了超时时间后自动进入阻塞队列，开始竞争锁。
例如上面买电影票的案例中，模拟出票间隔时间，run方法中添加了sleep语句Thread.sleep(100)。它强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。而这个”休眠状态“，也就是所谓的超时等待状态(TIMED_WAITING)。
超时等待状态(TIMED_WAITING)与WAITING态一样，并不是因为被动请求不到资源，而是主动进入的"休眠"状态，并且进入后释放CPU执行权；
运行—>超时等待
- 调用静态方法，
Thread.sleep(long) - 线程对象调用
wait(long)方法 - 其他线程调用指定时间的
join(long)。 LockSupport.parkNanos()。LockSupport.parkUntil()。
再看一个案例：
实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串。
public class TimeWaitingTest extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if ((i) % 10 == 0) {
System.out.println("开启线程数为:" + i);
}
System.out.print(i);
try {
Thread.sleep(1000);
System.out.print(" 线程睡眠1秒！\n");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new TimeWaitingTest().start();
}
}
执行结果：
开启线程数为:0
0 线程睡眠1秒！
1 线程睡眠1秒！
2 线程睡眠1秒！
3 线程睡眠1秒！
4 线程睡眠1秒！
5 线程睡眠1秒！
6 线程睡眠1秒！
7 线程睡眠1秒！
8 线程睡眠1秒！
9 线程睡眠1秒！
开启线程数为:10
10 线程睡眠1秒！
... ...
可见，线程睡眠到时间就会自动苏醒，并返回到Runnable（可运行）中的就绪状态。
上面提到，调用yield()静态方法，也能暂停当前线程，那其与sleep()有何区别呢？
- sleep(long)方法会使线程转入超时等待状态，时间到了之后才会转入就绪状态。而yield()方法不会将线程转入等待，而是强制线程进入就绪状态。
- 使用sleep(long)方法需要处理异常
InterruptedException，而yield()不用。
Tips：sleep()中指定的时间是线程暂停运行的最短时间，不能保证该线程睡眠到时后就开始立刻执行。
3. 7 终止状态（TERMINATED）
即线程的终止，表示线程已经执行完毕。前面已经说了，已经消亡的线程不能通过start再次唤醒。
- run()和call()线程执行体中顺利执行完毕，线程正常终止。
- 线程抛出一个没有捕获的Exception或Error。
需要注意的是：主线成和子线程互不影响，子线程并不会因为主线程结束就结束。
四、等待唤醒机制
4. 1 线程间通信
概念：多个线程并发处理同一个资源，而任务却不同时，就需要线程通信来帮助解决线程之间对同一个变量的使用或操作。
比如：线程A用来生产茶叶，线程B用来消费茶叶，茶叶可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
为什么要处理线程间通信：
多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。
如何保证线程间通信有效利用资源：
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
4. 2 等待唤醒机制
（1）什么是等待唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比我们在公司中与同事关系，可能存在在晋升时的竞争，但更多时候是一起合作以完成某些任务。
wait/notify 就是线程间的一种协作机制。
就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）。在有多个线程进行等待时， 如果需要，可以使用notifyAll()来唤醒所有的等待线程。
（2）等待唤醒中的方法
等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：
- wait：线程不再活动，不再参与调度，释放它对锁的拥有权，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从WAITING状态中释放出来，重新进入到调度队列（ready queue）中
- notify：唤醒一个等待当前对象的锁的线程。唤醒在此对象监视器上等待的单个线程。
- notifyAll：唤醒在此对象监视器上等待的所有线程。
注意：
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下：
- 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
- 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态。
（3）调用wait和notify方法需要注意的细节
-
wait方法与notify方法必须要由同一个锁对象调用。因为对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
-
wait方法与notify方法是属于Object类的方法的。因为锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
-
wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为必须要通过锁对象调用这2个方法。
4. 3 生产者与消费者模式
在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
在解决生产者消费者问题时，常用方法之一就是使用 Object 的 wait/notify 的等待唤醒机制。
这里我们用到了 2 个队列：
- 同步队列：对应线程状态中的
RUNNABLE，线程处于准备就绪，等着可以抢占资源。 - 等待队列：对应于我讲的线程状态中的
WAITING，也就是等待状态。
实现：
这里我首先建了一个简单的 Product 类，用来表示生产和消费的产品。
public class Product {
private String name;
public Product(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
创建生产者类：
public class Producer implements Runnable {
private Queue<Product> queue;
private int maxCapacity;
public Producer(Queue<Product> queue, int maxCapacity) {
this.queue = queue;
this.maxCapacity = maxCapacity;
}
@Override
public void run() {
synchronized (queue) {
while (queue.size() == maxCapacity) {
try {
System.out.println("生产者" + Thread.currentThread().getName() + "Queue 已满，WAITING");
wait();
System.out.println("生产者" + Thread.currentThread().getName() + "退出等待");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (queue.size() == 0) { //队列里的产品从无到有，需要通知在等待的消费者
queue.notifyAll();
}
Integer i = new Random().nextInt(50);
queue.offer(new Product("产品" + i.toString()));
System.out.println("生产者" + Thread.currentThread().getName() + "生产了产品" + i.toString());
}
}
}
创建消费者类：
public class Consumer implements Runnable {
private Queue<Product> queue;
private int maxCapacity;
public Consumer(Queue queue, int maxCapacity) {
this.queue = queue;
this.maxCapacity = maxCapacity;
}
@Override
public void run() {
synchronized (queue) {
while (queue.isEmpty()) {
try {
System.out.println("消费者" + Thread.currentThread().getName() + "Queue已空，WAITING");
wait();
System.out.println("消费者" + Thread.currentThread().getName() + "退出等待");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (queue.size() == maxCapacity) {
queue.notifyAll();
}
Product product = queue.poll();
System.out.println("消费者" + Thread.currentThread().getName() + "消费了" + product.getName());
}
}
}
开启多线程：
public class TreadTest {
public static void main(String[] args) {
Queue<Product> queue = new ArrayDeque<>();
for (int i = 0; i < 10; i++) {
new Thread(new Producer((Queue<Product>) queue, 10)).start();
new Thread(new Consumer((Queue) queue, 10)).start();
}
}
}
测试结果：
生产者Thread-0生产了产品35
消费者Thread-1消费了产品35
生产者Thread-2生产了产品43
消费者Thread-3消费了产品43
消费者Thread-5Queue已空，WAITING
生产者Thread-6生产了产品17
生产者Thread-8生产了产品39
消费者Thread-7消费了产品17
生产者Thread-10生产了产品17
生产者Thread-12生产了产品3
消费者Thread-13消费了产品39
生产者Thread-14生产了产品10
消费者Thread-17消费了产品17
生产者Thread-16生产了产品8
消费者Thread-19消费了产品3
生产者Thread-4生产了产品29
消费者Thread-9消费了产品10
消费者Thread-11消费了产品8
消费者Thread-15消费了产品29
生产者Thread-18生产了产品33
五、线程池
5. 1 概述
- 线程池：其实是一种线程使用模式，解决线程频繁开启、关闭带来的性能开销问题。使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。
线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。
5. 2 线程池原理
Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。
在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。
Executors类中主要创建线程池的方法如下：
Executors.newCachedThreadPool()：无限线程池。Executors.newFixedThreadPool(nThreads)：创建固定大小的线程池。Executors.newSingleThreadExecutor()：创建单个线程的线程池。
查看三种方式创建的源码，发现都是通过ThreadPoolExecutor类来实现线程池的创建。
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
查看ThreadPoolExecutor类：
查看创建线程的 API：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
这几个核心参数的作用：
corePoolSize为线程池的基本大小。maximumPoolSize为线程池最大线程大小。keepAliveTime和unit则是线程空闲后的存活时间。workQueue用于存放任务的阻塞队列。handler当队列和最大线程池都满了之后的饱和策略。
在实际的运用中，提交一个任务到线程池中，核心的逻辑就是 execute() 函数。
在具体分析前，得先知悉线程池的状态转换。查看源码，发现定义有如下几类状态：
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
RUNNING自然是运行状态，指可以接受任务执行队列里的任务SHUTDOWN指调用了shutdown()方法，不再接受新任务了，但是队列里的任务得执行完毕。STOP指调用了shutdownNow()方法，不再接受新任务，同时抛弃阻塞队列里的所有任务并中断所有正在执行任务。TIDYING所有任务都执行完毕，在调用shutdown()/shutdownNow()中都会尝试更新为这个状态。TERMINATED终止状态，当执行terminated()后会更新为这个状态。
那么 execute() 核心到底做了什么：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get(); ------ 1
if (workerCountOf(c) < corePoolSize) { ------ 2
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) { ------ 3
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command)) ------ 4
reject(command);
else if (workerCountOf(recheck) == 0) ------ 5
addWorker(null, false);
}
else if (!addWorker(command, false)) ------ 6
reject(command);
}
- 获取当前线程池的状态。
- 当前线程数量小于
corePoolSize时创建一个新的线程运行。 - 如果当前线程处于运行状态，并且写入阻塞队列成功。
- 双重检查，再次获取线程状态；如果线程状态变了（非运行状态）就需要从阻塞队列移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
- 如果当前线程池为空就新创建一个线程并执行。
- 如果在第三步的判断为非运行状态，尝试新建线程，如果失败则执行拒绝策略。
由此可以窥探出线程池工作原理：
5. 3 线程池的使用
这里定义了一个使用线程池对象的方法如下：
-
public Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行Future接口：用来记录线程任务执行完毕后产生的结果。
使用线程池中线程对象的步骤：
- 创建线程池对象。
- 创建Runnable接口子类对象。(task)
- 提交Runnable接口子类对象。(take task)
- 关闭线程池(一般不做)。
Runnable实现类代码：
public class MyRunnable implements Runnable {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("获取到线程： " + Thread.currentThread().getName());
System.out.println(Thread.currentThread().getName() + "线程回到线程池");
}
}
线程池测试类：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author: Kai
* @DateTime: 2020/09/30 17:12
* @Description: TODO
*/
public class ThreadPoolTest {
public static void main(String[] args) {
// 1.创建线程池对象
ExecutorService pool= Executors.newFixedThreadPool(2);
// 2.创建Runnable实例对象
MyRunnable mr = new MyRunnable();
// 3.从线程池中获取线程对象，调用MyRunnable中的run()
pool.submit(mr);
// 再获取个线程对象，调用MyRunnable中的run()
pool.submit(mr);
// 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
// 将使用完的线程又归还到了线程池中
// 4.关闭线程池
pool.shutdown();
}
}
运行结果：
获取到线程： pool-1-thread-2
获取到线程： pool-1-thread-1
pool-1-thread-1线程回到线程池
pool-1-thread-2线程回到线程池
3043
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
