JAVA多线程：yield/join/wait/notify/notifyAll等方法的作用（二）

女爷i 2023-10-01 19:16 18阅读 0赞

## 前言 ##

讨论这个问题前，需要先了解以下知识点！

> 1、等待队列（blocked）中的线程不参与cpu竞争，就绪队列(runable)中的线程才会参与cpu竞争。  
> 2、CPU竞争策略有多种，Unix使用的是时间片算法，Windows属于抢占式。

> a)时间片：  
> 所有的进程排成一个队列。操作系统按照他们的顺序，给每个进程分配一段时间，即允许该进程运行的时间。  
>   
> b)抢占式操作系统  
> 就是说如果一个进程得到了 CPU 时间，除非它自己放弃使用 CPU ，否则将完全霸占 CPU 。因此可以看出，在抢 占式操作系统中，操作系统假设所有的进程都是“人品很好”的，会主动退出 CPU 。

## 一、start()用来启动一个线程 ##

> 调用该方法后，相应线程就会进入就绪状态，也就是runable状态，等待某个时机被CPU调用。  
> 声明：wait() 、notify()、notifyAll()是Object类的方法，不是Thread类的方法。

## 二、yield()让线程让出CPU的执行（不释放锁） ##

> 该方法与sleep()类似，不能由用户指定暂停多长时间，它的作用是放弃当前CPU资源，让给其他线程去使用，但是放弃时间不确定。
> 
> 它并不会让线程进入阻塞状态，而是让线程回到就绪状态，随时等待重新得到CPU的执行。
> 
> 实际中无法保证yield()达到让步目的，因为让步的线程还有可能会再次被线程调度程序选中。

注意：

1.yield()并不会释放锁，仅仅是暂时交出了占用CPU执行权限。

2.yield()的线程有可能在进入到可执行状态后马上又被执行。

3.yield()方法只能使同优先级或者高优先级的线程得到执行机会，这也和sleep()方法不同。

通常配合Thread.activeCount()使用：

while(Thread.activeCount()>1) {
    	Thread.yield();//保障前面的线程都执行完
    }

注：这里的1指的是主线程，如果你的main方法中new了一个线程类4个实例对象，分别启动这4各类的实例，那么就至少会有4个主线程（这里就需要用4去判断，所有子线程是否执行完毕）

### 使用场景示例 ###

public class VolatileTest {
    	public volatile int num = 0;
    
    	public synchronized void increase() {
    		num++;
    	}
    
    	public static void main(String[] args) {
    		final VolatileTest test = new VolatileTest();
    		for (int i = 0; i < 10; i++) {
    			//开启10个子线程，对num同时操作
    			new Thread() {
    				public void run() {
    					for (int j = 0; j < 1000; j++) {
    						test.increase();
    					}
    				}
    			}.start();
    		}
    
    		while(Thread.activeCount()>1) {
    			Thread.yield();//保障前面的线程都执行完
    		}
    		System.out.println(test.num);
    		System.out.println(Thread.activeCount());
    	}
    }

## 三、join()会释放Thread的锁，不会释放对象锁 ##

> 简单的说：如果在main方法中，调用其他线程的join方法，则main方法的主线程A就需要给其他线程B让步，让B先执行完，主线程A才能继续执行，相当于阻塞主线程，直到被唤醒。
> 
> 注：阻塞状态，它是让“外层的主线程”从 RUNNABLE 变为 WAITING 状态（因为join的底层就是wait()）。
> 
> join(long millis)方法：执行当前A线程交出CPU执行权限millis后，再和其它线程一起竞争CPU资源。
> 
> 如果在A主线程中，一次join了多个其他线程B/C/D，则被join的多个子线程执行的先后顺序不影响，都是并行执行。
> 
> 注意：
> 
> 1、如果有两个线程同时调用另外一个线程的join方法，会有一个线程成功得到锁，而另外一个则必须等待，进入阻塞状态，而在得到锁之后，才会执行join方法。
> 
> 2、join底层使用wait，wait会释放锁，但是wait释放的是Thread的锁，所以Join在设计的时候也只是会释放Thread的锁，不会释放线程对象的锁，[点击：进入代码示例][Link 1]。

如果看完，依然有疑问：那就单独列出来讨论一下。

join底层调用的是wait()，而wait是Object的方法，wait本身是会释放锁（彻底交出CPU的执行权），所以 Thread 的join() 方法是否会释放锁？答案是会！

[点击进入：狂抓！join()方法到底会不会释放锁，给你彻底介绍清楚（带示例）][Link 1]

