JavaSE--多线程

一、多线程

1、进程与线程概念

  进程是一个应用程序（1个进程是一个软件），一个进程可以启动多个线程

  线程是一个进程中的执行场景/执行单元

2、进程与线程的关系

  a）进程与线程

    进程可以看作是一个公司，线程就是公司中的一个小员工

    进程A与进程B的内存独立不共享资源

  b）线程A与线程B：

    在java语言中，线程A与线程B，堆内存和方法区内存共享

    栈独立，一个线程一个栈，每个栈之间互不干扰，各自执行各自的

  c）例如火车站可以看作一个进程

    火车站的每一个售票窗口都可以看作一个线程，每个窗口都可以买票，提高效率

    java中的多线程机制就是为了提高程序的处理效率

3、main方法结束后，之后还有其他进程

  使用了多线程机制之后，main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。

 

二、实现线程的方式

1、第一种方式

  a）编写一个类，直接继承java.lang.Thread类，重写run方法

// 定义线程类
public class MyThread extends Thread{
    public void run(){
 
    }
}
// 创建线程对象
MyThread t = new MyThread();
// 启动线程。
t.start();

  b）使用start()方法启动分支线程：

    start()方法作用：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。

        只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。

        启动成功的线程会自动调用run方法（run必须重写奥），并且run方法在分支栈的栈底部（压栈）。

// start()方法
public class ThreadTest02 {
    public static void main(String[] args) {
        // 这里是main方法，这里的代码属于主线程，在主栈中运行
        // 新建一个分支线程对象
        MyThread t = new MyThread();
        // 启动线程
        // run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
        t.start();
        // 这里的代码还是运行在主线程中。
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}
 
class MyThread extends Thread {
    run方法必须重写
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

 2、第二种方式（较常用）

  a）编写一个类，实现java.lang.Runnable接口

// 定义一个可运行的类
public class MyRunnable implements Runnable {
    public void run(){
 
    }
}
// 创建线程对象
Thread t = new Thread(new MyRunnable());
// 启动线程
t.start();

  b）例子

public class ThreadTest03 {
    public static void main(String[] args) {
        // 创建一个可运行的对象
        //MyRunnable r = new MyRunnable();
        // 将可运行的对象封装成一个线程对象
        //Thread t = new Thread(r);
        
        // 合并
        Thread t = new Thread(new MyRunnable());
        // 启动线程
        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);
        }
    }
}

3、采用匿名内部类

