Java多线程Day05-多线程之线程等待与唤醒

川长思鸟来 2022-12-01 14:05 222阅读 0赞

### 线程等待与线程唤醒 ###

*  线程的等待与唤醒方法
 *  wait()与notify()
 *  wait(long timeout)与notify()
 *  wait()与notifyAll()
 *  问题

# 线程的等待与唤醒方法 #

*  在**Object.java**中,定义了**wait(), notify()** 和**notifyAll()** 等接口:
    
     *  **wait()的作用:**
        
         *  让当前线程进入等待状态
         *  **wait()** 也会让当前线程释放所持有的锁
     *  **notify()和notifyAll()的作用:**
        
         *  唤醒当前对象上等待的所有线程
         *  **notify()** 是唤醒单个线程
         *  **notifyAll()** 是唤醒所有线程
 *  **notify():** 唤醒此对象监视器上等待的单个线程
 *  **notifyAll():** 唤醒此对象监视器上等待的所有线程
 *  **wait():** 让当前线程处于等待或者堵塞状态,直到其余线程调用此对象的**notify()** 方法或者**notifyAll()** 方法,当前线程被唤醒进入就绪状态
 *  **wait(long timeout):** 让当前线程处于等待或者阻塞状态,直到其余线程调用此对象的**notify()** 方法或者**notifyAll()** 方法,或者等待时间超过指定的时间,当前线程被唤醒进入就绪状态
 *  **wait(long timeout, int nanos):** 让当前线程处于等待或者阻塞状态,直到其余线程调用此对象的**notify()** 方法或者**notifyAll()** 方法,或者其余某个线程中断当前线程,或者等待时间超过指定的时间,当前线程被唤醒进入就绪状态

# wait()与notify() #

class MyThread extends Thread { 
    	public MyThread(String name) { 
    		super(name);
    	}
    
    	public viod run() { 
    		synchronized(this) { 
    			System.out.println(Thread.currentThread().getName() + "调用notify()方法");
    			// 唤醒当前的wait线程
    			notify();
    		}
    	}
    }
    
    public class WaitTest { 
    	public static void main(String[] args) { 
    		Thread thread1 = new Thread("thread1");
    
    		synchronized(thread1) { 
    			try { 
    				System.out.println(Thread.currentThread().getName() + "启动线程thread1");
    				thread1.start();
    
    				System.out.println(Thread.currentThread().getName() + "调用wait()方法");
    				thread1.wait();
    
    				System.out.println(Thread.currentThread().getName() + "继续执行");
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    }

main启动线程thread1
    main调用wait()方法
    main调用notify()方法
    main继续执行

![在这里插入图片描述][format_png_pic_center]

*  主线程代表主线程**main.** 线程**t1**代表**WaitTest**中启动的线程**Thread1.** 锁代表**thread1**对象的同步锁
 *  主线程**main**通过**new Thread(“thread1”)** 新建线程**thread1.** 然后通过**synchronized(thread1)** 获取对象的同步锁.接着调用**thread1.start()** 方法启动线程**thread1**
 *  主线程**main**执行**thread1.wait()** 释放 **“thread1对象的锁”** 并且进入 **“等待或者阻塞状态”,** 等待**thread1**对象上的线程通过**notify()** 或者**notifyAll()** 唤醒
 *  线程**thread1**运行之后,通过**synchronized(this)** 获取当前对象的锁,然后调用**notify()** 方法唤醒当前对象上的等待线程,即唤醒主线程**main**
 *  线程**thread1**运行结束后,释放当前对象的锁.然后主线程**main**获取**thread**对象的锁,接着运行
 *  **问题:** **thread1.wait()** 应该是让线程**thread1**等待,但是为什么让主线程**main**等待了?
    
     *  **wait()** 作用是让 **\[当前线程\]** 等待 **,\[当前线程\]** 是指正在**CPU**上运行的线程
     *  意味着尽管**thread1.wait()** 是通过线程**thread1**调用的**wait()** 方法,但是调用**thread.wait()** 的位置

# wait(long timeout)与notify() #

*  **wait(long timeout)** 会让当前线程处于等待阻塞状态,直到其余线程调用此对象的**notify()** 方法或**notifyAll()** 方法或者超过指定的时间量,当前线程被唤醒进入就绪状态  
    ![在这里插入图片描述][format_png_pic_center 1]
 *  主线程**main**执行**t1.start()启动线程t1**
 *  主线程**main**执行**t1.wait(3000),** 主线程**main**进入阻塞状态. 需要使用**t1**对象锁的线程通过**notify()** 或者**notifyAll()** 唤醒或者超时**3000ms**之后自动唤醒,主线程进入就绪状态,然后才可以运行
 *  线程**t1**运行之后,进入循环会不断地运行
 *  超时**3000ms**之后,主线程**main**会进入就绪状态,然后接着进入运行状态

# wait()与notifyAll() #

*  **notifyAll():** 唤醒此对象监视器上等待的所有线程  
    ![在这里插入图片描述][format_png_pic_center 2]
 *  主线程新建并启动了**3**个线程**t1, t2, t3**
 *  主线程通过**sleep(3000)** 休眠**3**秒,在主线程休眠**3**秒的过程中,线程**t1, t2, t3**都运行了.运行的线程会执行**obj.wait()** 方法等待其余线程通过**notify()** 或者**notifyAll()** 来唤醒线程
 *  主线程休眠**3**秒之后,接着运行,执行**obj.notifyAll()** 唤醒**obj**上的等待线程,即等待的线程**t1, t2, t3.** 紧接着,主线程的**synchronized(obj)** 运行完毕之后,主线程释放**obj**锁,这样线程**t1, t2, t3**就可以获取**obj**锁继续运行

# 问题 #

*  **notify()是依据什么唤醒等待线程的,即wait()和notify()之间是通过什么相互关联的?**
    
     *  对象的同步锁
 *  **为什么notify().wait()等函数方法定义在Object类中,而不是定义在Thread类中?**
    
     *  **Object**类中的**wait()** 和**notify()** 等函数方法是和**synchronized**一样,会对 **\[对象的同步锁\]** 进行操作
     *  **wait()** 会使 **\[当前线程\]** 等待,因为线程进入等待状态,所以线程应该释放持有的 **\[对象的同步锁\],** 否则其余线程获取不到该 **\[对象的同步锁\]** 而无法运行
     *  线程调用**wait()** 之后,会释放持有的 **\[对象的同步锁\],** 等待线程被**notify()** 或者**notifyAll()** 唤醒
     *  负责唤醒等待线程的唤醒线程,只有在获取该对象的 **\[对象的同步锁\],** 即等待线程的同步锁,并且调用**notify()** 或者**notifyAll()** 方法之后,才能唤醒等待线程.被唤醒的等待线程进入就绪状态,不能立即执行.因为唤醒线程还持有着该对象的 **\[对象的同步锁\],** 必须等到唤醒线程释放了该对象的 **\[对象的同步锁\]** 之后,等待线程才能获取到该对象的 **\[对象的同步锁\]** 继续运行
     *  总的来说 **,notify(),wait()** 等方法依赖于 **\[对象的同步锁\],\[对象的同步锁\]** 是对象持有的,并且每个对象有且仅有一个. 这就是**notify(),wait()** 等函数方法定义在**Object**类中而不是**Thread**类中的原因

[format_png_pic_center]: /images/20221123/02243377539d4ecda851bf726d058327.png
[format_png_pic_center 1]: /images/20221123/9bac5b88250f4b87a937e3aeb9549695.png
[format_png_pic_center 2]: /images/20221123/7bbedbf70162453fa018c88875621dfe.png