Java学习笔记----Day11（多线程）

多线程

- 1. 进程、线程
- 2. 实现线程的三种方式
- 3. 线程的生命周期
- 4. 线程里常用的方法
- 5. 线程的调度（了解）
- 6. 多线程并发环境下，数据的安全问题
- 7. Java三大变量（线程同步机制synchronized）【重要的内容】
- 8. 死锁
- 9. 开发中应该怎么解决线程安全问题
- 10. 守护线程
- 11. 定时器
- 12. Object类中的wait和notify方法（生产者和消费者模式）

1. 进程、线程

进程：一个应用程序
线程：一个进程中的执行场景/执行单元
一个进程可以执行多个线程
例如：
对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后。
会先启动JVM，而JVM就是一个进程，JVM再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾。
现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。

进程和线程的关系：
进程A和进程B的内存独立不共享。两个进程是独立的，不共享资源。
线程A和线程B，在java语言中，线程A和线程B，堆内存和方法区内存共享；但是栈内存独立，一个线程一个栈，内存独立不共享。（main方法结束只代表主线程结束，其他线程可能还在执行）
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。多线程并发可以提高效率。 java中之所以有多线程机制，目的就是为了提高程序的处理效率。

2. 实现线程的三种方式

方式1：编写一个类，直接继承java.lang.Thread，重写run方法。

public class ThreadTest01 {
    public static void main(String[] args) {
        //主线程
        //创建一个分支线程对象
        MyThread myThread = new MyThread();
        //启动线程
        myThread.start();
        //这段代码运行在主线程中
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程---->"+i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        //编写程序，这段程序运行在分支堆栈中
        for (int i = 0; i < 1000; i++) {
            System.out.println("分支线程---->"+i);
        }
    }
}

start()方法的作用：启动一个分支线程，在JVM种开辟一个新的栈空间，这段代码瞬间完成，线程启动成功之后会自动调用run()方法，run()方法在分支栈的底部，run()方法和main()方法是平级的。
注：直接在main()方法中调用run()方法是不会启动线程的，也不会分配新的栈空间，只是在主栈中运行run()方法而已。

方式2：编写一个类，实现java.lang.Runnable接口，实现run方法。

package com.test;

public class ThreadTest02 {
    public static void main(String[] args) {
        //创建一个可运行的对象
        MyRunnable r = new MyRunnable();
        //将可运行的对象封装成一个线程对象
        Thread t = new Thread(r);
        //启动线程
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程---->"+i);
        }
    }
}
//这并不是一个线程类，十一个可运行的类，它还不是一个线程
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("分支线程---->"+i);
        }
    }
}

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。

方式二可以使用匿名内部类

public class ThreadTest03 {
    public static void main(String[] args) {
        //创建线程对象，采用匿名内部类
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("分支线程---->"+i);
                }
            }
        });
        //启动线程
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程---->"+i);
        }
    }
}

方式三：实现Callable接口（JDK8新特性）
这种方式实现的线程可以获取线程的返回值。前面两种方式是无法获取线程返回值的，因为run方法返回void。
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，怎么能拿到这个执行结果呢？使用第三种方式：实现Callable接口方式。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask; //JUC包下，属于java的并发包，新特性

/**
 * 实现线程的第三种方式：实现Callable接口
 * 优点：可以获取线程执行结果
 * 缺点：效率比较低。(在获取t线程执行结果的时候，当前线程受到阻塞，效率降低)
 */
public class ThreadTest11{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个“未来任务类”对象
        //注：参数非常重要需要给一个Callable接口实现类对象
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { //call()相当于run()，只不过call方法有返回值
                //线程执行一个任务，执行之后可能会有一个执行结果
                //模拟执行
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b; //自动装箱（300结果变成Integer）
            }
        });
        //创建一个线程对象
        Thread t = new Thread(task);
        //启动线程
        t.start();
        //这里是main方法，获取t线程的结果
        //get()方法执行可能会导致当前线程阻塞
        Object obj = task.get();
        System.out.println("线程执行结果："+obj);
        //main方法这里的程序想要执行必须等待get()方法结束
        //而get()方法可能需要很久，因为get方法是为了拿另一个线程的执行结果
        System.out.println("HELLO!!");
    }
}

3. 线程的生命周期

在这里插入图片描述

4. 线程里常用的方法

获取当前线程对象
Thread t = Thread.currentThread();
返回值t就是当前线程
获取线程对象的名字
String name = 线程对象.getName();
修改线程对象的名字
线程对象.setName(“线程名字”);

【示例】测试代码

