java线程通信的三种方式「建议收藏」

大家好，又见面了，我是你们的朋友全栈君。

1、传统的线程通信。

    在synchronized修饰的同步方法或者修饰的同步代码块中使用Object类提供的wait(),notify()和notifyAll()3个方法进行线程通信。

    关于这3个方法的解释：

    wait():导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。
    notify():唤醒在此同步监视器上等待的单个线程。
    notifyAll():唤醒在此同步监视器上等待的所有线程。

2、使用Condition控制线程通信。

    当程序使用Lock对象来保证同步，系统不存在隐式的同步监视器，只能用Condition类来控制线程通信。

     await():类似于隐式同步监视器上的wait()方法，导致当前线程等待，直到其他线程调用该Condition的signal()方法或signalAll()方法来唤醒该线程。
    signal():唤醒在此Lock对象上等待的单个线程。如果所有的线程都在该Lock对象上等待，则会选择唤醒其中一个线程。选择是任意性的。
    signalAll():唤醒在此Lock对象上等待的所有线程，只有当前线程放弃对该Lock对象的锁定后，才可以执行被唤醒的线程。

3、使用阻塞队列（BlockingQueue）控制线程通信（也实现了生产者消费者模式）

    BlockingQueue提供如下两个支持阻塞的方法：
    put(E e):尝试把E元素放入BlockingQueue中，如果该队列的元素已满，则阻塞该线程。
    take():尝试从BlockingQueue的头部取出元素，如果该队列的元素已空，则阻塞该线程。
    示例代码如下：
    
package edu.Utils;
 
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
 
/**
 * Created by hpp on 2017/7/4.
 */
 
class Producer extends Thread{

    private BlockingQueue<String> bq;
    public Producer(BlockingQueue<String> bq){

        this.bq = bq;
    }
    public void run(){

        String[] strArr = new String[]{

                “java”,
                “Struts”,
                “Spring”
        };
        for(int i = 0;i<99999;i++){

            System.out.println(getName() + “生产者准备生产集合元素！”);
            try{

                Thread.sleep(1000);
                bq.put(strArr[i%3]);
            }catch (Exception e){

                e.printStackTrace();
            }
            System.out.println(getName() + “生成完成：” + bq);
        }
    }
}
 
class Consumer extends Thread{

    private BlockingQueue<String> bq;
    public Consumer(BlockingQueue<String> bq){

        this.bq = bq;
    }
    public void run(){

        while(true){

            System.out.println(getName() + “消费者准备消费集合元素！”);
            try{

                Thread.sleep(1000);
                bq.take();
            }catch (Exception e){

                e.printStackTrace();
            }
            System.out.println(getName() + “消费完成：” + bq);
        }
    }
}
 
 
public class BlockingQueueTest {

 
    public static void main(String[] args){

        //创建一个容量为1的BlockingQueue
        BlockingQueue<String> bq = new ArrayBlockingQueue<String>(1);
        //启动3个生产者线程
        new Producer(bq).start();
        new Producer(bq).start();
        new Producer(bq).start();
        //启动1个消费者线程
        new Consumer(bq).start();
 
    }
 
}
运行结果：
Thread-0生产者准备生产集合元素！
Thread-1生产者准备生产集合元素！
Thread-2生产者准备生产集合元素！
Thread-3消费者准备消费集合元素！
Thread-0生成完成：[java]
Thread-0生产者准备生产集合元素！
Thread-1生成完成：[java]
Thread-1生产者准备生产集合元素！
Thread-3消费完成：[java]
Thread-3消费者准备消费集合元素！
Thread-2生成完成：[java]
Thread-2生产者准备生产集合元素！
Thread-3消费完成：[java]
Thread-3消费者准备消费集合元素！
Thread-0生成完成：[Struts]
Thread-0生产者准备生产集合元素！
Thread-3消费完成：[Struts]
Thread-3消费者准备消费集合元素！