public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式
        // 这是通过一个没有名字的类，new出来的对象
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i < 100; i++){
                    System.out.println("t线程---> " + i);
                }
            }
        });
 
        // 启动线程
        t.start();
 
        for(int i = 0; i < 100; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

 三、线程生命周期

  新建状态、就绪状态、运行状态、阻塞状态、死亡状态

 

四、线程常用方法

1、获取线程对象的名字

  String name = 线程对象.getName();

2、修改线程对象的名字

  线程对象.setName("线程名字");

3、获取当前线程对象

  Thread t = Thread.currentThread();

  线程对象的默认名字： Thread-0、 Thread-1......

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

4、线程的sleep()方法

  static void sleep(毫秒数)静态方法

Thread.sleep(毫秒数);

  作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。代码出现在哪个线程中，哪个线程就会进入休眠状态

public class ThreadTest06 {
    public static void main(String[] args) {
        // 睡眠5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
            // 睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5、叫醒正在睡眠的线程

  interrupt();  这种终断睡眠的方式依靠了java的异常处理机制。

public class ThreadTest08 {
    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) {
            e.printStackTrace();
        }
        // 终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制）
        t.interrupt();
    }
}
 
class MyRunnable2 implements Runnable {
 
    // 重点：run()当中的异常不能throws，只能try catch
    // 因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---> begin");
        try {
            // 睡眠1年
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //1年之后才会执行这里
        System.out.println(Thread.currentThread().getName() + "---> end");
 
    }
 
}

6、强行终止线程

  stop();  已过时，

   这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。

7、合理的终止线程

// 打Boolean标记，在方法中return终止方法结束
public class ThreadTest10 {
    public static void main(String[] args) {
        MyRunable4 r = new MyRunable4();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();
 
        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程
        // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}
 
class MyRunable4 implements Runnable {
 
    // 打一个布尔标记
    boolean run = true;
 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            // 判断boolean标记
            if(run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // 有需要保存的信息  在这保存
                //终止当前线程
                return;
            }
        }
    }
}

五、线程调度

1、常见的线程调度模型

  1）抢占式调度模型：

    那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些

    java采用的就是抢占式调度模型

  2）均分式调度模型：

  平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样，平均分配，一切平等

  有一些编程语言，线程调度模型采用的是这种方式

2、常用的线程调度方法

  1）void setPriority(int newPriority)设置线程优先级

    优先级：从最低1-最高10，默认为5

  2）int getPriority() 获取线程优先级

public class ThreadTest11 {
    public static void main(String[] args) {
        System.out.println("最高优先级" + Thread.MAX_PRIORITY);
        System.out.println("最低优先级" + Thread.MIN_PRIORITY);
        System.out.println("默认优先级" + Thread.NORM_PRIORITY);
        
        // 设置主线程的优先级为1
        Thread.currentThread().setPriority(1);
        
        // 获取当前线程对象
        Thread t = new Thread(new MyRunnable5());
        t.setPriority(10);
        t.setName("t");
        t.start();
 
        for(int i = 0; i < 10000; i++){
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}
 
class MyRunnable5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10000; i++){
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

  3）static void yield()  让位方法，暂停当前正在执行的线程对象，回到就绪状态，并执行其他线程

public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable6());
        t.setName("t");
        t.start();
 
        for(int i = 1; i <= 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}
 
class MyRunnable6 implements Runnable {
 
    @Override
    public void run() {
        for(int i = 1; i <= 10000; i++) {
            //每100个让位一次
            if(i % 100 == 0){
                Thread.yield(); // 当前线程暂停一下，让给主线程
            }
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

  4）void join()等待当前线程结束

/*
    线程合并
*/
public class ThreadTest13 {
    public static void main(String[] args) {
        System.out.println("main begin");
 
        Thread t = new Thread(new MyRunnable7());
        t.setName("t");
        t.start();
 
        //合并线程
        try {
            t.join(); // t合并到当前线程中，当前线程受阻塞，t线程执行直到结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        System.out.println("main over");
    }
}
 
class MyRunnable7 implements Runnable {
 
    @Override
    public void run() {
        for(int i = 0; i < 10000; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

六、多线程并发下，数据的安全问题（重点）

1、考虑安全问题

  以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。

  编写的程序需要放到一个多线程的环境下运行，更需要关注的是这些数据在多线程并发的环境下是否是安全的

2、什么条件下数据在多线程环境下存在安全问题

  条件1：多线程并发

  条件2：有共享数据

  条件3：共享数据有修改的行为

3、解决线程安全问题

  使用“线程同步机制”

  线程排队执行（不能并发），用排队执行解决线程安全问题。

4、同步代码块synchronized

  1）同步代码块synchronized语法

// 同步代码块synchronized语法
synchronized(参数){
    需要排队执行的代码;
}
// 参数：需要传入一个共享的对象，这个共享对象一定是你需要排队执行的这些线程对象所共享的
假设t1、t2、t3、t4、t5，有5个线程，
你只希望t1 t2 t3排队，t4 t5不需要排队
一定要在括号（）中写一个t1 t2 t3共享的对象，而这个对象对于t4 t5来说不是共享的
 
//synchronized ("abc") { // "abc"在字符串常量池当中。，这样就是全部线程都会排队
//synchronized (null) { // 不能写null，会空指针异常
 
// synchronized代码块执行原理
1、假设t1和t2线程并发，开始执行synchronized代码块的时候，肯定有一个先一个后
2、假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，
找到之后，并占有这把锁，然后执行同步代码块中的程序，
在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面
共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，
直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，进入同步代码块执行程序
这样就达到了线程排队执行
/*
在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁）
100个对象，100把锁。1个对象1把锁。
*/

2）例子：模拟在同一个账户中取钱

// 线程对象
public class AccountThread extends Thread {
 
    // 两个线程必须共享同一个账户对象
    private Account act;
 
    // 通过构造方法传递过来账户对象
    public AccountThread(Account act) {
        this.act = act;
    }
 
    public void run(){
        // run方法的执行表示取款操作。
        // 假设取款5000
        double money = 5000;
        // 取款
        // 多线程并发执行这个方法
        act.withdraw(money);
        /*这样虽然也可以，但是扩大了执行范围，执行效率降低
            相当于把withdarw中所有代码都同步机制了，这样也不好
            synchronized{
                act.withdraw(money);
            }
        */
        System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());
    }
}

// 账户类
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance;
 
    //对象
    Object obj = new Object(); // 实例变量。（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）
 
    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 (this){
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
}

// main方法中测试
public class Test {
    public static void main(String[] args) {
        // 创建账户对象（只创建1个）
        Account act = new Account("act-001", 10000);
        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
 
        // 设置name
        t1.setName("t1");
        t2.setName("t2");
        // 启动线程取款
        t1.start();
        t2.start();
    }
}

  3）synchronized放在实例方法上

    当synchronized出现在实例方法上，一定锁的是this。只能是this。不能是其他的对象了。所以这种方式不灵活

    缺点： 表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低。所以不常用

    优点： 如果共享的对象就是this，并且需要同步的代码块是整个方法体，建议使用这种方式。代码简洁

//取款的方法
public synchronized void withdraw(double money){
    double before = this.getBalance();
    double after = before - money;
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    this.setBalance(after);
}

5、哪些变量会产生线程安全问题

  java三大变量：实例变量（在堆中）、静态变量（在方法区）、局部变量（在栈中）

    以上三大变量中：局部变量永远都不会存在线程安全问题因为局部变量不共享。（一个线程一个栈。）局部变量在栈中。所以局部变量永远都不会共享。

 6、synchronized的三种写法

  1）第一种：同步代码块

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

  2）第二种：在实例方法上使用synchronized

    表示共享对象一定是this

    并且同步代码块是整个方法体

  3）第三种：在静态方法上使用synchronized

    表示找类锁，类锁永远只有1把

    就算创建了100个对象，那类锁也只有一把

      对象锁：1个对象1把锁，100个对象100把锁

      类锁：100个对象，也可能只是1把类锁

 

七、死锁

1、死锁概述

2、死锁代码（需要会写）

public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
 
        // t1和t2两个线程共享o1,o2
        Thread t1 = new MyThread1(o1,o2);
        Thread t2 = new MyThread2(o1,o2);
 
        t1.start();
        t2.start();
    }
}
 
class MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){
 
            }
        }
    }
}
 
class MyThread2 extends Thread {
    Object o1;
    Object o2;
    public MyThread2(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){
 
            }
        }
    }
}

 