public class ThreadTest04 {
    public static void main(String[] args) {
        //currentThread就是当前线程对象
        //这段代码出现在main方法中，所以当前线程是主线程
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName());
        //创建线程对象
        MyThread2 t = new MyThread2();
        //设置线程名字
        t.setName("tttt...");
        //获取线程名字
        String tName = t.getName();
        System.out.println(tName);
        MyThread2 t2 = new MyThread2();
        System.out.println(t2.getName());
        //启动线程
        t.start();
    }
}
class MyThread2 extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            Thread currentThread = Thread.currentThread();
            System.out.println(currentThread.getName()+"---->"+i);
        }
    }
}

sleep()
static void sleep(long millis) 静态方法；参数是毫秒；让当前线程进入休眠，进入阻塞状态，放弃占有的时间片。
拓展：下面程序是否能让t线程进入睡眠？

public class ThreadTest06 {
    public static void main(String[] args) {
        Thread t = new MyThread3();
        t.setName("t");
        t.start();
        //调用sleep()
        try {
            t.sleep(1000*5);    //能否让t线程进入睡眠  
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("hello....");
    }
}
class MyThread3 extends Thread{
    public void run(){
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
}

不能。sleep()是静态方法，在执行时还是会转换成Thread.sleep(),这行代码的作用时让当前线程进入休眠，也就是main

interrupt()方法终止线程的休眠
注意：这个方法依靠的是java的异常处理机制，这个方法执行的时候会让slee()报异常，使程序进入catch语句块，使得sleep()方法结束。

public class ThreadTest07 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable2());
        t.setName("t");
        t.start();
        //5秒后t线程醒来
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //中断t线程的睡眠
        t.interrupt();
    }
}
class MyRunnable2 implements Runnable{
    //run()当中的异常不能throws，只能try/catch
    //因为run()在父类中没有抛出异常，子类不能比父类抛出更多的异常
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---->begin");
        try {
            Thread.sleep(1000*60*60*24*365);
        } catch (InterruptedException e) {
            //e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"---->end");
    }
}

stop()方法，强行终止线程，注：容易丢失数据，不建议使用，已经过时了。

Thread t = new Thread(new MyRunnable3());
t.start();
t.stop();//强行终止

【示例】合理终止一个线程的执行：打一个布尔标记

public class ThreadTest09 {
    public static void main(String[] args) {
        MyRunnable4 r = new MyRunnable4();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();
        //模拟5秒
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //终止线程
        r.run = false;
    }
}
class MyRunnable4 implements Runnable{
    //打一个布尔标记
    boolean run = true;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (run){
                System.out.println(Thread.currentThread().getName()+"---->"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }else {
                //终止线程
                return;
            }
        }
    }
}

5. 线程的调度（了解）

常见的线程调度模型
抢占式调度模型：哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。java采用的就是抢占式调度模型。
均分式调度模型： 平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。平均分配，一切平等。有一些编程语言，线程调度模型采用的是这种方式。
java中提供了方法与线程调度有关系
实例方法：
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程优先级
最低优先级1；默认优先级是5；最高优先级10
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）并不是优先级高的抢到时间片的几率大。
线程的优先级具有继承性，在A线程中创建了B线程，则B线程的优先级与A线程一样。
静态方法：
static void yield() 让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意： 在回到就绪之后，有可能还会再次抢到。
实例方法：
void join() 合并线程
这个方法不是栈的合并，而是栈互相之间发生了等待。

		MyThread m = new MyThread();
        Thread t = new Thread(m);
        t.start();
        t.join();//当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
        for (int i = 0;i<10;i++){
            System.out.println("main");
        }

6. 多线程并发环境下，数据的安全问题

什么时候数据在多线程并发的环境下会存在安全问题呢？

三个条件：多线程并发；有共享数据；共享数据有修改的行为。
满足以上3个条件之后，就会存在线程安全问题。

怎么解决线程安全问题呢？

线程排队执行（不能并发）。用排队执行解决线程安全问题。这种机制被称为：线程同步机制（实际就是线程不能并发了，必须排队执行）
线程同步就是线程排队了，线程排队了就会牺牲一部分效率，数据安全第一位，只有数据安全了，才可以谈效率。数据不安全，没有效率的事儿。

同步编程模型和异步编程模型
异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高。）异步就是并发。
同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。

【示例】同步线程
Account：

/**
 * 使用线程同步机制，解决线程安全问题
 */
public class Account {
    private String actno;
    private double balance;

    Object obj = new Object();

    public Account() {
    }

    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    //取款的方法
    public void withdraw(double money){
        //以下代码必须是线程排队，不能并发
        //线程同步机制代码：
        /*synchronized (){}
        * （）中传的必须是多线程共享的数据
        * */
        Object obj2 = new Object();
        synchronized (this){
        /*synchronized (obj){*/
        /*synchronized (obj2){*/    //传这个对象就不安全了，obj2是局部变量，不是共享对象
        /*synchronized ("abc"){*/   //”abc“在字符串常量池中
        /*synchronized (null){ */   //报错，空指针
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            this.setBalance(after);
        }
    }
}

