Java多线程与并发应用-(9)-锁lock+条件阻塞conditon实现线程同步通信
一. lock可以代替synchronized关键字实现互斥功能。使用方法如下:
Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }
需要注意的是。
1.需要互斥的一个或多个方法要使用同一个互斥锁。
2.在被锁包含的代码块中,要使用finally块将锁释放。
二. Condition的await方法(注意不是wait方法)可以替换传统通信中的wait方法,对应的signal方法替换notify。
在传统通信的条件判断时,我们会用while而不是if做条件判断,是为了虚假唤醒。那么什么是虚假唤醒呢?
虚假唤醒即:如:我们要求AB方法按顺序执行,有5个线程执行A,5个线程执行B,如果某时刻全部A等待,当其中A1被唤醒,并执行完代码后,会调用notify方法,其本意是唤醒B模块执行线程,但是由于AB公用一个锁,所以可能将A唤醒,即唤醒了不该执行的代码,这就是虚假唤醒。
所以我们使用while条件,即使被唤醒了,我们还会做一次条件判读,这样被虚假唤醒的代码将再一次等待。
这就要求程序员来控制避免虚假唤醒带来的错误。而Lock和Condition的帮我们解决了这个问题。一个锁内部可以有多个Condition.那么同一个锁内可以多个condition实现模块
之间的切换,如上面的例子中A1再执行完之后,通过B对应的Condtion.signal只可以唤醒B对应的线程。我们可以看看Condition的API中的例子,阻塞队列的简单实现:
首先我们看看传统的通信技术实现简单的阻塞队列,有何弊端?
package com.lipeng; import java.util.Random; public class BoundedBuffer1 <T>{ private Object[] objs=new Object[100]; private int length; private int putIndex=0;//存指针 private int getIndex=0;//取指针 /** * 存放元素,从头到尾,再反复从头到尾 * @param t */ public synchronized void put(T t) { //如果已经放满了,就等待。 while(length==objs.length)//如果N个线程在这儿等待, 其中一个线程被唤醒后,执行下面的代码,35行this.notify本意是唤醒取线程取数据,但其实可能唤醒存线程。 { try { this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } objs[putIndex]=t; //在队尾插入元素 length++; //长度加1, putIndex++; if(putIndex==objs.length) { //注意不是放满了才从起始处放,而是存放指针到队尾了再从头开始。 putIndex=0; } this.notify(); } /** * 取元素,从头到尾取,在如此反复。 * @return */ public synchronized T get() { while(length==0) { try { this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } T t=(T) objs[getIndex]; length--; getIndex++; if(getIndex==objs.length) { getIndex=0; } this.notify(); return t; } public static void main(String[] args) { final BoundedBuffer1<Integer> bb=new BoundedBuffer1<Integer>(); Runnable getRun=new Runnable() { @Override public void run() { for(int i=0;i<10;i++) { synchronized (bb) { //这里加synchronized只是为了让读取数据和打印数据保持完整性,做演示用用 Integer data=bb.get(); System.out.println(Thread.currentThread().getName()+" 读取元素------ "+data); } } } }; Runnable putRun=new Runnable() { @Override public void run() { for(int i=0;i<10;i++) { synchronized (bb) {//这里加synchronized只是为了让存放数据和打印数据保持完整性,做演示用用 Integer data=new Random().nextInt(100); bb.put(data); System.out.println(Thread.currentThread().getName()+" 放入--------------------------- "+data); } } } }; System.out.println("***********************"); for(int i=0;i<10;i++) { new Thread(getRun).start(); new Thread(putRun).start(); } } }
我们再来看Condition是如何帮我们实现的?
package com.lipeng; import java.util.Random; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class BoundedBuffer2 <T>{ private Object[] objs=new Object[100]; private int length; private int putIndex=0;//存指针 private int getIndex=0;//取指针 private Lock lock=new ReentrantLock(); private Condition putCon=lock.newCondition();//存放条件 private Condition getCon=lock.newCondition();// 取条件 /** * 存放元素,从头到尾,再反复从头到尾 * @param t */ public void put(T t) { try { lock.lock(); //如果已经放满了,就等待。 while(length==objs.length)//如果N个线程在这儿等待, 其中一个线程被唤醒后,执行下面的代码,35行this.notify本意是唤醒取线程取数据,但其实可能唤醒存线程。 { try { putCon.await(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } objs[putIndex]=t; //在队尾插入元素 length++; //长度加1, putIndex++; if(putIndex==objs.length) { //注意不是放满了才从起始处放,而是存放指针到队尾了再从头开始。 putIndex=0; } getCon.signal(); System.out.println(Thread.currentThread().getName()+" 放入--------------------------- "+t); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); }finally{ lock.unlock(); } } /** * 取元素,从头到尾取,在如此反复。 * @return */ public T get() { try { lock.lock(); while(length==0) { try { getCon.await(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } T t=(T) objs[getIndex]; length--; getIndex++; if(getIndex==objs.length) { getIndex=0; } putCon.signal(); System.out.println(Thread.currentThread().getName()+" 读取元素------ "+t); return t; } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); return null; }finally{ lock.unlock(); } } public static void main(String[] args) { final BoundedBuffer2<Integer> bb=new BoundedBuffer2<Integer>(); Runnable getRun=new Runnable() { @Override public void run() { for(int i=0;i<10;i++) { bb.get(); } } }; Runnable putRun=new Runnable() { @Override public void run() { for(int i=0;i<10;i++) { Integer data=new Random().nextInt(100); bb.put(data); } } }; System.out.println("***********************"); for(int i=0;i<10;i++) { new Thread(getRun).start(); new Thread(putRun).start(); } } }
注意事项:
Lock(包括读写锁)+Condition看起来更加面向对象,也似乎提高了性能*(因为我没验证过,哈哈)也更加严谨,但我认为如果传统的通信方法够用,没必要使用它。
郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。