[PHP知识库]9-17多线程04

复习：

1.实现多线程的方法到底有1种还是2种还是4种？

2.怎样才是正确的线程启动方式？

3.如何正确停止线程？（难点）

4.线程的一生-6个状态（生命周期）

学习目标：

1.为什么线程通信的方法wait(),notify()和notifyAll()被定义在Object类？而sleep定义在Thread类里？

2.用3种方式实现生产者模式

3.JavaSE8和Java1.8和JDK 8 是什么关系，是同一个东西吗？

4.Join 和sleep和wait期间线程的状态分别是什么？为什么？

wait,notify,notifyAll

阻塞阶段->唤醒阶段->

在执行上述几种方法时，首先，我们是必须得先得到monitor即获得synchronized锁。才能执行上述几种方法。

其次，我们只能释放其中一个锁。

最后，这些方法是任何对象都可以调用的。

在持有多把锁的时候，要注意，该如何释放，释放谁，释放的时间等等。

被唤醒的4种情况：

注意：wait只会释放，其自己的锁。

package ThreadCommonMethod;
/**
 * @program:多线程和IO
 * @descripton:展示wait和notify的使用方法
 * @author:ZhengCheng
 * @create:2021/9/17-13:05
 **/
public class Wait {
    static Object object = new Object();
    static class Thread1 extends Thread{
        @Override
        public void run() {
            synchronized (object){
                System.out.println(Thread.currentThread().getName()+"Begin");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程"+Thread.currentThread().getName()+"获得了锁");
        }
    }
    static class Thread2 extends Thread{
        @Override
        public void run() {
            synchronized (object){
                object.notify();
                System.out.println("线程"+Thread.currentThread().getName()+"调用了notify");
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
        thread1.start();
        Thread.sleep(200);
        thread2.start();
    }
}

演示NotifyAll

package ThreadCommonMethod;
/**
 * @program:多线程和IO
 * @descripton:
 * @author:ZhengCheng
 * @create:2021/9/17-13:30
 **/
public class NotifyAll {
    static Object ob = new Object();
    static class Thread1 implements Runnable{
        @Override
        public void run() {
            synchronized (ob){
                System.out.println(Thread.currentThread().getName()+"开始了");
                try {
                    ob.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"被唤醒了");
        }
    }

    static class Thread3 extends Thread{
        @Override
        public void run() {
            synchronized (ob){
                ob.notifyAll();
                System.out.println(Thread.currentThread().getName()+"唤醒了所有线程");
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread1 thread1 = new Thread1();

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

        Thread3 thread3 = new Thread3();
        t1.start();
        t2.start();

        Thread.sleep(1000);
        thread3.run();
    }
}

学习到了Notify、wait。我们可以尝试实现生产者和消费者模式。

那么首先，什么是生产者和消费者模式呢？

手写生产者消费者模式。尝试用自己的方式来完成。

题目：使用多线程，交替打印0-99

package ThreadKN.交替打印100;

/**
 * @program:多线程和IO
 * @descripton:两个线程交替打印
 * @author:ZhengCheng
 * @create:2021/9/17-22:14
 **/
public class demo {
    static int a =0;
    static Object lock = new Object();
    public static void main(String[] args) {
        d1 d1 = new d1();
        d2 d2 = new d2();
        Thread thread1 = new Thread(d1);
        Thread thread2 = new Thread(d2);
        thread1.start();
        thread2.start();
    }
    static class d1 implements Runnable{
        public d1() {
        }

        @Override
        public void run() {
            print();
        }
    }
    static void print(){
        while (a<100){
            synchronized (lock){
                System.out.println(a+++Thread.currentThread().getName());
                lock.notify();
                if (a<100){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
     static class d2 implements Runnable{
         public d2() {
         }
         @Override
        public void run() {
            print();
        }
    }
}

?深入理解，为什么要先notify然后再lock。这个锁对象究竟是如何操作的？明天好好想想。