Java线程——线程之间的通信

Java中多线程间的通信是怎么实现的？

线程通信的方式：

（1）共享变量

　　线程之间的通信可以通过发送信号，发送信号的一个简单方法就是再共享的对象里面设置信号值。线程A在一个同步块中设置boolean型的成员变量hasDataToProcess为true,线程B在同步块中读取hasDataProcess的值，如下：

package com.itheima.threadTest;

public class ThreadtTest {
    //共享的变量
    private boolean hasDataToProcess=false;
    //取值
    public boolean getHasDataToProcess() {
        return hasDataToProcess;
    }
    //设值
    public void setHasDataToProcess(boolean hasDataToProcess) {
        this.hasDataToProcess = hasDataToProcess;
    }
        
    public static void main(String[] args) {
        //创建一个对象
        final ThreadtTest my=new ThreadtTest();
        //线程1设置hasDataToProcess的值为true
        final Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                my.setHasDataToProcess(true);
                
            }
        });
        
        //线程1开始执行
        t1.start();
        
        //线程2取值
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //等待线程1执行完
                    t1.join();
                }catch (Exception e) {
                    e.printStackTrace();
                }
                
                my.getHasDataToProcess();
                
                System.out.println("t1改变后的值："+my.getHasDataToProcess());
            }
        });
        t2.start();
    }

（2）wait/notify机制

　　生成者消费者案例

package com.itheima.threadTest;

//资源类
class Resource{
    private String name;
    private int count=1;
    //标志位
    private boolean flag=false;  //当标识位为false时是生产者执行，为true是消费者执行
    
    //生成资源
    public synchronized void set(String name) {
        //根据标志位判断是否到自己执行了
        while(flag) {
            //标志位为true时，生产者等待,消费者执行
            try {
                //注意如果是同步代码块的话,就要使用锁住的那个对象来调用wait()
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        //如果到自己执行了
        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 (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        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;
    }
    //生成者生成资源
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            res.set("商品！");
        }
        
    }    
}

//消费者消费资源
class Consumer implements Runnable{
    private Resource resource;
    public Consumer(Resource resource) {
        this.resource=resource;
    }
    @Override
    public void run() {
        for(int i=0;i<5;i++) {
            resource.out();
        }
        
    }
}

public class ProducerConsumerDemo {
    public static void main(String[] args) {
        //参加一个公共资源
        Resource r=new Resource();
        
        //两个线程
        Producer producer=new Producer(r);
        Consumer consumer=new Consumer(r);
        Thread t1=new Thread(producer);
        Thread t2=new Thread(consumer);
        
        t1.start();
        t2.start();
    }
}

　　运行结果：