## 四、sleep()进入阻塞状态，让其他线程得到执行机会（不释放锁） ##

> 该方法需要指定等待的时间，它可以让当前正在执行的线程在指定的时间内暂停执行，进入阻塞状态，让其他线程得到执行机会。但是sleep()方法不会释放“锁标志”，其他线程仍然不能访问被锁定的共享数据。
> 
> [点击进入：sleep(0)、sleep(1)、sleep(1000)的区别][sleep_0_sleep_1_sleep_1000]

举例：

> 1、拿 "点火->烧水->煮面"来说事儿，而当A点完火之后，并不想不立即烧水，要休息一段时间再烧，煮面的主动权是由A来控制(不释放锁)。
> 
> 2、再拿看三个人看电视来说，A只是想休息一下，并不想交出遥控（锁），此时调用sleep(10)，指定个休息时间；如果来了个管理员，需要让A交出遥控器，需要调用wait(10)方法，调用wait的同时，A立刻交出遥控，在wait的10毫秒期间，不参与遥控的竞争，10毫秒后几个人重新争夺遥控（锁）。

### 1.它需要捕获InterruptedException异常 ###

如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出，而wait，notify和notifyAll不需要捕获异常。

### 2.不会释放对象锁，其他线程无法访问这个对象 ###

sleep方法不会释放该线程所拥有的资源（例如：锁），也就是说如果当前线程持有对某个对象的锁，其他线程也无法访问这个共享对象。

## 五、Object类的三个方法wait()，notify()和notifyAll() ##

> wait 与 notify/notifyAll 方法必须在synchronized 同步代码块中使用，即要先对调用对象加锁，不放在synchronized 中则会在程序运行时抛出“java.lang.IllegalMonitorStateException”异常。
> 
> ReenTrantLock.newCondition()获取一个Condition类对象，然后Condition的await()，signal()以及signalAll()分别对应上面的三个方法。ReenTrantLock是Lock接口的实现类。

### 1.wait()指定时间内不参与锁的竞争(释放锁) ###

> 到时间会自动唤醒；否则就需要 notify / notifyAll 去唤醒。
> 
> 它和sleep的重要区别是，sleep是Thread类的方法，wait是Object的方法。wait调用时，需写在synchronized代码块内。

拿看电视来举例，三个人看电视，锁就是遥控器。

> A正在拿遥控器，一旦调用wait时，意味着A立刻交出遥控器（释放锁），至于交给B还是C，有JVM来控制。
> 
> 那么，拿到遥控器的，可以每隔10秒，换一个电视台，这间隔的10秒就需要sleep实现，因为遥控仍在他手上，并没有交出遥控（sleep不释放锁）。

### 2.notify()和notifyAll()叫醒一个或所有线程参与锁的竞争 ###

> notify() 只会唤醒一个线程，notifyAll() 会唤醒所有的线程。
> 
> notifyAll() 调用后，会将全部线程由等待池（等待队列）移到锁池（就绪队列），然后参与锁的竞争，竞争成功则意味着获取到了CPU的执行权（不一定会立刻被CPU执行），如果不成功则留在锁池等待锁被释放后再次参与竞争。而 notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制。

## 总结 ##

这些方法相互之间总是容易混淆，重点记忆两点：

> 1、他们的父类不同：
> 
> wait()，notify()和notifyAll()三个方法属于Object类，只有用在synchronized代码同步块中才有意义。其他几个方法都属于Thread线程。
> 
> 2、关于锁的获取是释放
> 
> wait会释放锁，yield、join()、park()、都不释放锁，需要注意的是join不释放对象锁，释放thread的锁（[更多，点击进入][Link 1]）

## 尾言 ##

> 学好多线程，这些都是绕不过去的点，只能深挖后一个一个突破，加油！

猜你还可能会对以下内容感兴趣：

1、 [JAVA多线程：synchronized理论和用法 | Lock和ReentrantLock Volatile 区别和联系（一）][JAVA_synchronized_ _ Lock_ReentrantLock Volatile]

2、[JAVA多线程：sleep(0)、sleep(1)、sleep(1000)的区别（四）][sleep_0_sleep_1_sleep_1000]

3、[JAVA多线程：join()方法到底会不会释放锁，给你彻底介绍清楚（三）][Link 1]

[Link 1]: https://blog.csdn.net/succing/article/details/123023851
[sleep_0_sleep_1_sleep_1000]: https://blog.csdn.net/succing/article/details/123024623
[JAVA_synchronized_ _ Lock_ReentrantLock Volatile]: https://blog.csdn.net/succing/article/details/122907616