AccountThread：

public class AccountThread extends Thread{
    //两个线程必须共享同一个账户对象
    private Account act;
    //通过构造方法传递账户对象
    public AccountThread(Account act){
        this.act = act;
    }
    public void run(){
        double money = 5000;
        //synchronized (act){ //这种方式也可以，只不过扩大了同步的范围，效率更低了
        act.withdraw(money);
        //}
        System.out.println(Thread.currentThread().getName()+"对"+act.getActno()+"取款成功，余额"+act.getBalance());
    }
}

Test：

public class Test {
    public static void main(String[] args) {
        //创建账户对象（只创建一个）
        Account act = new Account("act-001",10000);
        //创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);

        Account act2 = new Account("ACT-002",10000);
        Thread t3 = new AccountThread(act2);

        t1.setName("t1");
        t2.setName("t2");
        t3.setName("t3");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

7. Java三大变量（线程同步机制synchronized）【重要的内容】

实例变量：在堆中。
静态变量：在方法区。
局部变量：在栈中。

三大变量中：
局部变量永远都不会存在线程安全问题。因为局部变量不共享。（一个线程一个栈。）局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量+常量： 不会有线程安全问题。

成员变量： 可能会有线程安全问题。

线程同步机制（排它锁）的语法（三种）：
在这里插入图片描述

第一种：同步代码块，找的是对象锁（灵活）

		synchronized(线程共享对象){
				同步代码块;
		}

第二种：在实例方法上使用synchronized（不灵活），找的是对象锁；表示共享对象一定是this；并且同步代码块是整个方法体，可能会无故扩大同步的范围，导致程序的执行效率降低。这种方式不常用。如果共享的对象就是this，并且需要同步的代码块是整个方法体建议使用这种方式。

拓展：如果使用局部变量的话建议使用StringBulider。
因为局部变量不存在线程安全问题。StringBuffer效率比较低。
ArrayList是非线程安全的；Vector是线程安全的。
HashMap HashSet是非线程安全的；Hashtable是线程安全的。

第三种：在静态方法上使用synchronized；表示找类锁。类锁永远只有1把。就算创建了100个对象，那类锁也只有一把。

对象锁：1个对象1把锁，100个对象100把锁。
（我们经常会使用this或者自定义常量作为对象锁。）
类锁：100个对象，也可能只是1把类锁。
注：如果线程在执行过程中出现异常，会讲锁释放，后面等待的线程
就能拿到锁执行代码。

【示例】测试题1

//问题：doOther方法执行的时候需要等待doSome方法的结束吗？ 
//不需要（doOther()没有synchronized）
public class Exam01 {
    public static void main(String[] args) {
        MyClass mc = new MyClass();
        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        try {
            Thread.sleep(1000); //为了保证t1线程先执行
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        t2.start();
    }
}
class MyThread extends Thread{
    private MyClass mc;
    public  MyThread(MyClass mc){
        this.mc = mc;
    }
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if (Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}
class MyClass{
    //synchronized出现在实例方法上，表示锁this
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("doSome over");
    }
    public void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

【示例】测试题2

//问题：doOther方法执行的时候需要等待doSome方法的结束吗？ 
//需要（doOther()没有synchronized）
......
public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
......

【示例】测试题3

//问题：doOther方法执行的时候需要等待doSome方法的结束吗？ 
//不需要，因为MyClass对象是两个，两把锁。
.....
public static void main(String[] args) {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();
        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);
        ......
}
.......
	public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }

【示例】测试题4

//问题：doOther方法执行的时候需要等待doSome方法的结束吗？ 
//需要。因为静态方法是类锁，不管创建了几个对象类锁只有一把
......
public static void main(String[] args) {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();
        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);
        ......
}
......
class MyClass{
    //synchronized出现静态方法上是找类锁
    public synchronized static void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("doSome over");
    }
    public synchronized static void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

8. 死锁

synchronized在开发中尽量不要嵌套使用，容易导致死锁现象
在这里插入图片描述 【示例】死锁现场

public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        //t1和t2共享o1，o2
        Thread t1 = new MyThread01(o1,o2);
        Thread t2 = new MyThread02(o1,o2);
    }
}
class MyThread01 extends Thread{
    Object o1;
    Object o2;
    public MyThread01(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (o2){

            }
        }
    }
}
class MyThread02 extends Thread{
    Object o1;
    Object o2;
    public MyThread02(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (o1){

            }
        }
    }
}