八、守护线程

1、线程分类

  一类是：用户线程

  一类是：守护线程（后台线程），其中具有代表性的就是：垃圾回收线程（守护线程）

2、守护线程特点

  一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束

  注意：主线程main方法就是一个用户线程

3、守护线程作用

  例如：每天00:00的时候系统数据自动备份

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

4、setDaemon(true);

  启动之前调用此方法，使线程称为守护线程

public class ThreadTest14 {
    public static void main(String[] args) {
        Thread t = new BakDataThread();
        t.setName("备份数据的线程");
 
        // 启动线程之前，将线程设置为守护线程
        t.setDaemon(true);
 
        t.start();
 
        // 主线程：主线程是用户线程
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 
class BakDataThread extends Thread {
    public void run(){
        int i = 0;
        // 即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止
        while(true){
            System.out.println(Thread.currentThread().getName() + "--->" + (++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

九、定时器

1、定时器的作用

  间隔特定的时间，执行特定的程序。

  java可以采用多种方式实现定时器：使用sleep、或者spring框架中SpringTask、或者java.util.Timer定时器类

2、使用定时器

  继承TimerTask抽象类，他是一个抽象类

// 创建一个定时器对象
Timer timer = new Timer();
// 守护线程的方式
Timer timer = new Timer(true); 
 
// 指定定时任务
timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);

public class TimerTest {
    public static void main(String[] args) throws Exception {
 
        // 创建定时器对象
        Timer timer = new Timer();
        
        //守护线程的方式
        //Timer timer = new Timer(true); 
 
        // 指定定时任务
        //timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2020-03-14 09:34:30");
        timer.schedule(new LogTimerTask() , firstTime, 1000 * 10);
        /*
        //匿名内部类方式
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                // code....
            }
        } , 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 + ":成功记录了一次！");
    }
}

 十、实现线程的第三种方式

  实现Callable接口，这种方式可以获取线程的返回值

  Callable接口的优点：可以获取到线程的执行结果

  Callable接口的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低

public class ThreadTest15 {
    public static void main(String[] args) throws Exception {
 
        // 第一步：创建一个“未来任务类”对象。
        // 参数需要给一个Callable接口实现类对象
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { // call()方法就相当于run方法。只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                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;
            }
        });
 
        // 创建线程对象
        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 world!");
    }
}

 

十一、关于Object类中的wait和notify方法（生产者和消费者模式）

1、概述

  wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的

  注意：wait方法和notify方法不是通过线程对象调用

2、wait()方法作用

Object o = new Object();
o.wait();

  让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止

  o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态，并且释放之前占有o对象的锁

3、notify()方法作用

Object o = new Object();
o.notify();

  唤醒正在o对象上等待的线程，只会通知，不会释放之前占有的o对象的锁

  notifyAll()方法：唤醒o对象上处于等待的所有线程 

4、生产者与消费者之间结构

5、实现生产者和消费者模式

模拟这样一个需求：
    仓库我们采用List集合。
    List集合中假设只能存储1个元素。
    1个元素就表示仓库满了。
    如果List集合中元素个数是0，就表示仓库空了。
    保证List集合中永远都是最多存储1个元素。
 
必须做到这种效果：生产1个消费1个

 

public class ThreadTest16 {
    public static void main(String[] args) {
        // 创建1个仓库对象，共享的。
        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，说明仓库中已经有1个元素了。
                    try {
                        // 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够执行到这里说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒消费者进行消费
                list.notifyAll();
            }
        }
    }
}
 
// 消费线程
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){
                    try {
                        // 仓库已经空了。
                        // 消费者线程等待，释放掉list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够执行到此处说明仓库中有数据，进行消费。
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒生产者生产
                list.notifyAll();
            }
        }
    }
}