线程之间的通信

主要是三个方法wait(); notify(); notifyAll()

wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。

wait方法释放锁, notify方法不释放锁

由于 wait()、notify/notifyAll() 在synchronized 代码块执行，说明当前线程一定是获取了锁的。

当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。

只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。

 

notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。notifyAll 会唤醒所有等待(对象的)线程，尽管哪一个线程将会第一个处理取决于操作系统的实现。

 

wait(), notify(), notifyAll() 必须是同一对象的多个线程之间的通信

举例

 

Target1

public class Target1 implements Runnable {

    private Demo3 demo;

    public Target1(Demo3 demo) {
        this.demo = demo;
    }

    @Override
    public void run() {
        demo.set();
    }

}

Target2

public class Target2 implements Runnable {

    private Demo3 demo;

    public Target2(Demo3 demo) {
        this.demo = demo;
    }

    @Override
    public void run() {
        demo.get();
    }

}

Demo3

public class Demo3 {

    private volatile int signal;

    public synchronized void set () {
        signal = 1;
        notifyAll(); // notify方法会随机叫醒一个处于wait状态的线程
        // notifyAll叫醒所有的处于wait线程，争夺到时间片的线程只有一个
        System.out.println("叫醒线程叫醒之后休眠开始...");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public synchronized int get () {
        System.out.println(Thread.currentThread().getName() + " 方法执行了...");
        if(signal != 1) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 方法执行完毕...");
        return signal;
    }

    public static void main(String[] args) {

        Demo3 d = new Demo3();
        Target1 t1 = new Target1(d);
        Target2 t2 = new Target2(d);

        new Thread(t2).start();
        new Thread(t2).start();
        new Thread(t2).start();
        new Thread(t2).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(t1).start();

    }
}

Console

hread-0 方法执行了...
Thread-2 方法执行了...
Thread-1 方法执行了...
Thread-3 方法执行了...
叫醒线程叫醒之后休眠开始...
Thread-3 方法执行完毕...
Thread-1 方法执行完毕...
Thread-2 方法执行完毕...
Thread-0 方法执行完毕...

生产者和消费者问题

Tmall

public class Tmall {
    private int count;

    public final int MAX_COUNT = 10;

    public synchronized void  push(){
        while (count >= MAX_COUNT){
            try {
                System.out.println(Thread.currentThread().getName()+"生产者库存数量库存满，生产者停止生产");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count++;
        System.out.println(Thread.currentThread().getName()+"生产者生产，当前库存为："+count);
        notifyAll();
    }



    public synchronized void take(){
        while (count<= 0){
            try {
                System.out.println(Thread.currentThread().getName()+"生产者库存数量库0，消费者等待");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        count--;
        System.out.println(Thread.currentThread().getName()+"生产者消费，当前库存为："+count);
        notifyAll();

    }

TakeTarget

public class TakeTarget implements  Runnable{

    private Tmall tmall;

    public TakeTarget(Tmall tmall){
        this.tmall = tmall;
    }


    @Override
    public void run() {

       while (true){
           tmall.take();
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

    }
}

PushTarget

public class PushTarget  implements Runnable{

    private Tmall tmall;

    public PushTarget(Tmall tmall){
        this.tmall = tmall;
    }


    @Override
    public void run() {
        while (true){
            tmall.push();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Main

    public static void main(String[] args) {

        Tmall tmall = new Tmall();

        PushTarget p = new PushTarget(tmall);

        TakeTarget t = new TakeTarget(tmall);

        new Thread(p).start();
        new Thread(p).start();
        new Thread(p).start();
        new Thread(p).start();


        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }

}

生产者线程多余消费者线程

Console

Thread-6生产者消费，当前库存为：9
Thread-0生产者生产，当前库存为：10
Thread-1生产者库存数量库存满，生产者停止生产..................

完