Java多线程（三）

Java多线程（三）


目录

• Java多线程（三）
  
  
  
  • 
    
    
    
    • 五、线程的通信
      
      
      
      • 5.1 wait() 与 notify() 和 notifyAll() 介绍：
        
      • 5.2 wait() 的使用：
        
      • 5.3 notify() / notifyAll() 的使用
        
      • 5.4 经典例题：生产者/消费者问题
        
      
      
    • 六、JDK5.0新增多线程创建方式
      
      
      
      • 6.1 多线程的创建方式之三：实现Callable接口
        
      • 6.2 多线程的创建方式之四：使用线程池
        
      
      
    
    
  
  

五、线程的通信

5.1 wait() 与 notify() 和 notifyAll() 介绍：

• wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify() 或 notifyAll() 方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
  
• notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
  
• notifyAll ()：唤醒正在排队等待资源的所有线程结束等待。
  

• 这三个方法只有在 synchronized 方法 或 synchronized 代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常。
  
• 因为这三个方法必须有锁对象调用，而任意对象都可以作为 synchronized 的同步锁， 因此这三个方法只能在Object类中声明。
  

5.2 wait() 的使用：

• 在当前线程中调用方法： 对象名.wait() 。
  
• 使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify  (或notifyAll) 为止。
  
• 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）。
  
• 调用此方法后，当前线程将释放对象监控权 ，然后进入等待。
  
• 在当前线程被 notify 后，要重新获得监控权，然后从断点处继续代码的执行。
  

5.3 notify() / notifyAll() 的使用

• 在当前线程中调用方法： 对象名.notify()。
  
• 功能：唤醒等待该对象监控权的一个/所有线程。
  
• 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）。
  

5.4 经典例题：生产者/消费者问题

题目描述：
生产者（Productor）将产品交给店员（Clerk），而消费者（Customer）从店员处取走产品，店员一次只能持有固定数量的产品（比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如 果店中有产品了再通知消费者来取走产品。

1. class Clerk{
3.     private int productCount = 0;
4.     //生产产品
5.     public synchronized void produceProduct() {
7.         if(productCount < 20){
8.             productCount++;
9.             System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
10.             
11.             notify();
13.         }else{
14.             //等待
15.             try {
16.                 wait();
17.             } catch (InterruptedException e) {
18.                 e.printStackTrace();
19.             }
20.         }
21.     }
22.     //消费产品
23.     public synchronized void consumeProduct() {
24.         if(productCount > 0){
25.             System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
26.             productCount--;
28.             notify();
29.         }else{
30.             //等待
31.             try {
32.                 wait();
33.             } catch (InterruptedException e) {
34.                 e.printStackTrace();
35.             }
36.         }
37.     }
38. }
40. class Producer extends Thread{//生产者
42.     private Clerk clerk;
44.     public Producer(Clerk clerk) {
45.         this.clerk = clerk;
46.     }
48.     @Override
49.     public void run() {
50.         System.out.println(getName() + ":开始生产产品.....");
52.         while(true){
53.             
54.             try {
55.                 Thread.sleep(10);
56.             } catch (InterruptedException e) {
57.                 e.printStackTrace();
58.             }
60.             clerk.produceProduct();
61.         }
62.     }
63. }
65. class Consumer extends Thread{//消费者
66.     private Clerk clerk;
68.     public Consumer(Clerk clerk) {
69.         this.clerk = clerk;
70.     }
72.     @Override
73.     public void run() {
74.         System.out.println(getName() + ":开始消费产品.....");
76.         while(true){
78.             try {
79.                 Thread.sleep(20);
80.             } catch (InterruptedException e) {
81.                 e.printStackTrace();
82.             }
84.             clerk.consumeProduct();
85.         }
86.     }
87. }
89. public class ProductTest {
91.     public static void main(String[] args) {
92.         Clerk clerk = new Clerk();
94.         Producer p1 = new Producer(clerk);
95.         p1.setName("生产者1");
97.         Consumer c1 = new Consumer(clerk);
98.         c1.setName("消费者1");
99.         Consumer c2 = new Consumer(clerk);
100.         c2.setName("消费者2");
102.         p1.start();
103.         c1.start();
104.         c2.start();
105.     }
106. }

复制代码

六、JDK5.0新增多线程创建方式

6.1 多线程的创建方式之三：实现Callable接口

• 创建一个实现 Callable 的实现类
  
• 实现call方法，将此线程需要执行的操作声明在call() 中。
  
• 创建 Callable 接口实现类的对象。
  
• 将此 Callable 接口实现类的对象作为传递到 FutureTask 构造器中，创建 FutureTask 的对象。
  
• 将 FutureTask 的对象作为参数传递到 Thread 类的构造器中，创建 Thread 对象，并调用 start() 。
  
• 获取 Callable 中 call 方法的返回值。（可选）
  

[code]//1.创建一个实现Callable的实现类class NumThread implements Callable{    //2.实现call方法，将此线程需要执行的操作声明在call()中    @Override    public Object call() throws Exception {        int sum = 0;        for (int i = 1; i