第05章_java多线程

5.多线程

5.1 程序、进程、线程的理解

/*
1.程序:是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码
2.进程:程序的一次执行过程，或是正在运行的一个程序
    2.1 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
3.线程:进程可进一步细化为线程，是一个程序内部的一条执行路径
    3.1 说明：线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
 */

/*
4.补充
	4.1 内存结构
 */

/*
	4.2 进程可以细化为多个线程。
	4.3 每个线程拥有自己独立的：栈、程序计数器
	4.4 多个线程共享同一个进程中的结构：方法区、堆。
 */

5.2 并行与并发

/*
1.单核CPU与多核CPU的理解
	1.1 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务，但是因为CPU时间单元特别短，因此感觉不出来
	1.2 如果是多核的话，才能更好地发挥多线程的效率
2.Java应用程序至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程	
3.并发与并行的理解：
	3.1 并发：一个CPU(采用时间片)同时执行多个任务。比如：单核cpu的工作方式
	3.2 并行：多个CPU同时执行多个任务。比如：多核cpu的工作方式
 */

5.3 创建线程的四种方式

/*
1.方式一：继承Thread类的方式
	1.1 使用方式：
    	1.1.1 创建一个继承于Thread类的子类
    	1.1.2 重写Thread类的run() --> 将此线程执行的操作声明在run()中
    	1.1.3 创建Thread类的子类的对象
    	1.1.4 通过此对象调用start()：
    		1.1.4.1 启动当前线程
    		1.1.4.2 调用当前线程的run()
	1.2 说明两个问题：
    	1.2.1 问题一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程
    	1.2.2 问题二：如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start().
 */
public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //线程1
        myThread.start();
        //线程2
        new MyThread(){
            @Override
            public void run() {
                for(int i=0;i<20;i++){
                    if(i%2==0){
                        System.out.println(getName()+" "+i+" ");
                    }
                }
            }
        }.start();
        //以下操作在main线程中执行
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+" "+i+" ");
        }
        /*
        输出：三个线程会出现交叉输出的情况
         */
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if(i%2==1){
                System.out.println(getName()+" "+i+" ");
            }
        }
    }
}

/*
2.方式二：实现Runnable接口的方式
	2.1 使用方式：
    	2.1.1 创建一个实现了Runnable接口的类
    	2.1.2 实现类去实现Runnable中的抽象方法：run()
    	2.1.3 创建实现类的对象
    	2.1.4 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
    	2.1.5 通过Thread类的对象调用start():
   			2.1.5.1 启动当前线程
    		2.1.5.2 调用当前线程的run()方法，该run()方法会调用实现类中重写的run()方法
 */
public class Main {
    public static void main(String[] args) {
        YourThread yourThread = new YourThread();
        Thread thread = new Thread(yourThread);
        thread.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<20;i++){
                    if(i%2==0){
                        System.out.println(Thread.currentThread().getName()+" "+i+" ");
                    }
                }
            }
        }).start();
    }
}
class YourThread implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if(i%2==1){
                System.out.println(Thread.currentThread().getName()+" "+i+" ");
            }
        }
    }
}

/*
3.两种方式的对比：
    3.1 开发中：优先选择：实现Runnable接口的方式
        原因：1.实现的方式没有类的单继承性的局限性
             2.实现的方式更适合来处理多个线程共享数据的情况(看下面例子)
    3.2 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
              目前两种方式，要想启动线程，都是调用的Thread类中的start()
4.例子：创建三个窗口卖票，总票数为100张，使用两种方式完成（存在线程安全问题，待解决）
 */
public class Main {
    public static void main(String[] args) {
        YourThread yourThread = new YourThread();
        Thread thread1 = new Thread(yourThread);
        thread1.start();
        Thread thread2 = new Thread(yourThread);
        thread2.start();
        Thread thread3 = new Thread(yourThread);
        thread3.start();

        Mythread myThread1 = new Mythread();
        myThread1.start();
        Mythread myThread2 = new Mythread();
        myThread2.start();
        Mythread myThread13 = new Mythread();
        myThread13.start();
    }
}
class YourThread implements Runnable{
    //只创造了1个对象，不需要用static就满足所有进程共享ticket
    private int ticket=100;
    @Override
    public void run() {
        while (true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"取到了："+ticket+"票");
                ticket--;
            }else {
                break;
            }
        }

    }
}
class Mythread extends Thread{
    //创造了3个对象，需要用static才能满足所有进程共享ticket
    private static int ticket=100;
    @Override
    public void run() {
        while (true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"取到了："+ticket+"票");
                ticket--;
            }else {
                break;
            }
        }
    }
}