9. 开发中应该怎么解决线程安全问题

直接就选择线程同步吗？
不是，synchronized会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。

第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候
就只能选择synchronized，线程同步机制。

10. 守护线程

java语言中线程分为两大类：
一类是：用户线程
一类是：守护线程（后台线程）其中具有代表性的就是：垃圾回收线程（守护线程）。

守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。

守护线程用在什么地方呢？
例如：每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

        //启动线程前，将线程设置为守护线程
        t.setDaemon(true);
        t.start();

11. 定时器

定时器的作用：间隔特定的时间，执行特定的程序。
例如：每周要进行银行账户的总账操作；每天要进行数据的备份操作。
在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
那么在java中其实可以采用多种方式实现：

可以使用sleep方法，设置睡眠时间，每到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）
在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。schedule()方法能完成定时器。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

【示例】定时器

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 定时器
 */
public class TimerTest {
    public static void main(String[] args) throws ParseException {
        //创建定时器对象
        Timer timer = new Timer();
        //指定定时任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2023-04-26 14:05:10");
        //每十秒执行一次
        //timer.schedule(new LogTimerTask(),firstTime,1000*10);
        //也可以使用匿名内部类的方式
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String strTime = sdf.format(new Date());
                System.out.println(strTime+":完成了一次数据备份！");
            }
        },firstTime,1000*10);
    }
}
//编写一个定时任务类
/*class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        //编写需要执行的任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(new Date());
        System.out.println(strTime+":完成了一次数据备份！");
    }
}*/

12. Object类中的wait和notify方法（生产者和消费者模式）

wait和notify方法不是线程对象的方法，是java中任何一个java对象
都有的方法，因为这两个方式是Object类中自带的。也就是说wait方法和notify方法不是通过线程对象调用
wait()方法作用：

java Object o = new Object(); o.wait();
表示： 让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。

notify()方法作用？

java Object o = new Object(); o.notify();
表示： 唤醒正在o对象上等待的线程。
ps：还有一个notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程。

使用 wait和notify方法实现生产者和消费者模式：
在这里插入图片描述

【示例】生产者和消费者模式

/**
 * 1、使用wait 方法和notify方法实现“生产者和消费者模式”
 * 2、什么是“生产者和消费者模式”?
 * 生产线程负责生产,消费线程负责消费。
 * 生产线程和消费线程要达到均衡。
 * 这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方法。
 * 3. wait和notify方法不是线程对象的方法，是普通java对象都有的方法。
 * 4. wait方法和notify方法建立在线程同步的基础之.上。 因为多线程要同时操作-个仓库。有线程安全问题。
 * 5、wait方法作用:o. wait()让正在o对象上活动的线程t进入等待状态,并且释放掉t线程之前占有的o对象的锁。
 * 6、notify方法作用:o. notify()让正在o对象上等待的线程唤醒，只是通知,不会释放o对象上之前占有的锁。
 * 7、模拟这样一个需求:
 * 仓库我们采用ist集合。
 * List集合中假设只能存储1个元素。1个元素就表示仓库满了。
 * 如果ist集合中元素个数是0 ,就表示仓库空了。
 * 保证ist集合中永远都是最多存做1个元素。
 * 必须做到这种效果:生产1个消费1个。
 */

import java.util.ArrayList;
import java.util.List;

/**
 * 使用wait方法和notify方法实现“生产者和消费者模式”
 */
public class ThreadTest12 {
    public static void main(String[] args) {
        //创建一个仓库对象（共享的）
        List list = new ArrayList();
        //创建两个线程对象
        //生产者线程
        Thread t1 = new Thread(new Producer(list));
        //消费者线程
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

        t1.start();
        t2.start();
    }
}
//生产线程
class Producer implements Runnable{
    //仓库
    private List list;
    public  Producer(List list){
        this.list = list;
    }
    @Override
    public void run() {
        //一直生产
        while (true){
            //给仓库List加锁
            synchronized (list) {
                if (list.size() > 0) {   //大于0，说明仓库满了
                    try {
                        //当前线程进入等待状态，并且释放List集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序执行到这里，说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);
                //唤醒消费者进行消费
                list.notify();

            }
        }
    }
}
//消费线程
class Consumer implements Runnable{
    //仓库
    private List list;
    public  Consumer(List list){
        this.list = list;
    }
    @Override
    public void run() {
        //一直消费
        while (true){
            synchronized (list){
                if (list.size() == 0){  //仓库空了，消费者线程等待释放List集合的锁
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序执行到这里，说明仓库中有数据，进行消费
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);
                //唤醒生产者生产
                list.notify();
            }
        }
    }
}