标签：多线程
1.多线程-线程间通信-多生产者多消费者问题
多生产者和多消费者。等待唤醒机制。
产生了两个问题：
1.出现了多次连续生产，未消费，或者一个商品被消费多次。
解决：必须要--------每一个被唤醒的线程判断一次标记，所以将if判断改为while判断。
2.出现了死锁。
本方唤醒了本方，导致了所有的线程都等待了。
解决方式就是：唤醒所有等待的线程。这样既唤醒了本方也唤醒对方。
虽然解决了多生产消费的问题，但是有些低效。
解决方法一： 唤醒所有等待的线程
class Resource{
private String name;//定义一个商品都有名字。
private int count = 1; //定义一个商品的编号。
private boolean flag = false;//定义用来判断是否有商品的标记。
public synchronized void set(String name){
while(flag)
try{wait();}catch(Exception e){}//t1,t2
this.name = name+"--"+count;//蛋糕1 蛋糕2 蛋糕3
count++;
System.out.println(Thread.currentThread().getName()+"---生产了，"+this.name);
//生产蛋糕1 生产蛋糕2 生产蛋糕3
flag = true; //将标记改为true。
notifyAll();//唤醒等待的线程。
}
public synchronized void get()//{
while(!flag)
try{wait();}catch(Exception e){}//t3.t4
System.out.println(Thread.currentThread().getName()+"-------消费了....."+this.name);//消费蛋糕1
flag = false;
notifyAll();
}
}
//定义生产者的任务。
class Producer implements Runnable{
private Resource r;
Producer(Resource r){
this.r = r;
}
public void run(){
while(true){
r.set("蛋糕");
}
}
}
//定义消费者的任务。
class Consumer implements Runnable{
private Resource r;
Consumer(Resource r){
this.r = r;
}
public void run(){
while(true){
r.get();
}
}
}
class ThreadDemo_Producer_Consumer2 {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
//创建两个生产者线程。
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
//创建两个消费者线程。
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}解决方法二：使用Lock锁对象和Condition监听对象
根据jdk1.5 版本的特性，创建一个锁对象。比同步的隐式锁操作要更加的面向对象。提供了显示的锁操作。
通过lock锁获取监视器方法对象。Condition 负责生产者的监视操作。
再创建一个监视器方法对象。负责消费者的监视操作。
解决了低效的问题
import java.util.concurrent.locks.*;
class Resource{
//定义一个商品都有名字。
private String name;
//定义一个商品的编号。
private int count = 1;
//定义用来判断是否有商品的标记。
private boolean flag = false;
//根据jdk1.5 版本的特性，创建一个锁对象。比同步的隐式锁操作要更加的面向对象。提供了显示的锁操作。
final Lock lock = new ReentrantLock();//互斥锁。
//通过lock锁获取监视器方法对象。Condition 负责生产者的监视操作。
final Condition producer = lock.newCondition();
//再创建一个监视器方法对象。负责消费者的监视操作。
final Condition consumer = lock.newCondition();
public void set(String name)//{
//通过锁对象进行显示的获取锁操作。
lock.lock();//获取锁，锁的开始位置，想从哪里锁就把锁放在什么地方
try{
while(flag)
try{producer.await();}catch(Exception e){}//t1,t2
this.name = name+"--"+count;
count++;
System.out.println(Thread.currentThread().getName()+"生产了，"+this.name);
//将标记改为true。
flag = true;
consumer.signal();//唤醒等待的线程。
}finally{
//释放锁。
lock.unlock();//定义在finally中，要求一定被释放。
}
}
public void get()//{
lock.lock();
try{
while(!flag)
try{consumer.await();}catch(Exception e){}//t3.t4
System.out.println(Thread.currentThread().getName()+"--消费了."+this.name); //消费蛋糕1
flag = false;
producer.signal();
}finally{
lock.unlock();
}
}
}
//定义生产者的任务。
class Producer implements Runnable{
private Resource r;
Producer(Resource r){
this.r = r;
}
public void run(){
while(true){
r.set("蛋糕");
}
}
}
//定义消费者的任务。
class Consumer implements Runnable{
private Resource r;
Consumer(Resource r){
this.r = r;
}
public void run(){
while(true){
r.get();
}
}
}
class ThreadDemo_Producer_Consumer3 {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
//创建两个生产者线程。
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
//创建两个消费者线程。
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}标签：多线程
原文地址：http://8477424.blog.51cto.com/8467424/1774102
