java线程通信

/**
 * 线程通信：
 * 通过控制做不同工作的线程来使多个线程协同工作
 * @author TokisakiYuu
 *
 */
public class HelloThread { 
    public static void main(String[] args) {
        Produce pro = new Produce();    //创建一个产品的样本
        Producer p = new Producer(pro); //传入样本，用以复制加工制造
        Seller s = new Seller(pro);     //传入产品，用以出售

        Thread pp = new Thread(p);      //通过Thread类来生成线程pp
        Thread ss = new Thread(s);      //通过Thread类来生成线程ss
        pp.start();     //启动线程
        ss.start(); 
    }

}
/**
 * 产品的原型设计
 * @author TokisakiYuu
 *
 */
class Produce{
    private int number;             //产品的属性  编号，这里只用一个举例，成员变量不必初始化，默认为0
    private boolean flag;           //布尔类型数据，用来标记此刻产品是否制作完成用以出售，默认为false。有产品true；没产品false
    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

/**
 * 制造商，接收产品样本，用以复制出产品，通过实现Runnable接口创建制造线程
 * @author TokisakiYuu
 *
 */
class Producer implements Runnable{
    public Produce pro;     //用来储存已经制造好的产品   空间“pro”，成员变量
    public int i;       //产品编号,成员变量，默认为0
    public void run() {         //线程一
        while(true){        //这个循环的作用是使制造商源源不断地制造产品
            synchronized(pro){
                if(pro.isFlag()){   //如果flag为真，即产品已经制造好了，无需再制造，将制造线程挂起
                    try {           //规定如果使用线程挂起操作wait()，必须进行异常捕获
                        pro.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } 
                }
                pro.setNumber(i);   //一个产品制造完成，设定编号
                System.out.println("制造出了第"+pro.getNumber()+"个产品");
                i = i + 1;      //i+1保证产品编号唯一性。     
                pro.setFlag(true);      //将此刻标记为已经制造完成      ↓这里再往下就将产品转移向零售商出售
                pro.notify();       //唤醒线程；通知零售商请开始出售产品！
            }
        }
    }

    public Producer(Produce pro){   //构造函数中接收传入的产品样本
        this.pro = pro;
    }
}

/**
 * 零售商，制造商每制作完成一个产品就卖出一个产品，通过实现Runnable接口创建零售线程
 * @author TokisakiYuu
 *
 */
class Seller implements Runnable{
    public Produce pro;     //用来存储要出售的产品
    public void run() {     //线程二
        while(true){        //这个循环的作用是让零售商源源不断地出售商品
            synchronized(pro){
                if(!pro.isFlag()){      //如果flag为假，即没有商品时，将出售线程挂起
                    try {
                        pro.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("已经出售第"+pro.getNumber()+"个产品");
                pro.setFlag(false);     //将此刻标记为缺货待制造
                pro.notify();       //唤醒线程；通知制造商请开始制造！这里缺货了  notify();唤醒同一锁控制的任意一个线程,这里只有两个线程,只有一个挂起的线程
            }
        }
    }

    public Seller(Produce pro){     //构造函数中接收要出售的产品
        this.pro = pro;
    }
}

//这个例子解释了线程通信的原理。例子中的产品pro其实始终是同一个对象，不断修改属性，修改一次，算是做成了一个产品
//多线程如果不加以控制，就相当于抢夺地盘的野兽。
/**
*这个例子的基本规则：在制造商线程制造商品时，零售商线程会被主动堵塞，不会出售商品，因为商品还没有被造出来，啥也不能出售
*  相反，在零售商线程出售商品过程中，制造商线程会被主动堵塞，不会制造商品，因为商品卖完之前不允许制造。
*/