线程协作(通信) 16

线程协作：

应用场景：1. 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。

2. 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库的产品

被消费者取走为止。

3. 如果仓库放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次

放入产品为止。

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

java提供了几个方法解决线程之间的通信问题：

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegaIMoitorStateException。

解决式：1. 并发协作模型“生产者/消费者”--->管程法

2. 生产者：负责生产数据的模块(可能是方法，对象，线程，进程)

3. 消费者：负责生产数据的模块(可能是方法，对象，线程，进程)

4. 缓冲区：消费者不能直接使用生产者的数据，它们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。

第二种：并发协作模型“生产者/消费者模式”-->信号灯法（trun , Flase）

同步机制：

package Runnable1;
/*
线程通信：使用两个线程打印1-100，线程1，线程2  交替打印
涉及三个方法：
wait()：一旦执行此方法，当前线程就进入阻塞状态并释放同步监视器（锁）
notify()：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的线程
notifyAll：一旦执行此方法，就会唤醒所有被wait的线程
说明：
只能是出现在同步代码块或者同步方法中，调用者必须是同步代码块或者同步方法中同步监视器。
否则，会出现异常
三个方法是定义在java.lang.Object类中
面试题：sleep和wait的异常
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：1. 两个方法声明的位置不同，Thread类中声明sleep()，Object列类中声明wait()
       2. 调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用同步代码块或同步方法中
       3. 关于是否是否同步监视器：如果两个方法都使用在同步代码块或者同步方法中，sleep()不会释放锁，wait()会释放锁
 */
class Number implements Runnable
{
  private int numeber=1;
    @Override
    public void run()
    {
        while (true)
        {
            synchronized (this) //快捷键ctrl+alt+t
            {
                notify();
                if (numeber<=100)
                {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName()+":"+numeber);
                    numeber++;


                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态 wait会释放锁
                        wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else {
                    break;
                }
            }
        }
    }
}


public class NumberCommunitionTest
{
    public static void main(String[] args)
    {
        Number number=new Number();
        Thread thread1=new Thread(number,"线程1");
        Thread thread2=new Thread(number,"线程2");
        thread1.start();
        thread2.start();
    }


}
----------------------------

package Runnable1;
/*
线程通信的应用：生产者消费者问题
分析：
是否是多线程问题？是，生产者线程，消费者线程
是否有共享数据？是店员（或产品）
如何来解决线程安全问题？同步机制：三种方法
是否涉及线程的通信？是
 */

class Clerk//
{
    private int productCount=0;

//生产产品
    //在这两个线程中一个时间内只有一个线程去跑
    public synchronized void ProduceProduct()
    {
        if (productCount<20)
        {
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            //只要生产了一个产品，就唤醒消费者
            notify();
        }else {//不生产
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
//消费产品
    public synchronized void consumeProduct()
    {
        if (productCount>0)
        {
            System.out.println(Thread.currentThread().getName()+"：开始消费第"+productCount+"个产品");
            productCount--;
            notify();//只要消费一个产品，就把生产者唤醒生产
        }else {//小于零
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
class Producer extends Thread//生产者
{
    private Clerk clerk;//共享数据

    public Producer(Clerk clerk)
    {
        this.clerk = clerk;
    }

    @Override
    public void run()
    {
        System.out.println(getName()+":开始生产产品........");//因为继承Thread.currentThread().可以省略
        while (true)
        {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.ProduceProduct();//调用clerk类的方法
        }
    }
}
class Consumers extends Thread//消费者
{
    private Clerk clerk;//共享数据

    public Consumers(Clerk clerk)
    {
        this.clerk = clerk;
    }

    @Override
    public void run()
    {
        System.out.println(getName()+":开始消费产品........");//因为继承Thread.currentThread().可以省略
        while (true)
        {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.consumeProduct();//调用clerk类的方法
        }
    }
}

public class ProductTest
{
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer p1=new Producer(clerk);
        p1.setName("生产者1");
        Consumers c1=new Consumers(clerk);
        c1.setName("消费者1");
        p1.start();
        c1.start();

    }

}

模拟生产者和消费者的案例:

创建馒头类(模拟共用的数据)

public
class
ManTou {

int id;

public ManTou(int id)

{

this.id=id;

}

public String toString()

{

return "ManTou[id="+this.id+"]";

}

创建篮子(模拟生产者和消费者的缓冲区)

public
class
Basket {

int index=0;

ManTou[] manTous=new ManTou[6];

//往篮子中放馒头

public synchronized void push(ManTou manTou)

{

//篮子满了需要等待

if(index==6)

try {

this.wait();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

this.notify(); //唤醒的是pop中的wait方法一旦放馒头了则说明篮子中有馒头了取馒头的方法不用等了

this.manTous[index]=manTou;

index++;

}

//从篮子中取馒头

public synchronized ManTou pop()

{

if(index==0)

try {

this.wait();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

this.notify(); //唤醒的是push中的wait方法一旦取馒头了则说明篮子有空位了放馒头的行为就不用等了

index--;

return this.manTous[index];

}

创建生产者(模拟产生或分配数据的对象)

public
class
Producer 
extends
Thread{

Basket basket=null;

public Producer(Basket basket)

{

this.basket=basket;

}

//执行任务

public void run()

{

for(int i=1;i<=20;i++)

{

ManTou manTou=new ManTou(i);

basket.push(manTou);

System.out.println("生产了"+manTou);

try {

this.sleep(200);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

创建消费者(处理数据)

public class Consumer extends Thread{

Basket basket=null;

public Consumer(Basket basket)

{

this.basket=basket;

}

//执行任务

public void run()

{

for(int i=1;i<=20;i++)

{

ManTou manTou= this.basket.pop();

System.out.println("消费了"+manTou);

try {

this.sleep(500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

publicclassTest { 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        Basket basket=new Basket();
         
        Producer producer=new Producer(basket);
         
        Consumer consumer=new Consumer(basket);
         
        producer.start();
         
        consumer.start();  
         
    }
 
}