java 多线程并发通信 java多线程之间通信

多线程三

• 1、线程的通信

• 1.1线程通信的例题
• 1.2涉及到的三个方法
• 1.3sleep()和wait()的异同
• 1.4 经典例题：生产者/消费者问题

1、线程的通信

• 线程通信就是线程间相互发送数据，线程通信经常通过共享一个数据的方式实现
• 线程间会根据共享的数据的情况决定字节该怎么做，以及通知其他线程怎么做

1.1线程通信的例题

题目：线程通信的例题：使用两个线程打印1-100：线程1，线程2，交替打印

代码：

public class ThreadComuicaTest {


    public static void main(String[] args) {
        Number number = new Number();

        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();


    }
}



class Number implements  Runnable{

    private int number = 1;

    @Override
    public void run() {
        while (true){
            synchronized(this){

                //唤醒优先级较高的阻塞的线程
                notify();


                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName()+":打印了 "+number);
                    number++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else break;
            }

        }
    }
}

1.2涉及到的三个方法

wait():一旦执行，就会阻塞当前进程，并同步释放监视器
notify()：一旦执行，就会唤醒被wait()的一个线程。如果有多个线程被wait()，就唤醒优先级高的阻塞线程
notifyAll()：一旦执行就唤醒当前所有被wait的线程();

说明：
wait().notify(),notifyAll()三个方法必须在同步代码块或同步方法中使用
wait().notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器（锁对象）
否则会出现IllegalMonitorStateException异常
wait().notify(),notifyAll()三个方法都定义在java.lang.Object类中以便于可以调用任何方法的对象作为监视器

1.3sleep()和wait()的异同

相同点

一旦执行，都可以让当前线程进入阻塞状态

不同点

① 方法声明位置不同：Thread(）类中声明sleep()，Object(）类中声明wait()
②调用的范围不同，sleep()方法可以在任何地方调用，wait()只能在同步代码块或同步方法中调用
③如果两种方法都使用在同步代码块或方法中，slee()不会释放锁，wait()会释放锁。

1.4 经典例题：生产者/消费者问题

问题描述

生产者（Productor）将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品，店员一次只能取走固定数量的产品(比如：20)，如果生产者试图生产更多的产品，店员会叫生产者停一下（wait），如果店中又空位放产品了在通知生产者继续生产（notify());如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走商品

问题分析

• 生产者比消费者快，消费者会漏掉一些数据没有取到
• 消费者比生产者快，消费者会取相同的数据

public class ProductTest {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Productor p1 = new Productor(clerk);
        Productor p2 = new Productor(clerk);
        Customer c1 = new Customer(clerk);
        Customer c2 = new Customer(clerk);


        p1.setName("生产者1");
        c1.setName("消费者1");
        p2.setName("生产者2");
        c2.setName("消费者2");

        p1.start();
        p2.start();
        c1.start();
        c2.start();

    }


}


//生产者线程
class Productor extends Thread {

    private final Clerk clerk;

    public Productor(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        //验证当前线程是否run(成功)
        System.out.println(Thread.currentThread().getName()+"正在生产品");

        while (true){

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            this.clerk.production();

        }

    }
}

//消费者线程
class Customer extends  Thread{

    private Clerk clerk;

    public Customer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        //验证当前线程是否run(成功)
        System.out.println(Thread.currentThread().getName()+"正在购买");
        while (true) {
            synchronized (this) {
                while (true) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    this.clerk.sell();

                }
            }

        }

    }
}

//店员线程
class Clerk {

    private int NumOfPro = 0;


    public int getNumOfPro(){
        return NumOfPro;
    };

    //生产产品
    public synchronized void  production(){

        if (NumOfPro < 20) {
            NumOfPro++;
            System.out.println(Thread.currentThread().getName()+"开始生产第"+NumOfPro+"个产品");
            if (NumOfPro == 1) {
                notify();
            }
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }


    };

    //出售产品
    public synchronized void sell(){
        if (NumOfPro > 0) {
            System.out.println(Thread.currentThread().getName()+"正在消费第"+NumOfPro+"个产品");
            NumOfPro--;

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}