java多线程-3-线程通信

待我称王封你为后i 2023-01-10 14:58 213阅读 0赞

### 文章目录 ###

*  线程通信的概念
 *  线程通信的实现方式
 *  线程通信练习

# 线程通信的概念 #

程序在运行时，涉及到对共享资源的读写操作，但由于当今操作系统是多进程多线程运行的，当多个线程共同访问一个共享资源时，无可避免的要对这些线程的访问顺序进行协调，以保证程序的正确运行。

# 线程通信的实现方式 #

Java中线程通信主要涉及到三个方法：

1.  wait() 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
2.  notify() 一旦执行此方法，就会唤醒一个被wait()的线程。若有多个线程被wait()，则唤醒优先级最高的那个
3.  notifyAll() 一旦执行此方法，就会唤醒所有被wait的线程

说明：

1 wait(), notify(), notifyAll()三个方法必须使用再同步代码块或同步方法中（不能使用在Lock锁实现的同步中）

synchronized(同步监视器) { 
    	// ……
    	wait();或notify()
    	// ……
    	notify();或wait();
    	// ……
    }
    
    访问修饰符 synchronized 返回值类型 方法名(参数列表) { 
    	// ……
    	wait();或notify()
    	// ……
    	notify();或wait();
    	// ……
    }

2 wait(), notify(), notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现 IllegalMonitorStateException异常。

// 正确用法一
    synchronized(this) { 
    	// ……
    	// 当使用this作为同步监视器时，调用wait或notify方法可以省略this
    	wait();或notify()//this.wait();或this.notify()
    	// ……
    	notify();或wait();//this.notify();或this.wait();
    	// ……
    }
    
    // 正确用法二
    Object obj = new Object();
    synchronized(obj) { 
    	// ……
    	obj.wait();或obj.notify()
    	// ……
    	obj.notify();或obj.wait();
    	// ……
    }
    
    // 错误用法一
    Object obj = new Object();
    synchronized(this) { 
    	// ……
    	obj.wait();或obj.notify()
    	// ……
    	obj.notify();或obj.wait();
    	// ……
    }
    
    // 错误用法二
    Object obj = new Object();
    synchronized(obj) { 
    	// ……
    	this.wait();或this.notify()
    	// ……
    	this.notify();或this.wait();
    	// ……
    }
    
    总结：充当同步监视器的对象必须和调用wait、notify方法的对象必须是同一个

3 wait(), notify(), notifyAll()三个方法是定义在java.lang.Object类中的方法。因为任何类的对象都可以充当同步监视器，也就意味着任何对象都能调用上述三个方法。

4 sleep()和wait()的异同：

*  相同点：一旦执行方法，都可以使当前线程进入阻塞状态。
 *  不同点：
    
    1.  两个方法声明的位置不同：sleep是Thread类中的方法，wait是Object类中的方法
    2.  调用的要求不同：sleep可以在任何需要的场景下调用。wait必须使用在同步代码块或同步方法中
    3.  关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep不会释放锁，wait会释放锁

**线程通信的例子：使用两个线程打印1-100，线程1、2交替打印。**

class PrintNumThread implements Runnable { 
        private int num = 1;
    
        @Override
        public void run() { 
            while (true) { 
                synchronized (this) { 
                    notify();
    
                    if (num <= 100) { 
                        try { 
                            Thread.sleep(100);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + " 打印数字 " + num++);
    
                        try { 
                            wait();
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    public class CommuTest { 
        public static void main(String[] args) { 
            PrintNumThread printNumThread = new PrintNumThread();
            Thread thread1 = new Thread(printNumThread);
            Thread thread2 = new Thread(printNumThread);
            thread1.setName("线程一");
            thread2.setName("线程二");
            thread1.start();
            thread2.start();
        }
    }

# 线程通信练习 #

线程通信的应用：生产者/消费者问题

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

分析:  
1．是否是多线程问题?是，生产者线程，消费者线程  
2．是否有共享数据?是，店员（或产品)  
3．如何解决线程的安全问题?同步机制,有三种方法：同步代码块、同步方法、Lock锁  
4．是否涉及线程的通信?是

class Clerk { 
        // 产品数量
        private int prodNum;
    
        public synchronized void consumeProd(){ 
            if (prodNum > 0) { 
                System.out.println(Thread.currentThread().getName() + " 消费第 " + prodNum + " 个产品");
                prodNum--;
                notify();
            } else { 
                try { 
                    wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
        public synchronized void produceProd(){ 
            if (prodNum < 20) { 
                prodNum++;
                System.out.println(Thread.currentThread().getName() + " 生产第 " + prodNum + " 个产品");
    
                notify();
            } else { 
                try { 
                    wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    }
    class ProducerThread extends Thread { 
        private Clerk clerk;
    
        public ProducerThread(Clerk clerk) { 
            this.clerk = clerk;
        }
    
        @Override
        public void run() { 
            System.out.println(Thread.currentThread().getName() + " 生产者开始生成产品……");
            while (true) { 
                clerk.produceProd();
            }
        }
    }
    class ConsumerThread extends Thread { 
        private Clerk clerk;
    
        public ConsumerThread(Clerk clerk) { 
            this.clerk = clerk;
        }
    
        @Override
        public void run() { 
            System.out.println(Thread.currentThread().getName() + " 开始消费产品");
            while (true) { 
                clerk.consumeProd();
            }
        }
    }
    public class ProducerConsumerTest { 
        public static void main(String[] args) { 
            Clerk clerk = new Clerk();
            ProducerThread producerThread = new ProducerThread(clerk);
            ConsumerThread consumerThread = new ConsumerThread(clerk);
            // ConsumerThread consumerThread1 = new ConsumerThread(product);
            producerThread.setName("生产者1");
            consumerThread.setName("消费者1");
            // consumerThread1.setName("消费者2");
            producerThread.start();
            consumerThread.start();
            // consumerThread1.start();
        }
    }