java线程详解（三）

java线程间通信

首先看一段代码

class Res
{
    String name;
    String sex;
}
class Input implements Runnable
{
    private Res r;

    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true){
            if(x==0){
                r.name = "mike";
                r.sex = "male";
            }
            else{
                r.name = "丽丽";
                r.sex = "女";
            }
            x = (x+1) % 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);
        }
    }
}

class Test
{
    public static void main(String[] args)
    {
        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();
    }

}

上面的代码主要是想实现一个人名和姓别的同时输入和输出，但是看结果却是错乱不堪的。这个原因是由于是线程安全问题。

下面就代码中加入同步代码块。关键要注意到Input和Output都要加入，并且synchronized的对象必须是同一个，这个选取Res r = new Res(); 由这条语句创建的对象r比较好。下面是修改后的代码及结果。

class Res
{
    String name;
    String sex;
}
class Input implements Runnable
{
    private Res r;

    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true){
            synchronized(r){
                if(x==0){
                    r.name = "mike";
                    r.sex = "male";
                }
                else{
                    r.name = "丽丽";
                    r.sex = "女";
                }
                x = (x+1) % 2;
            }
        }
    }
}

class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            synchronized(r){
                System.out.println(r.name + "---" + r.sex);
            }
        }
    }
}

class Test
{
    public static void main(String[] args)
    {
        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();
    }

}

同步代码块保证线程安全运行，但是为什么会出现一直显示丽丽或者是mike呢？这是由于假如输入线程输入之后输出线程一直在执行，那么输出的就是相同的内容了，这肯定不是我们想要的，我们想要的是输入一组数据就输出一组数据，那么如何修改呢？其实我们加一个标记用于判断，当没有输入的时候不能取数据而只能存数据，当已经存入一组数据的时候只能取数据而不能存数据。

class Res
{
    String name;
    String sex;
    boolean flag = false; //这里主要是一个标志，判断是否有输入，初始化为没有输入数据
}
class Input implements Runnable
{
    private Res r;

    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true){
            synchronized(r){   //同步代码块
                if(r.flag)     //如果本身有数据就等待，并且通知其他线程取走数据
                    try{r.wait();}catch(Exception e){}//在这里其实会阻塞，不会往下执行
                if(x==0){
                    r.name = "mike";
                    r.sex = "male";
                }
                else{
                    r.name = "丽丽";
                    r.sex = "女";
                }
                x = (x+1) % 2;
                //到这里说明该线程阻塞后其他线程已经取走数据，并且告知该线程，该线程又可存数据
                r.flag = true; //存数据之后标记为改变
                    try{r.notify();}catch(Exception e){}
            }
        }
    }
}

class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            synchronized(r){
                if(!r.flag)//这里如果没有数据就会等待，有数据就会去取数据
                    try{r.wait();}catch(Exception e){}
                System.out.println(r.name + "---" + r.sex);
                r.flag = false;//取了数据就换标记位
                    try{r.notify();}catch(Exception e){}//然后通知其他线程
            }
        }
    }
}

class Test
{
    public static void main(String[] args)
    {
        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();
    }

}

此时就会出现我们想要的结果，看看java api

可以看出wait(),notify(),等方法都用在同步中，因为要对持有锁的操作。所以这些方法要在同步中，只有同步才有锁！

为什么这些方法还会定义在Object中呢？

因为这些线程在操作同步线程时，都必须标识他们所操作线程的锁。只有同一个锁上被wait的线程才可以被同一个锁上的notify唤醒！也就是等待和唤醒必须是同一把锁，而锁可以是任意对象，而任意对象就定义在Object中！

现在对上面的代码进行优化。

class Res
{
    private String name;
    private String sex;
    private boolean flag = false; //这里主要是一个标志，判断是否有输入，初始化为没有输入数据
    public synchronized void set(String name,String sex){
        if(flag)     //如果本身有数据就等待，并且通知其他线程取走数据
            try{this.wait();}catch(Exception e){}//在这里其实会阻塞，不会往下执行
         this.name = name;
        this.sex = sex;
        flag = true; //存数据之后标记为改变
        try{this.notify();}catch(Exception e){}
    }
    public synchronized void out(){
        if(!flag)//这里如果没有数据就会等待，有数据就会去取数据
            try{this.wait();}catch(Exception e){}
        System.out.println(name + "---" + sex);
        flag = false;//取了数据就换标记位
         try{this.notify();}catch(Exception e){}//然后通知其他线程

    }
}
class Input implements Runnable
{
    private Res r;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true){
                if(x==0)
                    r.set("mike","male");
                else
                    r.set("丽丽","女");
                x = (x+1) % 2;
        }
    }
}
class Output implements Runnable
{
    private Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}
