[19/04/11-星期四] 多线程_并发协作(生产者/消费者模式_2种解决方案(管程法和信号灯法))...

一、概念

多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。

Ø 什么是生产者?

      生产者指的是负责生产数据的模块(这里模块可能是：方法、对象、线程、进程)。

Ø 什么是消费者?

      消费者指的是负责处理数据的模块(这里模块可能是：方法、对象、线程、进程)。

Ø 什么是缓冲区?

      消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

      缓冲区是实现并发的核心，缓冲区的设置有3个好处：

Ø 实现线程的并发协作

      有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况;同样，消费者只需要从缓冲区拿数据处理即可，

也不需要管生产者生产的情况。 这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。

Ø 解耦了生产者和消费者

      生产者不需要和消费者直接打交道。

Ø 解决忙闲不均，提高效率

      生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费;消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据 。

线程并发协作总结：

      线程并发协作(也叫线程通信)，通常用于生产者/消费者模式，情景如下：

      1. 生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

      2. 对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后，又需要马上通知消费者消费。

      3. 对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费。

      4. 在生产者消费者问题中，仅有synchronized是不够的。

        · synchronized可阻止并发更新同一个共享资源，实现了同步;

        · synchronized不能用来实现不同线程之间的消息传递(通信)。

      5. 那线程是通过哪些方法来进行消息传递(通信)的呢?见如下总结：

      6. 以上方法均是java.lang.Object类的方法;

      都只能在同步方法或者同步代码块中使用，否则会抛出异常。

【管程法】

/**
 * 生产者消费者模型实现方式一：管程法
 * 4个角色： 生产者、消费者、缓冲区、生产的商品
 * 
 */
package cn.sxt.thread;

public class Test_0411_Produce {
    public static void main(String[] args) {
        SynContainer container=new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;

    public Productor(SynContainer container) {
        super();
        this.container = container;
    }
    //开始生产，生产50个
    public void run() {    
        for (int i = 0; i < 50; i++) {
            System.out.println("生产-->第"+i+"个包子");
            container.push(new Goods(i));
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        super();
        this.container = container;
    }
    //开始消费,消费100个会等待
    public void run() {    
        for (int i = 0; i < 100; i++) {
            System.out.println("消费---->第"+container.pop().id+"个包子");
        }

    }
}

//缓冲区
class SynContainer {
    Goods[] goods=new Goods[10];
    int count;

    //存
    public synchronized void push(Goods good1) {
        //缓冲区有空格就生产
        if (count==goods.length) {//此种情况下表示缓冲区满了，不能生产
            try {
                this.wait();//线程阻塞。生产通知消费，解除阻塞
            } catch (InterruptedException e) {//消费者通知生产，就解除
                
            }

            
        }
        
        goods[count]=good1;
        count++;
        this.notifyAll();//存在数据了，可以唤醒消费者消费了
    }
    
    //取
    public synchronized Goods pop() {

        //存在数据就拿，没有数据就等待
        if (count==0) {
            try {
                this.wait();//线程阻塞。生产通知消费，解除阻塞
            } catch (InterruptedException e) {
                
            }

        }

        count--;//从最后一个位置拿
        Goods good2=goods[count];
        this.notifyAll();//存在空间可唤醒对方生产了
        return good2;
    }
}
//商品
class Goods {
    int id;
    public Goods(int id) {
        super();
        this.id = id;
    }


}

 

【信号灯法】

/**
 * 生产者消费者模型实现方式二：信号灯法，借助标志位
 * 3要素：生产者(演员)、消费者(观众)、统一资源(电视剧)
 * 
 */
package cn.sxt.thread;

public class Test_0411_Signal {
    public static void main(String[] args) {
        Tv tv=new Tv();
        new Actor(tv).start();
        new Watcher(tv).start();        
    }
}


class Actor extends Thread{
    Tv tv;
    public Actor(Tv tv) {
        this.tv = tv;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {        
            if (i%2==0) {
                this.tv.play("知否知否应是绿肥红瘦");    
            }else {
                this.tv.play("香蜜沉沉烬如霜");
            }
            
        }
    }    
}


class Watcher extends Thread{
    Tv tv;
    public Watcher(Tv tv) {

        this.tv = tv;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            tv.watch();            
        }
    }        
}


class Tv{
    String vioce;
    boolean flag=true;//信号灯 真：表示演员表演，观众等待   假：观众观看，演员等待
    
    public synchronized void play(String v) {
        //演员等待
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }        
        }
        System.out.println("表演了:"+v);
        this.vioce=v;
        
        this.notifyAll();//唤醒 
        this.flag=!this.flag;//切换标志        
    }
    
    public synchronized void watch() {
        
        //观众等待
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }        
        }
        
        System.out.println("听到了:"+vioce);
        
        
        this.notifyAll();//唤醒
        this.flag=!this.flag;
        
    }
    
}

 

转载于:https://www.cnblogs.com/ID-qingxin/p/10679974.html