/*
5.方式三：实现Callable接口
    5.1 使用方式：
        5.1.1 创建一个Callable接口的实现类
        5.1.2 实现call方法，将此线程需要执行的操作声明在call()中
        5.1.3 创建Callable接口实现类的对象
        5.1.4 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        5.1.5 将FutureTask的对象作为参数（runnable实现类的对象）传递到Thread类的构造器中，创建Thread对象，并调用start()
        5.1.6 FutureTask对象调用get()方法获取Callable实现类中重写的call()方法的返回值（可选）
    5.2 如何理解实现Callable接口创建多线程的方式比实现Runnable接口创建多线程的方式强大？
        5.2.1 call()可以返回值的
        5.2.2 call()可以抛出异常，被外面的操作捕获，获取异常的信息
        5.2.3 Callable是支持泛型的-->到泛型再细说
 */
public class Main {
    public static void main(String[] args) {
        HisThread hisThread = new HisThread();
        FutureTask futureTask = new FutureTask(hisThread);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            //FutureTask对象调用get()方法获取Callable实现类中重写的call()方法的返回值
            Object sum=futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}
class HisThread implements Callable{

    @Override
    public Object call() throws Exception {
        int sum=0;
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i+" ");
            sum+=i;
        }
        return sum;
    }
}

/*
6.方式四：使用线程池
    6.1 使用方式：
        6.1.1 提供指定线程数量的线程池
        6.1.2 设置线程池的属性（可选）
        6.1.3 执行指定的线程的操作。需要提供Runnable接口或Callable接口实现类的对象
        6.1.4 关闭连接池
    6.2 好处
        6.2.1 提高响应速度（减少了创建新线程的时间）
        6.2.2 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
        6.2.3 便于线程管理:
            6.2.3.1 corePoolSize：核心池的大小
            6.2.3.2 maximumPoolSize：最大线程数
            6.2.3.3 keepAliveTime：线程没任务时最多保持多长时间后会终止
 */
public class Main {
    public static void main(String[] args) {
        //提供10线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        //ExecutorService为接口，当中没什么属性，需要转为它的实现类才能设置线程池的属性
        System.out.println(executorService.getClass());//查看ExecutorService实现类为ThreadPoolExecutor
        ThreadPoolExecutor threadPoolExecutor=(ThreadPoolExecutor) executorService;
        threadPoolExecutor.setCorePoolSize(10);

        //执行指定的线程的操作。需要提供Runnable接口或Callable接口实现类的对象
        //参数为Runnable接口实现类对象
        executorService.execute(new YouThread());
        //参数为Callable接口实现类对象
        Future submit = executorService.submit(new HisThread());
        try {
            System.out.println("总和为:"+submit.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        //关闭线程池
        executorService.shutdown();
    }
}
class YouThread implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+" "+i+" ");
            }
        }
    }
}
class HisThread implements Callable{

    @Override
    public Object call() throws Exception {
        int sum=0;
        for(int i=0;i<20;i++){
            if(i%2==1){
                System.out.println(Thread.currentThread().getName()+" "+i+" ");
                sum+=i;
            }
        }
        return sum;
    }
}

5.4 Thread类中的常用方法

/*
1.Thread类中的常用的方法:
    1.1 void start():启动当前线程，调用当前线程的run()
    1.2 void run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
    1.3 static Thread currentThread():静态方法，返回执行当前代码的线程
    1.4 String getName():获取当前线程的名字
    1.5 void setName(String name):设置当前线程的名字
    1.6 void yield():释放当前cpu的执行权，但是有可能马上又抢到了cpu的执行权
    1.7 void join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
    1.8 void stop():已过时。当执行此方法时，强制结束当前线程
    1.9 void sleep(long millis):让当前线程“睡眠”指定的millis毫秒。在指定的millis毫秒时间内，当前线程是阻塞状态
    1.10 boolean isAlive():判断当前线程是否存活
 */
