Java基础 浅谈线程补充 -------lock实现消费者和生产者以及精确唤醒

本文主要是介绍Java基础 浅谈线程补充 -------lock实现消费者和生产者以及精确唤醒，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

我们一直使用synchronized来聊经典模式消费者与生产者，在同步安全的时候我们除了讲解synchronized以外，还讲解了lock，对数据进行安全进行保护。那么问题就来了，是否可以通过lock实现消费者和生产者呢？

答案肯定是能，但是应该好奇是如何实现？

先看代码

class Data{private int num=0;Lock lock= new ReentrantLock();public void increment(){lock.lock();try {while (num!=0) {lock.wait();} }catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {lock.unlock();} num++;System.out.println(Thread.currentThread().getName()+"现在是number="+num);lock.notifyAll();}public void decrement(){lock.lock();try {while (num==0) {lock.wait();} }catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {lock.unlock();} num--;System.out.println(Thread.currentThread().getName()+"现在是number="+num);lock.notinofyAll();}} public class Test {public static void main(String[] args) {Data  data=new Data();new Thread(()->{for (int i=0;i<10;i++){data.decrement();}},"线程A").start();new Thread(()->{for(int i=0;i<10;i++) {data.increment();}} , "线程b").start() ;}
}
//输出
Exception in thread "线程A" Exception in thread "线程b" 线程b现在是number=1java.lang.IllegalMonitorStateExceptionat java.lang.Object.wait(Native Method)at java.lang.Object.wait(Unknown Source)at test.Data.decrement(Test.java:66)at test.Test.lambda$0(Test.java:22)at java.lang.Thread.run(Unknown Source)
java.lang.IllegalMonitorStateExceptionat java.lang.Object.notifyAll(Native Method)at test.Data.increment(Test.java:58)at test.Test.lambda$1(Test.java:31)at java.lang.Thread.run(Unknown Source)

只是简单的讲synchronized换程了lock和unlock，代码编辑器提示可以使用wait方法呢notinofyAll方法，所以第一反应，这个简单，可以直接依葫芦画瓢，然而输出的确实打脸了。

这个异常时一个非法异常，说明在编译没有异常，而是一个运行异常。还有就是为什么可以编译使用lock调用wait？

这个需要看jdk帮助文档：

可以看出这继承了object，所以可以使用object中的方法。

我们在看 ReentrantLock详细放的时候发现了这个，所以我们可以再看condition是如何实现等待和唤醒功能的。

完美不但对功能进行了一个简单解析，而且还给予了一个例子模板，可以从中找出三个方法await(),signal().signalAll()。

其中await等待，可以设置时间，signal唤醒一个等待的线程，signalAll唤醒所有等待的线程。

现在我们就可以通过lock实现消费者和生产者

public class Test {public static void main(String[] args) {Data  data=new Data();new Thread(()->{for (int i=0;i<10;i++){data.decrement();}},"线程A").start();new Thread(()->{for(int i=0;i<10;i++) {data.increment();}} , "线程b").start() ;}
}class Data{private int num=0;Lock lock= new ReentrantLock();Condition notFull  = lock.newCondition(); Condition notEmpty = lock.newCondition(); public void increment(){lock.lock();try {while (num!=0) {notEmpty.await();} num++;System.out.println(Thread.currentThread().getName()+"现在是number="+num);notFull.signalAll();}catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {lock.unlock();} }public void decrement(){lock.lock();try {while (num==0) {notFull.await();} num--;System.out.println(Thread.currentThread().getName()+"现在是number="+num);notEmpty.signalAll();}catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {lock.unlock();} }
} 
//输出
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0
线程b现在是number=1
线程A现在是number=0

可见输出可以完成用synchronized实现的消费者和生产者的例子。但是通过上面我们可以察觉一件事，那就是conditon，可以实现精确唤醒，比如increment中的condition等待的是notEmpty，而唤醒的时候使用的是notFull。

所以可以实现精确唤醒，具体看代码。

public class Test {public static void main(String[] args) {Step  step=new Step();new Thread(()->{for (int i = 0; i <10; i++) {step.step_first();}},"线程A").start();new Thread(()->{for (int i = 0; i <10; i++) {step.step_second();}},"线程b").start();new Thread(()->{for (int i = 0; i <10; i++) {step.step_thrid();}},"线程c").start();}}class Step{int num=1;Lock lock= new ReentrantLock();Condition step1  = lock.newCondition();Condition step2  = lock.newCondition();Condition step3  = lock.newCondition();public void step_first() {lock.lock();try {while(num!=1) {step1.await();}System.out.println(Thread.currentThread().getName());num=2;step2.signalAll();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {lock.unlock();}}public void step_second() {lock.lock();try {while(num!=2) {step2.await();}System.out.println(Thread.currentThread().getName());num=3;step3.signalAll();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {lock.unlock();}}public void step_thrid() {lock.lock();try {while(num!=3) {step3.await();}System.out.println(Thread.currentThread().getName());num=1;step1.signalAll();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {lock.unlock();}}
}
//输出
线程A
线程b
线程c
线程A
线程b
线程c
线程A
线程b
线程c
线程A
线程b
线程c
线程A
线程b
线程c
线程A
线程b
线程c
//后面一样

可以看出同各国condition可以实现精准唤醒。a,b,c相互交替，这个可以实现比如购物支付这样的功能。

这篇关于Java基础 浅谈线程补充 -------lock实现消费者和生产者以及精确唤醒的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---