java线程
进程与线程（Thread）：死瑞特
进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好像是在同时运行一样。
多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在执行过程中可以产生多个更小的程序单元，这些更小的单元称为线程，这些线程可以同时存在，同时运行，一个进程可能包含多个同时执行的线程。进程与线程的区别如图所示：
Java中线程实现的方式
在 Java 中实现多线程有两种手段，一种是继承 Thread 类，另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。
实现 Runnable 接口
package ljz;
class MyThread implements Runnable{ // 实现Runnable接口，作为线程的实现类
private String name ; // 表示线程的名称
public MyThread(String name){
this.name = name ; // 通过构造方法配置name属性
}
public void run(){ // 覆写run()方法，作为线程 的操作主体
for(int i=0;i<10;i++){
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class RunnableDemo01{
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ; // 实例化对象
MyThread mt2 = new MyThread("线程B ") ; // 实例化对象
Thread t1 = new Thread(mt1) ; // 实例化Thread类对象
Thread t2 = new Thread(mt2) ; // 实例化Thread类对象
t1.start() ; // 启动多线程
t2.start() ; // 启动多线程
}
};程序运行结果：
继承 Thread 类
class MyThread extends Thread{ // 继承Thread类，作为线程的实现类
private String name ; // 表示线程的名称
public MyThread(String name){
this.name = name ; // 通过构造方法配置name属性
}
public void run(){ // 覆写run()方法，作为线程 的操作主体
for(int i=0;i<10;i++){
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class ThreadDemo02{
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ; // 实例化对象
MyThread mt2 = new MyThread("线程B ") ; // 实例化对象
mt1.start() ; // 调用线程主体
mt2.start() ; // 调用线程主体
}
};程序运行结果：
从程序可以看出，现在的两个线程对象是交错运行的，哪个线程对象抢到了 CPU 资源，哪个线程就可以运行，所以程序每次的运行结果肯定是不一样的，在线程启动虽然调用的是 start() 方法，但实际上调用的却是 run() 方法定义的主体。
Callable实现带返回值的线程
package com.gx.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ZhiBoPingTai {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//设置五个线程
ExecutorService service=Executors.newFixedThreadPool(5);
//实例化线程，设置直播间名称，增长人数的速度（如：500毫秒增长1人）
ZhiBoJian zhiBoJian1=new ZhiBoJian("王者荣耀", 500);
ZhiBoJian zhiBoJian2=new ZhiBoJian("绝地求生", 300);
ZhiBoJian zhiBoJian3=new ZhiBoJian("英雄联盟", 50);
ZhiBoJian zhiBoJian4=new ZhiBoJian("部落冲突", 200);
ZhiBoJian zhiBoJian5=new ZhiBoJian("美女", 10);
//Future 相当于是用来存放Executor执行的结果的一种容器
Future result1=service.submit(zhiBoJian1);
Future result2=service.submit(zhiBoJian2);
Future result3=service.submit(zhiBoJian3);
Future result4=service.submit(zhiBoJian4);
Future result5=service.submit(zhiBoJian5);
//5秒后线程睡眠
Thread.sleep(5000);
//设置各个直播间人数停止增长
zhiBoJian1.setStop(false);
zhiBoJian2.setStop(false);
zhiBoJian3.setStop(false);
zhiBoJian4.setStop(false);
zhiBoJian5.setStop(false);
//获取返回值
int count1=result1.get();
int count2=result2.get();
int count3=result3.get();
int count4=result4.get();
int count5=result5.get();
//输出
System.out.println(zhiBoJian1.getNameString()+"直播间有"+count1+"人");
System.out.println(zhiBoJian2.getNameString()+"直播间有"+count2+"人");
System.out.println(zhiBoJian3.getNameString()+"直播间有"+count3+"人");
System.out.println(zhiBoJian4.getNameString()+"直播间有"+count4+"人");
System.out.println(zhiBoJian5.getNameString()+"直播间有"+count5+"人");
service.shutdownNow();//现在关闭
}
}
class ZhiBoJian implements Callable {
private String nameString;//直播间名称
private int peoplenum = 0;//直播间人数
private boolean stop = true;//手动停止线程
private long speed;//增长人数的速度
public ZhiBoJian() {}//空构造器
public ZhiBoJian(String nameString) {
super();
this.nameString = nameString;
}
public ZhiBoJian(String nameString, long speed) {
super();
this.nameString = nameString;
this.speed = speed;
}
@Override
public Integer call() throws Exception {//实现call方法
while (stop) {
Thread.sleep(speed);
peoplenum++;
}
return peoplenum;
}
public String getNameString() {
return nameString;
}
public void setStop(boolean stop) {
this.stop = stop;
}
}
输出结果是：
Runnable和Callable的区别
(1) Callable规定的方法是 call(), Runnable规定的方法是 run()。
(2) Callable的任务执行后可返回值，而 Runnable的任务是不能返 回值。
(3) call方法可以抛出异常， run方法不可以。
(4)运行 Callable任务可以拿到一个 Future对象
在实现接口时，Callable后又对尖括号中间还有个T，如：，这就是泛型，里面尖括号填写你的返回值的类型：
如：
class ZhiBoJian implements Callable1 在实现call方法时，返回值的类型也要一样，如：
public Integer call() 它也支持抛出异常 在它后面可以加上 throws Exception通过 Thread 类和 Runable 接口都可以实现多线程，那么两者有哪些联系和区别呢？下面我们观察 Thread 类的定义。
public class Thread extends Object implements Runnable从 Thread 类的定义可以清楚的发现，Thread 类也是 Runnable 接口的子类，但在Thread类中并没有完全实现 Runnable 接口中的 run() 方法，下面是 Thread 类的部分定义。
Private Runnable target；
public Thread(Runnable target,String name){
init(null,target,name,0);
}
private void init(ThreadGroup g,Runnable target,String name,long stackSize){
...
this.target=target;
}
public void run(){
if(target!=null){
target.run();
}
}从定义中可以发现，在 Thread 类中的 run() 方法调用的是 Runnable 接口中的 run() 方法，也就是说此方法是由 Runnable 子类完成的，所以如果要通过继承 Thread 类实现多线程，则必须覆写 run()。
实际上 Thread 类和 Runnable 接口之间在使用上也是有区别的，如果一个类继承 Thread类，则不适合于多个线程共享资源，而实现了 Runnable 接口，就可以方便的实现资源的共享。
线程的状态变化
要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有5种状态，即创建，就绪，运行，阻塞，终止。下面分别介绍一下这几种状态：
- 创建状态
在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存空间和其他资源，但还处于不可运行状态。新建一个线程对象可采用Thread 类
的构造方法来实现，例如 “Thread thread=new Thread()”。
- 就绪状态
新建线程对象后，调用该线程的 start() 方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。
- 运行状态
当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。
- 阻塞状态
一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线程都将进入阻塞状态，发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。
- 死亡状态
线程调用 run() 方法执行结束后，即处于死亡状态。运行的能力。处于死亡状态的线程不具有继续
在此提出一个问题，Java 程序每次运行至少启动几个线程？
回答：至少启动两个线程，每当使用 Java 命令执行一个类时，实际上都会启动一个 JVM，每一个JVM实际上就是在操作系统中启动一个线程，Java 本身具备了垃圾的收集机制。所以在 Java 运行时至少会启动两个线程，一个是 main 线程，另外一个是垃圾收集线程。
取得和设置线程的名称
class MyThread implements Runnable{ //实现Runnable接口
public void run(){
for(int i=0;i<3;i++){
System.Out.Println(Thread.currentThread().getName()+"运行, i="+i); //取得当前线程的名称
}
}
};
public class ThreadDemo{
public static void main(String args[]){
MyThread my=new MyThread(); //定义Runnable子类对象
new Thread(my).start; //系统自动设置线程名称
new Thread(my,"线程A").start(); //手工设置线程名称
}
};程序运行结果：
线程的操作方法
线程的强制运行
在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。
public static void main(String[] args) {
Thread t1=new Thread(()->{
for(int i=1;i<6;i++){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程A执行的第"+i+"次运行");
}
},"线程A");
Thread t2=new Thread(()->{
for(int i=1;i<6;i++){
try {
t1.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程B执行的第"+i+"次运行");
}
},"线程B");
t2.start();
t1.start();
}程序运行结果：
线程的休眠
在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 即可实现休眠。
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
for(int i=0;i<50;i++){
try{
Thread.sleep(500) ; // 线程休眠
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()
+ "运行，i = " + i) ; // 取得当前线程的名字
}
}
};
public class ThreadSleepDemo{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 实例化Runnable子类对象
Thread t = new Thread(mt,"线程"); // 实例化Thread对象
t.start() ; // 启动线程
}
};程序执行结果：
中断线程
它并不像stop方法那样会中断一个正在运行的线程。线程会不时地检测中断标识位，以判断线程是否应该被中断（中断标识值是否为true）。中断只会影响到wait状态、sleep状态和join状态。被打断的线程会抛出InterruptedException。Thread.interrupted()检查当前线程是否发生中断，返回boolean。synchronized在获锁的过程中是不能被中断的。
中断是一个状态！interrupt()方法只是将这个状态置为true而已。所以说正常运行的程序不去检测状态，就不会终止，而wait等阻塞方法会去检查并抛出异常。
interrupt()：设置当前中断标志位为true；
interrupted()：检查当前线程是否发生中断（即中断标志位是否为true）
设置中断标志位后，只能通过wait()、sleep()、join()判断标志位，若标志位为true，会抛出InterruptedException异常，捕获异常后，手动中断线程或进行其他操作。
当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。
程序运行结果是：
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
for (int i = 1; i < 6; i++) {
System.out.println("线程A执行的第" + i + "次运行");
}
}, "线程A");
Thread t2 = new Thread(() -> {
try {
t1.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
for (int i = 1; i < 6; i++) {
System.out.println("线程B执行的第" + i + "次运行");
}
}, "线程B");
Thread t3 = new Thread(() -> {
t2.interrupt();
System.out.println("dsafdsa");
});
t2.start();
t1.start();
t3.start();
}
后台线程【守护线程】
在 Java 程序中，只要前台有一个线程在运行，则整个 Java 进程都不会消失，所以此时可以设置一个后台线程，这样即使 Java 线程结束了，此后台线程依然会继续执行，要想实现这样的操作，直接使用 setDaemon() 方法即可。
public static void main(String[] args) throws InterruptedException {
System.out.println("main方法执行开始");
Thread t1 = new Thread(() -> {
for (;;) {
System.out.println("线程A执行运行");
}
}, "线程A");
t1.setDaemon(true);
t1.start();
Thread.sleep(10000);
System.out.println("main方法执行结束");
}在线程类 MyThread 中，尽管 run() 方法中是死循环的方式，但是程序依然可以执行完，因为方法中死循环的线程操作已经设置成后台运行。
线程优先级
每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。Java 线程的优先级是一个整数，其取值范围是1(Thread.MIN_PRIORITY)到10(Thread.MAX_PRIORITY)。默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY(5)。具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。
在 Java 的线程操作中，所有的线程在运行前都会保持在就绪状态，那么此时，哪个线程的优先级高，哪个线程就有可能会先被执行。
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
for(int i=0;i<5;i++){
try{
Thread.sleep(500) ; // 线程休眠
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName()
+ "运行，i = " + i) ; // 取得当前线程的名字
}
}
};
public class ThreadPriorityDemo{
public static void main(String args[]){
Thread t1 = new Thread(new MyThread(),"线程A") ; // 实例化线程对象
Thread t2 = new Thread(new MyThread(),"线程B") ; // 实例化线程对象
Thread t3 = new Thread(new MyThread(),"线程C") ; // 实例化线程对象
t1.setPriority(Thread.MIN_PRIORITY) ; // 优先级最低
t2.setPriority(Thread.MAX_PRIORITY) ; // 优先级最高
t3.setPriority(Thread.NORM_PRIORITY) ; // 优先级最中等
t1.start() ; // 启动线程
t2.start() ; // 启动线程
t3.start() ; // 启动线程
}
};程序运行结果：
从程序的运行结果中可以观察到，线程将根据其优先级的大小来决定哪个线程会先运行，但是需要注意并非优先级越高就一定会先执行，哪个线程先执行将由 CPU 的调度决定。
线程的礼让
在线程操作中，也可以使用 yield() 方法将一个线程的操作暂时让给其他线程执行
具体的礼让效果看CPU是单核还是多核
.yield()方法只是提出申请释放CPU资源，至于能否成功释放由JVM决定。
由于这个特性，一般编程中用不到此方法，但在很多并发工具包中，yield()方法被使用，如AQS、ConcurrentHashMap、FutureTask等。
②.调用了yield()方法后，线程依然处于RUNNABLE状态，线程不会进入堵塞状态。
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
for(int i=0;i<5;i++){
try{
Thread.sleep(500) ;
}catch(Exception e){
}
System.out.println(Thread.currentThread().getName()
+ "运行，i = " + i) ; // 取得当前线程的名字
if(i==2){
System.out.print("线程礼让：") ;
Thread.yield() ; // 线程礼让
}
}
}
};
public class ThreadYieldDemo{
public static void main(String args[]){
MyThread my = new MyThread() ; // 实例化MyThread对象
Thread t1 = new Thread(my,"线程A") ;
Thread t2 = new Thread(my,"线程B") ;
t1.start() ;
t2.start() ;
}
};程序执行结果：
并发与并行的区别
程序安全和不安全：
挤公交：人少安全。
人多：不安全。找个人然后监督有序排队。
线程：单个线程是安全。
多线程就是不安全。
判断标准是啥？
运行的结果和期望的结果不一致。
那种情况要考虑多线程的安全问题：
操作公共的数据比如全局变量，数据库一条数据，redis中的一个缓存。
public static int count=100;
public static void m1(){
count = count +5;
for (int i = 0; i < 3; i++) {
System.out.println("方法m1执行第："+i+"次");
}
}并行和并发。
如果某个系统支持两个或者多个动作（Action）同时存在，那么这个系统就是一个并发系统。如果某个系统支持两个或者多个动作同时执行，那么这个系统就是一个并行系统。并发系统与并行系统这两个定义之间的关键差异在于“存在”这个词。
在并发程序中可以同时拥有两个或者多个线程。这意味着，如果程序在单核处理器上运行，那么这两个线程将交替地换入或者换出内存。这些线程是同时“存在”的——每个线程都处于执行过程中的某个状态。如果程序能够并行执行，那么就一定是运行在多核处理器上。此时，程序中的每个线程都将分配到一个独立的处理器核上，因此可以同时运行。
“并行”概念是“并发”概念的一个子集。也就是说，你可以编写一个拥有多个线程或者进程的并发程序，但如果没有多核处理器来执行这个程序，那么就不能以并行方式来运行代码。因此，凡是在求解单个问题时涉及多个执行流程的编程模式或者执行行为，都属于并发编程的范畴。
用一个极其简单的生活实例来解释如下：
你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。
你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。
你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。
并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。
同步以及死锁
一个多线程的程序如果是通过 Runnable 接口实现的，则意味着类中的属性被多个线程共享，那么这样就会造成一种问题，如果这多个线程要操作同一个资源时就有可能出现资源同步问题。
解决方法：
同步代码块
synchronized(同步对象)｛
需要同步的代码
｝class MyThread implements Runnable{
private int ticket = 5 ; // 假设一共有5张票
public void run(){
for(int i=0;i<100;i++){
synchronized(this){ // 要对当前对象进行同步
if(ticket>0){ // 还有票
try{
Thread.sleep(300) ; // 加入延迟
}catch(InterruptedException e){
e.printStackTrace() ;
}
System.out.println("卖票：ticket = " + ticket-- );
}
}
}
}
};
public class SyncDemo02{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 定义线程对象
Thread t1 = new Thread(mt) ; // 定义Thread对象
Thread t2 = new Thread(mt) ; // 定义Thread对象
Thread t3 = new Thread(mt) ; // 定义Thread对象
t1.start() ;
t2.start() ;
t3.start() ;
}
};程序执行结果：
同步方法
除了可以将需要的代码设置成同步代码块外，也可以使用 synchronized 关键字将一个方法声明为同步方法。
synchronized 方法返回值 方法名称（参数列表）｛
｝class MyThread implements Runnable{
private int ticket = 5 ; // 假设一共有5张票
public void run(){
for(int i=0;i<100;i++){
this.sale() ; // 调用同步方法
}
}
public synchronized void sale(){ // 声明同步方法
if(ticket>0){ // 还有票
try{
Thread.sleep(300) ; // 加入延迟
}catch(InterruptedException e){
e.printStackTrace() ;
}
System.out.println("卖票：ticket = " + ticket-- );
}
}
};
public class SyncDemo03{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 定义线程对象
Thread t1 = new Thread(mt) ; // 定义Thread对象
Thread t2 = new Thread(mt) ; // 定义Thread对象
Thread t3 = new Thread(mt) ; // 定义Thread对象
t1.start() ;
t2.start() ;
t3.start() ;
}
};程序执行结果：
从程序运行的结果可以发现，此代码完成了与之前同步代码同样的功能。
死锁
同步可以保证资源共享操作的正确性，但是过多同步也会产生问题。例如，现在张三想要李四的画，李四想要张三的书，张三对李四说“把你的画给我，我就给你书”，李四也对张三说“把你的书给我，我就给你画”两个人互相等对方先行动，就这么干等没有结果，这实际上就是死锁的概念。
所谓死锁，就是两个线程都在等待对方先完成，造成程序的停滞，一般程序的死锁都是在程序运行时出现的。
下面以一个简单范例说明这个概念
class Zhangsan{ // 定义张三类
public void say(){
System.out.println("张三对李四说：“你给我画，我就把书给你。”") ;
}
public void get(){
System.out.println("张三得到画了。") ;
}
};
class Lisi{ // 定义李四类
public void say(){
System.out.println("李四对张三说：“你给我书，我就把画给你”") ;
}
public void get(){
System.out.println("李四得到书了。") ;
}
};
public class ThreadDeadLock implements Runnable{
private static Zhangsan zs = new Zhangsan() ; // 实例化static型对象
private static Lisi ls = new Lisi() ; // 实例化static型对象
private boolean flag = false ; // 声明标志位，判断那个先说话
public void run(){ // 覆写run()方法
if(flag){
synchronized(zs){ // 同步张三
zs.say() ;
try{
Thread.sleep(500) ;
}catch(InterruptedException e){
e.printStackTrace() ;
}
synchronized(ls){
zs.get() ;
}
}
}else{
synchronized(ls){
ls.say() ;
try{
Thread.sleep(500) ;
}catch(InterruptedException e){
e.printStackTrace() ;
}
synchronized(zs){
ls.get() ;
}
}
}
}
public static void main(String args[]){
ThreadDeadLock t1 = new ThreadDeadLock() ; // 控制张三
ThreadDeadLock t2 = new ThreadDeadLock() ; // 控制李四
t1.flag = true ;
t2.flag = false ;
Thread thA = new Thread(t1) ;
Thread thB = new Thread(t2) ;
thA.start() ;
thB.start() ;
}
};程序运行结果：
李四对张三说：“你给我书，我就把画给你”
张三对李四说：“你给我画，我就把书给你”
Java 线程等待通知机制（wait、notify）
线程等待/通知机制简介
假设有两个线程，一个生产数据，一个消费数据。如何保证生产线程生产出数据后通知给消费线程，消费线程在没有数据可被消费情况下等待有数据呢？
一般的做法是采用轮询方法，一直 while 循环（中间睡眠几毫秒）判断是否有数据。该办法可能存在的问题是
1. 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
2.难以降低开销。如果降低睡眠的时间，比如休眠 1 毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
Java 通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。
等待/通知机制，是指一个线程 A 调用了对象 O 的 wait 方法进入等待状态，而另一个线程 B 调用了对象 O 的 notify 或者 notifyAll 方法，线程 A 收到通知后从对象 O 的 wait 方法返回，进而执行后续操作。上述两个线程通过对象 O 来完成交互，而对象上的 wait 和 notify/notifyAll 的 关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
怎么实现线程等待/通知机制
Object 作为所有对象的父类，其中与等待通知机制相关几个方法如下：
wait : 调用该方法线程进入 WAITING 状态，只有等待其他线程的通知或者被中断才会返回（调用后会释放锁，sleep 不会）
wait（超时设置） : 在 wait 方法的基础上增加了超时，达到超时设置后如果没有通知或者中断也会返回
notify : 通知一个在对象上等待的线程 A（调用过 wait 方法的线程），使其从 wait 方法返回，前提是该线程 A 获取到了对象锁。（多线程存在锁竞争）
notifyAll : 通知所有等待在该对象上的线程
代码实战分析
例子中，创建了两个线程-WaitThread 和 NotifyThread，前者检查 flag 值是否为 false，如果符合要求，进行后续操作，否则在 lock 上等待，后者在睡眠了一段时间 后对 lock 进行通知。
等待方 (消费者) 和通知方 (生产者)
public class WaitAndNotifyExample {
public static boolean FLAG = true;
public static final Object LOCK = new Object();
public static void main(String[] args) {
new Thread(new Wait(), "[WaitThread]").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException ignored) {
}
new Thread(new Notify(), "[NotifyThread]").start();
}
}
class Wait implements Runnable {
@Override
public void run() {
synchronized (LOCK) {
final String threadName = Thread.currentThread().getName();
while (FLAG) {
System.out.println(new Date() + threadName + " FLAG = true , wait...");
try {
LOCK.wait();
} catch (InterruptedException ignored) {
}
}
System.out.println(new Date() + threadName + " FLAG = false，开始继续工作");
}
}
}
class Notify implements Runnable {
@Override
public void run() {
synchronized (LOCK) {
final String threadName = Thread.currentThread().getName();
System.out.println(new Date() + threadName + " 持有锁，发出通知");
LOCK.notifyAll();
FLAG = false;
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException ignored) {
}
synchronized (LOCK) { // 再次加锁，目的：测试调用 notifyAll 方法后被唤醒的线程是否立即执行
System.out.println(new Date() + threadName + " 再次拿到锁. sleep @ ");
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException ignored) {
}
}
}
}
}最终打印：
Thu Dec 19 15:41:33 CST 2019[WaitThread] FLAG = true , wait…
Thu Dec 19 15:41:34 CST 2019[NotifyThread] 持有锁，发出通知
Thu Dec 19 15:41:39 CST 2019[NotifyThread] 再次拿到锁. sleep @
Thu Dec 19 15:41:44 CST 2019[WaitThread] FLAG = false，开始继续工作执行细节说明：
1.使用 wait、notify 和 notifyAll 时需要先对调用对象加锁。
2.调用 wait 方法后，线程状态由 RUNNING 变为 WAITING，并将当前线程放置到对象的等待队列。
3.notify 或 notifyAll 方法调用后，等待线程依旧不会从 wait() 返回，需要调用 notify 或 notifyAll 的线程释放锁之后，等待线程才有机会从 wait 返回。
4.notify 方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而 notifyAll 方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由 WAITING 变为 BLOCKED。
5.从 wait 方法返回的前提是获得了调用对象的锁。
