黑马程序员-----多线程之间的通信（生产者消费者）

                   --------android培训、java培训、期待与您交流！ ----------

线程间的相互作用：

　　线程间的相互作用：线程之间需要一些协调通信，来共同完成一件任务。

   因为wait和notify方法定义在Object类中，因此会被所有的类所继承。

   这些方法都是final的，即它们都是不能被重写的，不能通过子类覆写去改变它们的行为。

在前面学习了多线程编程中使用同步机制的重要性，并学会了如何实现同步的方法来正确的访问共享资源。这些线程之间的关系是平等的，批次之间并不存在依赖，他们各自竞争CPU的资源，互不相让，并且还无条件的阻止其他线程对共享资源的访问。然而，也有很多现实问题要求不仅仅要同步的访问同一共享资源，而且线程间还彼此牵制，通过相互通信来向前推进。那么，多个线程之间是如何进行通信的呢？

 

线程间的通信其实就是多个线程在操作同一个资源，但操作的动作不同。

class Res {    String name;    String sex;} class Input implements Runnable {    private Res r;     public Input(Res r) {        // TODO Auto-generated constructor stub        this.r = r;    }     public void run() {        int x = 0;        while (true) {            if (x == 0) {                r.name = "mike";                r.sex = "man";            } else {                r.name = "丽丽";                r.sex = "女女女";            }            x = ++x % 2;        }    }} class Output implements Runnable {    private Res r;     Output(Res r) {        this.r = r;    }     public void run() {        while (true) {            System.out.println(r.name + "----" + r.sex);        }    }} public class Communicate {    public static void main(String[] args) {        // TODO Auto-generated method stub        Res r = new Res();        Input in = new Input(r);        Output out = new Output(r);         Thread t1 = new Thread(in);        Thread t2 = new Thread(out);         t1.start();        t2.start();    }}

但是这样写的会出现名字与性别不相匹配的情况。

这就表明了出现了安全问题，当出现安全问题时就要想到需要同步。

class Res {    String name;    String sex;} class Input implements Runnable {    private Res r;    Object obj = new Object();     public Input(Res r) {        // TODO Auto-generated constructor stub        this.r = r;    }     public void run() {        int x = 0;        while (true) {            synchronized (obj) {                if (x == 0) {                    r.name = "mike";                    r.sex = "man";                } else {                    r.name = "丽丽";                    r.sex = "女女女";                }                x = ++x % 2;            }        }    }} class Output implements Runnable {    private Res r;    Object obj = new Object();    Output(Res r) {        this.r = r;    }     public void run() {        while (true) {            synchronized (obj)            {                System.out.println(r.name + "----" + r.sex);            }        }    }} public class Communicate {     public static void main(String[] args) {        // TODO Auto-generated method stub        Res r = new Res();        Input in = new Input(r);        Output out = new Output(r);         Thread t1 = new Thread(in);        Thread t2 = new Thread(out);         t1.start();        t2.start();     }}

但是这样做之后还是没有解决出现的问题。

那么还是要考虑那两个原则：

1.是否是两个及两个以上的线程？（满足）

2.是否是同一个锁？（？？）

用生产者和消费者的例子来观察同步的效果：

class ConsumeDemo{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(con);t1.start();t2.start();}}class Resource{private String name;private int count = 1;private boolean flag = false; public synchronized void set (String name) { if(flag) try{wait();}catch(Exception e){} this.name = name+"--"+count++; System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name); flag = true; this.notify(); } public synchronized void out() { if(!flag) try{wait();}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"..消费者.."+this.name); flag = false; this.notify();  }}class Producer implements Runnable{private Resource res;Producer(Resource res){this.res=res;}public void run(){while(true){res.set("+商品+");}}}class Consumer implements Runnable{private Resource res;Consumer(Resource res){this.res=res;}public void run(){while(true){res.out();}}}

运行结果：

Thread-0..生产者..+商品+--5857
Thread-1..消费者..+商品+--5857
Thread-0..生产者..+商品+--5858
Thread-1..消费者..+商品+--5858
Thread-0..生产者..+商品+--5859
Thread-1..消费者..+商品+--5859
Thread-0..生产者..+商品+--5860
Thread-1..消费者..+商品+--5860
Thread-0..生产者..+商品+--5861
Thread-1..消费者..+商品+--5861
Thread-0..生产者..+商品+--5862
Thread-1..消费者..+商品+--5862
Thread-0..生产者..+商品+--5863
Thread-1..消费者..+商品+--5863
Thread-0..生产者..+商品+--5864
Thread-1..消费者..+商品+--5864
Thread-0..生产者..+商品+--5865
Thread-1..消费者..+商品+--5865
Thread-0..生产者..+商品+--5866
Thread-1..消费者..+商品+--5866
Thread-0..生产者..+商品+--5867
Thread-1..消费者..+商品+--5867

同时开启两个生产着和两个消费者时：

class ConsumeDemo1{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();}}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){} this.name = name+"--"+count++; System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name); flag = true; this.notifyAll(); } public synchronized void out() { while(!flag) try{wait();}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"..消费者.."+this.name); flag = false; this.notifyAll();  }}class Producer implements Runnable{private Resource res;Producer(Resource res){this.res=res;}public void run(){while(true){res.set("+商品+");}}}class Consumer implements Runnable{private Resource res;Consumer(Resource res){this.res=res;}public void run(){while(true){res.out();}}}

运行结果：
Thread-1..生产者..+商品+--6175
Thread-3..消费者..+商品+--6175
Thread-0..生产者..+商品+--6176
Thread-2..消费者..+商品+--6176
Thread-1..生产者..+商品+--6177
Thread-3..消费者..+商品+--6177
Thread-0..生产者..+商品+--6178
Thread-2..消费者..+商品+--6178
Thread-1..生产者..+商品+--6179
Thread-3..消费者..+商品+--6179
Thread-0..生产者..+商品+--6180
Thread-2..消费者..+商品+--6180
Thread-1..生产者..+商品+--6181
Thread-3..消费者..+商品+--6181
Thread-0..生产者..+商品+--6182
Thread-2..消费者..+商品+--6182
Thread-1..生产者..+商品+--6183
Thread-3..消费者..+商品+--6183
Thread-0..生产者..+商品+--6184
Thread-2..消费者..+商品+--6184
Thread-1..生产者..+商品+--6185
Thread-3..消费者..+商品+--6185
Thread-0..生产者..+商品+--6186