public class Main {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());//main
        Thread.currentThread().setName("主进程");
        System.out.println(Thread.currentThread().getName());//主进程
        //另外一种修改线程名的方式：重载构造器
        Thread thread = new MyThread("Thread: 1");
        System.out.println(thread.getName());//Thread: 1
        System.out.println();

        thread.start();


        new MyThread(){
            @Override
            public void run() {
                for(int i=0;i<20;i++){
                    if(i%2==0){
                        try {
                            //每次执行到这阻塞1秒（1000ms）
                            sleep(1000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.println(getName()+" "+i+" ");
                    }
                    if(i%10==0){
                        //释放当前cpu的执行权，但是有可能马上又抢到了cpu的执行器
                        this.yield();
                    }
                }
            }
        }.start();

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+" "+i+" ");
            if(i==5){
                try {
                    //此时线程main就进入阻塞状态，线程Thread: 1完全执行完以后，线程main才结束阻塞状态
                    thread.join();
                    //当返回线程main继续执行时Thread: 1线程已经完全执行完了，即已经不在存活
                    System.out.println(thread.isAlive());//false
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if(i==8){
                //此时线程main被强制结束
                Thread.currentThread().stop();
            }
        }
    }
}
class MyThread extends Thread{

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if(i%2==1){
                System.out.println(getName()+" "+i+" ");
            }
        }
    }

    public MyThread(){

    }
    public MyThread(String name) {
        super(name);
    }
}

/*
2.线程的优先级：
    2.1 Thread.MAX_PRIORITY：10
        Thread.MIN_PRIORITY：1
        Thread.NORM_PRIORITY：5  -->默认优先级
    2.2 如何获取和设置当前线程的优先级：
        int getPriority():获取线程的优先级
        void setPriority(int newPriority):设置线程的优先级
    2.3 说明：高优先级的线程要抢占低优先级线程的cpu执行权。从概率上讲，高优先级的线程高概率的情况下被执行，并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行
 */
public class Main {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        System.out.println(thread.getPriority());//5
        thread.setPriority(Thread.MAX_PRIORITY);
        System.out.println(thread.getPriority());//10
        thread.start();

        System.out.println(Thread.currentThread().getPriority());//5
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        System.out.println(Thread.currentThread().getPriority());//1

        for(int i=0;i<20;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+" "+i+" ");
            }
        }
    }
}
class MyThread extends Thread{

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if(i%2==1){
                System.out.println(getName()+" "+i+" ");
            }
        }
    }
}

5.5 Thread的生命周期

/*
1.图示
 */

/*
2.说明：
	2.1 生命周期关注两个概念：状态、相应的方法
	2.2 关注：
		2.2.1 状态a-->状态b:哪些方法执行了
		2.2.2 某个方法主动调用：状态a-->状态b
	2.3 阻塞：临时状态，不可以作为最终状态
    	死亡：最终状态
 */    	

5.6 线程的同步机制

/*
1.背景
例子：创建3个窗口卖票，总票数为100张.
    1.1 问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
    1.2 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
    1.3 如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket后，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变
2.Java解决方案：同步机制
    2.1 在Java中，我们通过同步机制，来解决线程的安全问题
    2.2 方式一：同步代码块
        2.2.1 synchronized(同步监视器){
                //需要被同步的代码
               }
        2.2.2 操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了
        2.2.3 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
        2.2.4 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
              要求：多个线程必须共用同一把锁
        2.2.5 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
        2.2.6 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器
 */
public class Main {
    public static void main(String[] args) {
//        YourThread yourThread = new YourThread();
//        Thread thread1 = new Thread(yourThread);
//        thread1.start();
//        Thread thread2 = new Thread(yourThread);
//        thread2.start();
//        Thread thread3 = new Thread(yourThread);
//        thread3.start();

        MyThread myThread1 = new MyThread();
        myThread1.start();
        MyThread myThread2 = new MyThread();
        myThread2.start();
        MyThread myThread13 = new MyThread();
        myThread13.start();
    }
}
class YourThread implements Runnable{
    //只创建了1个对象，不需要用static就满足所有进程共享ticket
    private int ticket=100;
    //只创建了1个对象，不需要用static就满足所有进程共用Object这把锁
    private Object object=new Object();

