线程的通信

线程的通信

1. wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
2. notify():一旦执行此方法，就会唤醒wait()的一个线程，如果多个线程被wait()，就唤醒优先级高的。
3. notifyAll():一旦执行此方法，就会唤醒所以被wait()的线程。
4. wait()，notify()，notifyAll()只能在同步代码块和同步方法中
5. wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则就会报IllegalMonitorStateException异常.(易出错)
6. wait()，notify()，notifyAll()三个方法是Java.lang.Object中的。

代码

package com.yicurtain.THREAD;
//实现1-100的线程的通信,线程一和线程二交替打印。
class Number implements Runnable{
    private int number=1;

    @Override
    public void run() {

        synchronized (this) {

            while (true) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                notify();//该方法只能在同步方法或同步块内部调用,锁定哪个对象就用哪个对象来执行 notify(),
                        // 否则就会报IllegalMonitorStateException异常.
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;



                } else {
                    break;
                }
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
            }
        }
    }
}
public class CommunicationTest {
    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();


    }

}

生产者和消费者问题

package com.yicurtain.THREAD;
//      生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
//        取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
//        生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
//        知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
//        果店中有产品了再通知消费者来取走产品。


class Clerk{
    private  int number=0;
        //生产产品
    public  synchronized void product(){
        notify();
        if (number<20){
            number++;
            System.out.println(Thread.currentThread().getName()+":生产第"+number+"个产品");
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    };

    public  synchronized void consume() {
        notify();
        if (number>0){
            System.out.println(Thread.currentThread().getName()+":消费第"+number+"个产品");
            number--;
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class productor implements Runnable{
    private  Clerk clerk;

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



    @Override
    public  void run() {
        System.out.println(Thread.currentThread().getName()+"生产者开始生产产品");
        while (true){

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

            clerk.product();
        }
    }
}


class consumer implements Runnable{
    private  Clerk clerk;

    public consumer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public  void run() {
        System.out.println(Thread.currentThread().getName()+"消费者开始消费产品");
        while (true){

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

            clerk.consume();
        }
    }
}

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        productor productor = new productor(clerk);
        consumer consumer = new consumer(clerk);

        Thread p1 = new Thread(productor);
        Thread c1 = new Thread(consumer);

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

        p1.start();
        c1.start();


    }
}