线程同步--生产者消费者

原创 2015年07月07日 20:53:30

当同时有很多生产者和消费者往仓库里面增加产品减少产品,会产生以下两个问题:

1当生产者和消费者同时改变仓库对象的属性,最后打印出的结果不能反映仓库的情况

2当生产者过多或者消费者过多会使仓库满或者空,如果不把线程从运行态变成就阻塞态的话,会出现异常

解决方式:

问题1:在改变对象的方法加入同步锁,该方法运行时将对象或者对象的属性锁定,当方法运行完才可以访问该对象或者对象的属性

问题2:在方法头部加入判断条件,如果仓库满或空,则调用wait()方法。线程将交出对象锁,并进入阻塞状态。而当其他的生产或者消费方法执行过后,仓库不满或不空则调用notifyall()方法,将线程池中阻塞的方法变成就绪态。

下面我利用三种方法实现了生产者和消费者

方法一:

线程同步synchronized+线程通信wait(),notify()

import java.util.LinkedList;
import java.util.List;

/**
 * Created by marsares on 15/7/7.
 */
public class ProducerAndCustomer1 {
    public static void main(String[]args){
        Storage storage=new Storage();
        Producer1 p1=new Producer1(storage,"p1",10);
        Producer1 p2=new Producer1(storage,"p2",10);
        Producer1 p3=new Producer1(storage,"p3",10);
        Producer1 p4=new Producer1(storage,"p4",10);
        Producer1 p5=new Producer1(storage,"p5",10);
        Customer1 c1=new Customer1(storage,"c1",10);
        Customer1 c2=new Customer1(storage,"c2",10);
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        c1.start();
        c2.start();
    }
}
class Storage{
    private static final int max=30;
    private int size=0;
    private int count=0;
    LinkedList<String>storage=new LinkedList<String>();
    public synchronized void add(int num){
        notifyAll();
        while(size+num>max){
            System.out.println(Thread.currentThread().getName()+"wait for customer");
            try{
                wait();
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
        for(int i=0;i<num;i++){
            storage.add("apple" + count);
            count++;
            size++;
        }
        System.out.println(Thread.currentThread().getName()+" add "+num+" products,"+" size="+size);
    }
    public synchronized void delete(int num){
        notifyAll();
        while(size-num<0){
            System.out.println(Thread.currentThread().getName()+"wait for producer");
            try{
                wait();
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
        for(int i=0;i<num;i++){
            storage.remove();
            size--;
        }
        System.out.println(Thread.currentThread().getName()+" delete "+num+" products,"+" size="+size);
    }
}
class Producer1 extends Thread{
    Storage storage;
    String name;
    int num;
    public Producer1(Storage storage,String name,int num){
        this.storage=storage;
        this.name=name;
        this.num=num;
    }
    public void produce(int num){
        storage.add(num);
    }
    public void run(){
        produce(num);
    }
}
class Customer1 extends Thread{
    Storage storage;
    String name;
    int num;
    public Customer1(Storage storage,String name,int num){
        this.storage=storage;
        this.name=name;
        this.num=num;
    }
    public void consume(int num){
        storage.delete(num);
    }
    public void run(){
        consume(num);
    }
}

方法二:

使用lock

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by marsares on 15/7/7.
 */
public class ProducerAndCustomer2 {
    public static void main(String[]args){
        Storage2 storage=new Storage2();
        Producer2 p1=new Producer2(storage,"p1",10);
        Producer2 p2=new Producer2(storage,"p2",10);
        Producer2 p3=new Producer2(storage,"p3",10);
        Producer2 p4=new Producer2(storage,"p4",10);
        Producer2 p5=new Producer2(storage,"p5",10);
        Customer2 c1=new Customer2(storage,"c1",10);
        Customer2 c2=new Customer2(storage,"c2",10);
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        c1.start();
        c2.start();
    }
}
class Storage2{
    private static final int max=30;
    private int size=0;
    private int count=0;
    LinkedList<String> storage=new LinkedList<String>();
    private final Lock lock=new ReentrantLock();
    private final Condition full=lock.newCondition();
    private final Condition empty=lock.newCondition();
    public void add(int num){
        lock.lock();
        while(size+num>max){
            System.out.println(Thread.currentThread().getName()+"wait for customer");
            try{
                full.await();
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
        for(int i=0;i<num;i++){
            storage.add("apple" + count);
            count++;
            size++;
        }
        System.out.println(Thread.currentThread().getName()+" add "+num+" products,"+" size="+size);
        empty.signalAll();
        lock.unlock();
    }
    public void delete(int num){
        lock.lock();
        while(size-num<0){
            System.out.println(Thread.currentThread().getName()+"wait for producer");
            try{
                wait();
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
        for(int i=0;i<num;i++){
            storage.remove();
            size--;
        }
        System.out.println(Thread.currentThread().getName()+" delete "+num+" products,"+" size="+size);
        full.signalAll();
        lock.unlock();
    }
}
class Producer2 extends Thread{
    Storage2 storage;
    String name;
    int num;
    public Producer2(Storage2 storage,String name,int num){
        this.storage=storage;
        this.name=name;
        this.num=num;
    }
    public void produce(int num){
        storage.add(num);
    }
    public void run(){
        produce(num);
    }
}
class Customer2 extends Thread{
    Storage2 storage;
    String name;
    int num;
    public Customer2(Storage2 storage,String name,int num){
        this.storage=storage;
        this.name=name;
        this.num=num;
    }
    public void consume(int num){
        storage.delete(num);
    }
    public void run(){
        consume(num);
    }
}
方法三:

使用LinkedBlockingQueue

import java.util.concurrent.LinkedBlockingQueue;

/**
 * Created by marsares on 15/7/7.
 */
public class ProducerAndCustomer3 {
    public static void main(String[]args){
        Storage3 storage=new Storage3();
        Producer3 p1=new Producer3(storage,"p1",10);
        Producer3 p2=new Producer3(storage,"p2",10);
        Producer3 p3=new Producer3(storage,"p3",10);
        Producer3 p4=new Producer3(storage,"p4",10);
        Producer3 p5=new Producer3(storage,"p5",10);
        Customer3 c1=new Customer3(storage,"c1",10);
        Customer3 c2=new Customer3(storage,"c2",10);
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        c1.start();
        c2.start();
    }
}
class Storage3{
    private static final int max=30;
    private int size=0;
    private int count=0;
    LinkedBlockingQueue<String> storage=new LinkedBlockingQueue<String>(max);
    public void add(int num){
        for(int i=0;i<num;i++){
            try{
                storage.put("apple" + count);
                count++;
                size++;
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
        System.out.println(Thread.currentThread().getName() + " add " + num + " products," + " size=" + size);
    }
    public void delete(int num){
        for(int i=0;i<num;i++){
            try{
                storage.take();
                size--;
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
        System.out.println(Thread.currentThread().getName() + " delete " + num + " products," + " size=" + size);
    }
}
class Producer3 extends Thread{
    Storage3 storage;
    String name;
    int num;
    public Producer3(Storage3 storage,String name,int num){
        this.storage=storage;
        this.name=name;
        this.num=num;
    }
    public void produce(int num){
        storage.add(num);
    }
    public void run(){
        produce(num);
    }
}
class Customer3 extends Thread{
    Storage3 storage;
    String name;
    int num;
    public Customer3(Storage3 storage,String name,int num){
        this.storage=storage;
        this.name=name;
        this.num=num;
    }
    public void consume(int num){
        storage.delete(num);
    }
    public void run(){
        consume(num);
    }
}


使用Win32 API实现生产者消费者线程同步

#include #include #define QUEUE_LENGTH 10 //缓冲区长度 HANDLE full_sem; //满信号量 HANDLE empty_sem; //空...
  • giantpoplar
  • giantpoplar
  • 2015年07月23日 16:47
  • 1603

线程同步-生产者消费者问题

在进行多线程编程时,难免还要碰到两个问题,那就线程间的互斥与同步: 线程同步是指线程之间所具有的一种制约关系,一个线程的执行依赖另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才...
  • big_bit
  • big_bit
  • 2016年05月09日 21:26
  • 7315

从生产者消费者窥探线程同步(上)

欢迎转载,转载请注明出处。尊重他人的一丢丢努力,谢谢啦! 阅读本篇之后,如果你觉得说得还有点道理,那不妨先戳一下从生产者消费者窥探线程同步(下) ,两篇一起嚼才更好呢。最近复习了下生产者消费者模式...
  • luochoudan
  • luochoudan
  • 2016年06月16日 18:29
  • 3184

Linux多线程消费者和生产者模型实例(互斥锁和条件变量使用)

条件变量与互斥锁使用,生产者和消费者模型
  • Linux_ever
  • Linux_ever
  • 2015年12月08日 11:41
  • 2734

Linux平台下线程同步,实现“生产者消费者问题”

(1)线程同步,实现“生产者消费者问题” 要求:缓冲区大小为20,生产者每次放一个产品,消费者每次取走一个产品;生产者和消费者至少2个。 (2)代码如下: #include #include ...
  • u010870518
  • u010870518
  • 2014年11月30日 13:08
  • 2570

线程同步——生产者消费者

Java实现生产者消费者的方式
  • fumier
  • fumier
  • 2015年04月10日 10:05
  • 430

Qt之线程同步(生产者消费者模式 - QSemaphore)

简述生产者将数据写入缓冲区,直到它到达缓冲区的末尾,这时,它从开始位置重新启动,覆盖现有数据。消费者线程读取数据并将其写入标准错误。Semaphores 使得比 mutexes 有一个更高级的并发性成...
  • u011012932
  • u011012932
  • 2016年09月23日 16:33
  • 4331

谈谈我对Linux下“生产者/消费者线程模型”的理解

生产者消费者线程模型常常用于网络编程,即一个线程监听事件发生(生产者,例如产生“收到数据”事件),其他线程来处理事件(消费者,例如处理收到的数据)比较笨的办法是: 消费者线程不停地loop等待数据,...
  • xocoder
  • xocoder
  • 2016年03月23日 15:39
  • 1575

C#多线程--生产者和消费者

http://blog.sina.com.cn/s/blog_4ca200e20100oi10.html (1)       Consumer表示消费类,其中定义了一个Array...
  • zunguitiancheng
  • zunguitiancheng
  • 2015年02月28日 16:41
  • 1626

【线程同步】java实现生产者消费者问题与线程中的wait与notify总结

JAVA解决线程模型有三种方式,只讲一种:   1、wait()和notify()
  • robert_lizhiqiang
  • robert_lizhiqiang
  • 2014年09月15日 14:41
  • 1136
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:线程同步--生产者消费者
举报原因:
原因补充:

(最多只允许输入30个字)