Java-线程通信

1. wait()

   一旦执行此方式，当前线程就进入阻塞状态，并释放线程锁。

2. notify()

   一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait,就唤醒优先级高的那个线程。

3. notifyAll()

   一旦执行此方法，就会唤醒所有被wait的线程。

   说明：

   • 上述三个方法只能出现在带锁的同步代码块或者方法块中。
   • 上述三个方法的调用者必须是同步代码块或者同步方法中的监视器。
   • 上述三个方法时定义在java.Object.lang包中的。

package com.lmw.thread2;



public class CommunicationTest2 {
    public static void main(String[] args) {
        Number2 n1 = new Number2();
        Thread t1 = new Thread(n1);
        t1.start();
        Thread t2 = new Thread(n1);
        t2.start();

    }
}


class Number2 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();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else {
                    break;
                }
            }

        }
    }
}

package com.lmw.thread2;



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

        Thread t1 = new Thread(p1);
        t1.setName("生产者");
        t1.start();

        Thread t2 = new Thread(c1);
        t2.setName("消费者");
        t2.start();

    }
}

class Clerk {
    public int number = 0;

    
    public boolean isProduct() {
        return number < 20;
    }

    
    public boolean isCust() {
        return number >= 1;
    }


    public synchronized void produceProduct() {
            if(isProduct()) {
                number ++;
                // 阻塞线程，持锁
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":生产 1个 产品,店员还有产品数量：" + number);
                // 唤醒消费线程
                notify();

            }else {
                // 阻塞线程，先其他线程执行
                try {
                    System.out.println("停止生产，店员手里产品数量达到:" + number);
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

    }

    public synchronized void consumerProduct() {
            if(isCust()) {
                number -- ;
                System.out.println(Thread.currentThread().getName() + ":消费 1个 产品,店员还有产品数量：" + number);
                // 唤醒生产线程
                notify();
            }else {

                try {
                    System.out.println("停止消费，店员手里产品数量为:" + number);
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

    }



}

class Productor implements Runnable {
    private Clerk clerk;

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

    @Override
    public void run() {
        while (true) {
            clerk.produceProduct();
        }

    }

}


class Customer implements Runnable {
    private Clerk clerk;

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

    @Override
    public void run() {
        while (true) {
            clerk.consumerProduct();
        }
    }
}

• sleep() 和 wait()的异同？
  • 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
  • 不同点：
    • 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
    • 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
    • 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。