一.本例实现 :一对一交替打印,
一.生产者逻辑 :每次只允许一个生产者来进行生产操作(生产者之间互斥访问仓库),必须等消费者取走数据之后,才能进行下一次的生产
二.消费者逻辑 :每次只允许一个消费者来进行生产操作(消费者之间互斥访问仓库),必须等生产者生产数据之后,才能进行下一次的消费。
二.仓库类:
package lock.produce.comsumer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class MyService {
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private boolean hasValue = false;
/**
* 生产数据
*/
public void set(){
try {
lock.lock(); //获取监视器对象,即获取锁
while(hasValue){
condition.await();
}
System.out.println("打印*");
hasValue = true; //只允许当前一个线程进来,且是消费线程进来
condition.signal();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
lock.unlock();
}
}
/**
* 消费数据
*/
public void get(){
try {
lock.lock(); //获取监视器对象,即获取锁
while(!hasValue){
condition.await();
}
System.out.println("打印&");
hasValue = false; //只允许当前一个线程进来,且是生产者线程进来
condition.signal();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
lock.unlock();
}
}
}
package lock.produce.comsumer;
/**
* 生产者线程
* @author Administrator
*
*/
public class MyThreadA extends Thread{
private MyService myService;
public MyThreadA(MyService myService){
this.myService = myService;
}
public void run(){
for(int i=0;i<5;i++){
myService.set();
}
}
}
package lock.produce.comsumer;
public class MyThreadB extends Thread{
/**
* 消费者线程
*/
private MyService myService;
public MyThreadB(MyService myService){
this.myService = myService;
}
public void run(){
for(int i=0;i<5;i++){
myService.get();
}
}
}
五。测试类:
package lock.produce.comsumer;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyService myService = new MyService();
MyThreadA a = new MyThreadA(myService);
a.start();
MyThreadB b = new MyThreadB(myService);
b.start();
}
}
六。测试结果:
打印*
打印&
打印*
打印&
打印*
打印&
打印*
打印&
打印*
打印&