    @Override
    public void run() {
        while (true){
//            synchronized (object){}
            //this代表当前YourThread的对象，只创建了1个对象，所以满足所有进程共用一把锁
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "取到了：" + ticket + "票");
                    ticket--;
                } else {
                    break;
                }
            }
        }

    }
}
class MyThread extends Thread{
    //创建了3个对象，需要用static才能满足所有进程共享ticket
    private static int ticket=100;
    //创建了3个对象，需要用static才能满足所有进程共用Object这把锁
    private static Object object=new Object();
    @Override
    public void run() {
        while (true){
            //错误的，this代表当前MyThread的对象，创建了3个对象，所以不满足所有进程共用一把锁
//            synchronized (this){}
            //正确的
//            synchronized (object){}
            //类也是对象,MyThread类只加载了一次，所以满足所有进程共用一把锁
            synchronized (MyThread.class) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "取到了：" + ticket + "票");
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

/*
    2.3 方式二：同步方法
        2.3.1 如果操作共享数据的代码完整地声明在一个方法中，我们不妨将此方法声明为同步的
        2.3.2 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
        2.3.3 非静态的同步方法，同步监视器是：this
              静态的同步方法，同步监视器是：当前类本身
 */
public class Main {
    public static void main(String[] args) {
        YourThread yourThread = new YourThread();
        Thread thread1 = new Thread(yourThread);
        thread1.start();
        Thread thread2 = new Thread(yourThread);
        thread2.start();
        Thread thread3 = new Thread(yourThread);
        thread3.start();

        MyThread myThread1 = new MyThread();
        myThread1.start();
        MyThread myThread2 = new MyThread();
        myThread2.start();
        MyThread myThread13 = new MyThread();
        myThread13.start();
    }
}
class YourThread implements Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while (true){
            show();
            if(ticket==0){
                break;
            }
        }
    }
    //锁为this，只创建了1个对象，所以满足所有进程共用一把锁
    private synchronized void show(){
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "取到了：" + ticket + "票");
            ticket--;
        }
    }
}
class MyThread extends Thread{
    private static int ticket=100;
    @Override

    public void run(){
        while (true){
            show();
            if(ticket==0){
                break;
            }
        }
    }
    //错误的，锁为this，创建了3个对象，所以不满足所有进程共用一把锁
//    private synchronized void show() {
    //正确的，this无法在静态方法中使用，所以锁为当前的类MyThread.class
    private static synchronized void show(){
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "取到了：" + ticket + "票");
            ticket--;
        }
    }
}

/*
    2.4 方式三：Lock锁  --- JDK5.0新增
        2.4.1 使用方式：
            2.4.1.1 实例化ReentrantLock
            2.4.1.2 调用锁定方法：lock()
            2.4.1.3 调用解锁方法：unlock()
        2.4.2 synchronized 与 Lock的异同？
            2.4.2.1 相同：二者都可以解决线程安全问题
            2.4.2.2 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
                         Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
        2.4.3 使用的优先顺序：
              Lock ---> 同步代码块（已经进入了方法体，分配了相应资源 ) ---> 同步方法（在方法体之外)
 */
public class Main {
    public static void main(String[] args) {
        YourThread yourThread = new YourThread();
        Thread thread1 = new Thread(yourThread);
        thread1.start();
        Thread thread2 = new Thread(yourThread);
        thread2.start();
        Thread thread3 = new Thread(yourThread);
        thread3.start();

        Mythread myThread1 = new Mythread();
        myThread1.start();
        Mythread myThread2 = new Mythread();
        myThread2.start();
        Mythread myThread13 = new Mythread();
        myThread13.start();
    }
}
class YourThread implements Runnable{
    private int ticket=100;
    //只创建了1个对象，不需要用static就满足所有进程共用lock这把锁
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"取到了："+ticket+"票");
                    ticket--;
                }else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }

    }
}
class Mythread extends Thread{
    private static int ticket=100;
    //创建了3个对象，需要用static才能满足所有进程共用lock这把锁
    private static ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"取到了："+ticket+"票");
                    ticket--;
                }else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }

    }
}
/*
    2.5 线程同步的利弊
        2.5.1 同步的方式，解决了线程的安全问题。---好处
        2.5.2 操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低
 */

/*
3.同步机制的课后习题
银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
分析:
    3.1 是否是多线程问题?是，两个储户线程
    3.2 是否有共享数据?有，账户(或账户余额)
    3.3 是否有线程安全问题?有
    3.4 需要考虑如何解决线程安全问题?同步机制:有三种方式
 */
