作者：淡淡笑嘻嘻 | 来源：互联网 | 2023-10-12 19:35
生产者和消费者是线程间进行通信的典型例子。实质是多线程共同操作一缓冲队列。Synchronizedwait()notify()实现，引出一个问题notify只负责唤
生产者和消费者是线程间进行通信的典型例子。实质是多线程共同操作一缓冲队列。
Synchronized &＃43; wait() notify() 实现&＃xff0c;引出一个问题 notify只负责唤醒所在对象的阻塞线程中的一个。被唤醒的线程进入可运行状态&＃xff0c;等待cpu时间片。
notifyAll负责唤醒所在对象的所有阻塞线程&＃xff0c;即所有因为对象阻塞的线程处于唤醒状态&＃xff0c;其中一个线程会获得锁&＃xff0c;当该线程退出后&＃xff0c;其他线程继续竞争。
如果用notify()只唤醒一个的话&＃xff0c;程序会执行不下去。这种情况不是死锁。是对象调用wait()方法后&＃xff0c;线程进入等待队列&＃xff0c;如果不唤醒&＃xff0c;不能自己唤醒。这里涉及到线程状态和wait(),notify()方法。
下面详细讲解下wait()和notify()方法。
wait()方法
和notify()一样都不是线程的方法&＃xff0c;在Object超类中就有该方法&＃xff0c;所有的实现类都继承自Object&＃xff0c;所以他们会重写该方法。所以代码中的this.wait()属于Buffer的实现类buffer&＃xff0c;它是多线程共享的类的方法。所以wait(),notify()的前提是获得对象的锁&＃xff0c;即在同步块内使用。 执行wait()后当前线程进入等待队列&＃xff0c;等待被唤醒&＃xff0c;唤醒方法可以是notify和notifyAll。唤醒后的线程与其他线程一起竞争该对象的锁&＃xff0c;如果获得锁&＃xff0c;从wait()方法后面直接运行&＃xff0c;这里会做代码实现&＃xff0c;清下下面代码的输出&＃xff0c;下面会做分析。执行wait()后当前线程进入等待队列&＃xff0c;等待被唤醒&＃xff0c;唤醒方法可以是notify和notifyAll。唤醒后的线程与其他线程一起竞争该对象的锁&＃xff0c;如果获得锁&＃xff0c;从wait()方法后面直接运行&＃xff0c;这里会做代码实现&＃xff0c;清下下面代码的输出&＃xff0c;下面会做分析。 notify()方法
只唤醒该对象等待队列中的一个线程&＃xff0c;随机唤醒。唤醒后执行notify()后面的代码&＃xff0c;出了同步块后即释放锁。锁池中的线程再竞争该锁。其他的等待队列中的线程还是在等待队列。这里与notifyAll有区别。 notifyAll()方法
唤醒所有等待队列中的线程&＃xff0c;进入锁池&＃xff0c;一起竞争该对象。当某一个线程获得锁&＃xff0c;运行完毕后释放锁或&＃xff0c;锁池中的锁还可以继续竞争。 这里有段深入理解写的很好&＃xff0c;我贴出来
当有线程调用了对象的notifyAll()方法(唤醒所有wait线程)或notify()方法(只随机唤醒一个wait线程)&＃xff0c;被唤醒的的线程便会进入该对象的锁池中&＃xff0c;锁池中的线程会去竞争该对象锁。
优先级高的线程竞争到对象锁的概率大&＃xff0c;假若某线程没有竞争到该对象锁&＃xff0c;它还会留在锁池中&＃xff0c;唯有线程再次调用wait&＃xff08;&＃xff09;方法&＃xff0c;它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行&＃xff0c;直到执行完了synchronized代码块&＃xff0c;它会释放掉该对象锁&＃xff0c;这时锁池中的线程会继续竞争该对象锁。
请看下面代码
public class Main { public static void main ( String[ ] arg) { Buffer buffer&＃61; new Buffer ( 5 ) ; Producer producer&＃61; new Producer ( buffer) ; Consumer consumer&＃61; new Consumer ( buffer) ; for ( int i&＃61; 0 ; i< 1 ; i&＃43;&＃43; ) { new Thread ( producer, "producer-" &＃43; i) . start ( ) ; } for ( int i&＃61; 0 ; i< 10 ; i&＃43;&＃43; ) { new Thread ( consumer, "consumer-" &＃43; i) . start ( ) ; } } } class Buffer { private int maxSize; private List< Date> ; Buffer ( int size) { maxSize&＃61; size; storage&＃61; new LinkedList < > ( ) ; } public synchronized void put ( ) { try { System. out. println ( "同步块开始运行处" ) ; while ( storage. size ( ) &＃61;&＃61; maxSize ) { System. out. println ( "看生产者从哪开始" ) ; System. out. print ( Thread. currentThread ( ) . getName ( ) &＃43; ": wait \n" ) ; ; this . wait ( ) ; } storage. add ( new Date ( ) ) ; System. out. print ( Thread. currentThread ( ) . getName ( ) &＃43; ": put:" &＃43; storage. size ( ) &＃43; "\n" ) ; Thread. sleep ( 1000 ) ; this . notify ( ) ; } catch ( InterruptedException e) { e. printStackTrace ( ) ; } } public synchronized void take ( ) { try { while ( storage. size ( ) &＃61;&＃61; 0 ) { System. out. print ( Thread. currentThread ( ) . getName ( ) &＃43; ": wait \n" ) ; this . wait ( ) ; } Date d&＃61; ( ( LinkedList< Date> ) storage) . poll ( ) ; System. out. print ( Thread. currentThread ( ) . getName ( ) &＃43; ": take:" &＃43; storage. size ( ) &＃43; "\n" ) ; Thread. sleep ( 1000 ) ; this . notify ( ) ; } catch ( InterruptedException e) { e. printStackTrace ( ) ; } } } class Producer implements Runnable { private Buffer buffer; Producer ( Buffer b) { buffer&＃61; b; } &＃64;Override public void run ( ) { while ( true ) { buffer. put ( ) ; } } } class Consumer implements Runnable { private Buffer buffer; Consumer ( Buffer b) { buffer&＃61; b; } &＃64;Override public void run ( ) { while ( true ) { buffer. take ( ) ; } } }
输出&＃xff1a;同步块开始运行处
这是典型的生产者和消费者代码&＃xff0c;这段代码贴的是这个博客的例子&＃xff0c;写的很好。
但是在执行该代码的时候&＃xff0c;我发现一个问题&＃xff0c;如果用notify()方法&＃xff0c;我有一个线程运行生产者代码&＃xff0c;10个线程运行消费者代码。缓冲区最多是5个产品。
同步块开始运行处
consumer-8: take:4
生产者线程获得锁&＃xff0c;开始加工产品&＃xff0c;没加工一个产品唤醒一个等待队列中的线程。注意下面的此处&＃xff0c;是从producer-0: put:1输出的&＃xff0c;没有输出同步块开始运行处。这证明了被唤醒的线程获得锁后是从wait()返回处开始运行的。
此时连续加工5个产品&＃xff0c;已经有5个线程被唤醒了。
消费者线程8获得锁&＃xff0c;执行消费任务&＃xff0c; 没消费一次&＃xff0c;运行一次notify方法&＃xff0c;唤醒一个锁。从后面的运行结果来看&＃xff0c;没有唤醒生产者线程。被唤醒的消费者线程竞争锁&＃xff0c;因为没有产品&＃xff0c;执行wait()方法&＃xff0c;然后所有的线程都在等待队列了。
这里比较凑巧&＃xff0c;我选了生产5个产品&＃xff0c;有10个消费者线程。如果有10个产品&＃xff0c;10个消费者线程&＃xff0c;生产产品能唤醒10个线程&＃xff0c;消耗产品能唤醒10个线程&＃xff0c;就不会出现上面的问题了&＃xff0c;因为肯定能把所有的线程都唤醒。
以上用notifyAll不用考虑生产者唤醒生产者&＃xff0c;消费者唤醒消费者的问题了。
京公网安备 11010802041100号