class Test
{
    public static void main(String[] args)
    {
        Res r = new Res();
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
    }

}

这次再来看一个生产消费者的例子。

class  ProducerConsumer
{
    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();
        }
    }
}

但是如果主函数的代码改为如下：

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);
        Thread t3 = new Thread(pro);
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

这里就是有两个生产线程，有两个消费线程，那么会出现问题

这就是当出现多个线程的时候的问题，需要使用while()循环不断判断标记，而不能使用if进行单次判断。也就是要把set和out里面的if语句全部变为while。这个时候会发生全部等待的现象，这里需要使用notifyAll进行全部唤醒。上面的程序只需要修改一下的几个地方

public synchronized void set(String name){
        while(flag)//(1)
            try{wait();}catch(Exception e){}
        this.name = name + "----" + count++;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
        flag = true;
        this.notifyAll();//(2)
    }
    public synchronized void out(){
        while(!flag)//(3)
            try{wait();}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"---消费者--------"+this.name);
        flag = false;
        this.notifyAll();//(4)
    }

记住:

当出现多个生产者线程和消费者线程时，必须使用while和notifyAll。

其实notifyAll唤醒了所有线程，这也不是我们的目的，我们只想唤醒对方线程，这该怎么做呢？

其实这需要看jdk1.5的新特性

仔细看这方面的资料，重新修改代码

import java.util.concurrent.locks.*;
class  ProducerConsumer
{
    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);
        Thread t3 = new Thread(pro);
        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;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public  void set(String name)throws InterruptedException{
        lock.lock();//这里显示加锁
        try {
            while(flag)
                condition.await();// == try{wait();}catch(Exception e){}
            this.name = name + "----" + count++;
            System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
            flag = true;
            condition.signalAll();// == this.notifyAll();如果使用signal则会出现等待现象
        } finally {
            lock.unlock();//这里显示解锁,必须执行，所以要放在这里
        }

    }
    public  void out()throws InterruptedException{
        lock.lock();//这里显示加锁
            try {
                while(!flag)
                    condition.await();// == try{wait();}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"---消费者--------"+this.name);
            flag = false;
            condition.signalAll();// == this.notifyAll();如果使用signal则会出现等待现象
        } finally {
            lock.unlock();//这里显示解锁,必须执行，所以要放在这里
        }
    }
}

class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res){
        this.res = res;
    }
    public void run(){
        while(true){
            try{res.set("+商品+");}catch(InterruptedException e){}
        }
    }
}

class Consumer implements Runnable
{
    private Resource res;
    Consumer(Resource res){
        this.res = res;
    }
    public void run(){
        while(true){
            try{res.out();}catch(InterruptedException e){}
        }
    }
}

上面程序只是对上上一个程序的替代，只不过是用到了比价现代的做法，但是本质还是没变，没有达到我们的目的，就是唤醒线程只唤醒对方线程，简而言之，生产者线程唤醒消费者线程，消费者线程唤醒生产者线程。虽然上面的程序没有实现这个目标，不过他具有比较多的特性，现在只需要简单修改便可达到目的。

class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
    private Lock lock = new ReentrantLock();
    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();

    public  void set(String name)throws InterruptedException{
        lock.lock();
        try {
            while(flag)
                condition_pro.await();// == try{wait();}catch(Exception e){}
            this.name = name + "----" + count++;
            System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
            flag = true;
            condition_con.signal();// == this.notifyAll();
        } finally {
            lock.unlock();
        }

    }
    public  void out()throws InterruptedException{
        lock.lock();
            try {
                while(!flag)
                    condition_con.await();// == try{wait();}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"---消费者--------"+this.name);
            flag = false;
            condition_pro.signal();// == this.notifyAll();
        } finally {
            lock.unlock();
        }
    }
}

这里主要看注释的几行代码。他们达到了目的：生产者线程唤醒消费者线程，消费者线程唤醒生产者线程。lock可以支持多个相关的 Condition 对象。