class Account{
    private double balance;
    public Account(double balance){
        this.balance=balance;
    }
    //锁为this，只创建了一个对象，所以满足所有线程公用同一把锁
    public synchronized void deposit(double amt){
        if(amt>0){
            balance+=amt;
            System.out.println(Thread.currentThread().getName()+"存钱成功，余额为"+balance);
        }
    }

}
class Customer extends Thread{
    private Account account;

    public Customer(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        for(int i=1;i<=3;i++){
            account.deposit(1000);
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Account account = new Account(0);
        Customer customer1 = new Customer(account);
        Customer customer2 = new Customer(account);
        customer1.start();
        customer2.start();
    }
}

5.7 线程安全的单例模式

class Person{
    private Person(){

    }
    private static Person instance=null;
    public static Person getInstance(){
        //效率稍差
/*        synchronized (Person.class){
            if(instance==null){
                instance=new Person();
            }
            return instance;
        }*/
        //效率更高
        if(instance==null) {
            synchronized (Person.class) {
                if (instance == null) {
                    instance = new Person();
                }
            }
        }
            return instance;
    }
}

5.8 死锁问题

/*
1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
2.说明：
    2.1 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
    2.2 我们使用同步时，要避免出现死锁
3.举例
 */
public class Main {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

    }
}

5.9 线程通信

/*
线程通信的例子：使用两个线程交替打印1-100
1.线程通信涉及到的三个方法：
    1.1 void wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
    1.2 void notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个
    1.3 void notifyAll():一旦执行此方法，就会唤醒所有被wait的线程
2.说明：
    2.1 wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
    2.2 wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器
        否则，会出现IllegalMonitorStateException异常
    2.3 wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中
3.sleep() 和 wait()的异同？
    3.1 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
    3.2 不同点：
        3.2.1 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
        3.2.2 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
        3.2.3 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁
4.小结
	4.1 释放锁的操作:
		4.1.1 当前线程的同步代码块、同步方法执行结束。
		4.1.2 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
		4.1.3 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
		4.1.4 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
	4.2 不会释放锁的操作
		4.2.1 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
		4.2.2 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
		4.2.3 应尽量避免使用suspend()和resume()来控制线程
 */
public class Main {
    public static void main(String[] args) {
        YourThread yourThread = new YourThread();
        Thread thread1 = new Thread(yourThread);
        thread1.start();
        Thread thread2 = new Thread(yourThread);
        thread2.start();
    }
}
class YourThread implements Runnable{
    private int number=1;
    Object object=new Object();

    @Override
    public void run() {
        while (true){
            //同步监视器是this
            synchronized (this) {
                //调用notify()方法，唤醒被wait的一个线程
                notify();
                if(number<=100){
                    System.out.println(Thread.currentThread().getName()+" "+number+" ");
                    number++;
                    try {
                        //调用wait()方法，当前线程就进入阻塞状态，并释放同步监视器
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }

            }
            //同步监视器是object
/*            synchronized (object) {
                //必须用object调用notify()
                object.notify();
                if(number<=100){
                    System.out.println(Thread.currentThread().getName()+" "+number+" ");
                    number++;
                    try {
                        //必须用object调用wait
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }

            }*/

        }

    }
}

/*
4.线程通信的应用:生产者/消费者问题：
    生产者(Producer)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品。
    店员一次只能持有固定数量的产品(比如:20)，如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产;
    如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
    4.1 分析:
        4.1.1 是否是多线程问题?是，生产者线程，消费者线程
        4.1.2 是否有共享数据?是，店员(或产品）
        4.1.3 如何解决线程的安全问题?同步机制,有三种方法
        4.1.4 是否涉及线程的通信?是

 */
public class Main {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer producer = new Producer(clerk);
        producer.setName("生产者");
        Customer customer1 = new Customer(clerk);
        customer1.setName("消费者1");
        Customer customer2 = new Customer(clerk);
        customer2.setName("消费者2");
        producer.start();
        customer1.start();
        customer2.start();
    }
}
class Clerk{
    private int productCount=0;
    public synchronized void produceProduct(){
        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+"开始生产第"+productCount+"个产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    public synchronized void consumerProduct(){
        if(productCount>0){
            System.out.println(Thread.currentThread().getName()+"开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
class Producer extends Thread{
    Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(getName()+":开始生产产品...");
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}
class Customer extends Thread{
    Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(getName()+":开始消费产品...");
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumerProduct();
        }
    }
}