哇！Java最全面的多线程基本教程来了!

作者: Java_Evan | 来源:发表于2024-01-21 00:03 被阅读0次

程序、进程、线程的概念

程序
完成特定任务，用某个语言编写的一组指令的集合，一段静态代码，即程序就是静态对象。
进程
程序启动的一次执行过程或正在执行的程序，是一个动态的过程。就是执行程序的过程中它产生、存在和消亡的过程。即该程序进程的生命周期。

如：Windows任务管理器中正在执行的QQ、微信都是一段进程。
程序是静态的，进程是动态的。
进程作为任务管理器的单位，系统程序在运行时会为每一个进程分配不同的内存空间。

线程
进程进一步细分为线程，是程序内部中一条执行路径。
若一个进程中同一时间并行执行多个线程，就是多线程。
单线程与多线程的执行过程
线程作为CPU调度和执行的最小单位。
每个线程拥有独立的执行栈和程序计数器，线程自身切换开销小。一个进程的多个线程共享相同的内存单元/内存地址空间（同一个堆空间分配对象），它们访问相同的变量和对象，这就使得线程间通信更简便、高效，但多个线程操作共享的资源就会带来安全隐患。
红框的蓝色区域为线程独享，黄色区域为线程共享

注意：
不同的进程之间是不共享内存的。
进程之间的数据交换和通信的成本很高。

直观理解进程和线程之间的关系

在Windows系统中打开任务管理器，可以看到每个运行的程序就是一个进程。

任务管理器中的进程列表
一个应用程序的多次运行，就是多个进程

多线程

单核CPU和多核CPU的理解

单核CPU，是一种伪多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多个车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以将其"挂起"(晾着他，等他想好了，再去收费)。但是因为CPU时间单元特别短，因此感觉不出来。

多核CPU，更好的提高多线程的效率。(现在基本物理机都是多核的)

一个java应用程序java.exe,其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发的理解

并行：多个CPU同一时间点（时间单元）执行多个任务。指在同一时刻，有多条指令在多个CPU上同时执行。比如：多个人同一时间做不同的事。

多个线程的并行操作

并发：一个CPU(采用时间片)同一时间执行多个任务。即在一段时间内，有多条指令在单个CPU上快速轮换、交替执行，使得在宏观上具有多个进程同时执行的效果。比如：秒杀、多个人同一时间做同一件事。

多个线程并发操作
在操作系统中，启动了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单核 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多核 CPU 系统中，则这些可以并发执行的程序便可以分配到多个CPU上，实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

多线程的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法)，肯定比用多个线程来完成用的时间更短，为何仍需要多线程？

多线程的优点：

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率。
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

何时需要多线程？

程序同时需要两个或多个任务。
程序需要实现一些需要等待任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。

线程分类

线程分为用户线程和守护线程

当主线程(用户线程)开始运行时，守护线程自动运行；反之，用户线程结束，守护线程也同时结束。
main()主线程执行时，里面的gc垃圾回收线程，异常线程会跟着一起执行，保护整个线程生命周期的结束。
它们在几乎每个方法都是相同的，唯一区别是判断JVM何时离开。
守护线程是用来服务用户线程的，执行start()方法前调用Thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
JVM垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。
两者可以理解为：兔死狗烹，鸟尽弓藏。

线程的调度

线程的调度是指按照特定的策略为多个线程分配CPU的使用权。有两种调度策略：分时调度策略和抢占式调度策略。

分时调度模型：让所有的线程轮流获得CPU的使用权，并且平均分配每个线程占用的CPU的时间片。

分时调度策略

抢占式调度模型：优先让可运行池中优先级高的线程占用CPU，如果线程的优先级相同，就随机选择一个线程，使其占用CPU。

需要注意的是，线程的调度不是跨平台的，它不仅取决于Java虚拟机，还依赖操作系统。在某些操作系统中，只要运行中的线程没有遇到阻塞，就不会放弃CPU；还有一些操作系统，就算线程没有遇到阻塞，也会在一段时间后放弃CPU，给其他线程运行的机会

java的调度方法
- 同优先级线程组成先进先出队列(先到先服务)，使用时间片策略
- 对高优先级，使用优先调度的抢占式策略

线程的优先级

线程的优先级等级
- MAX_PRIORITY: 10 最大优先级
- MIN_PRIORITY: 1 最小优先级
- NORM_PRIORITY: 5 默认优先级
涉及的方法
- getPriority()：获取线程优先值
- setPriority(int newPriority)：设置线程的优先级

案例实操

public class ThreadTest{
    /*
    结果分析：
    从结果来看主线程优先最高所以执行顺序时，先执行主线程再执行了自定义线程一
    */
    public static void main(String[] args){
        ThreadTest01 tt = new ThreadTest01();
        //启动线程
        tt.start();
        //设置线程一最小优先级
        tt.setPriority(Thread.MIN_PRIORITY);
        //设置主线程最大优先级
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        System.out.println("主线程")；
    }   
}

//创建子类继承Thread类重写类中run()
class ThreadTest01 extends Thread{
    @Override
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println("线程一")；        
        }
    }
}

说明:
高优先级的线程要抢占低优先级线程的cpu执行权。但这只是从最大概率来说，并不是绝对的，一般高优先级的线程是在概率高的情况下被执行；这并不是意味着只有当高优先级的线程被执行完以后，低优先级的线程就会被执行;如：当某个高优先级的线程被sleep(睡眠或阻塞)时，优先级调度会失效。

多线程的创建

两种创建线程方式。

继承Thread类的方式
这是创建线程的一种方式，但需要注意的是Java不支持多继承，因此如果继承了Thread类，那么就不能再继承其他类。创建一个新线程需要重写Thread类的run()方法，然后调用start()方法启动线程。
实现Runnable接口的方式
如果你已经继承了其他类，或者希望更灵活地处理多线程（例如共享资源），那么可以通过实现Runnable接口来创建线程。这种方式天然的实现了资源共享，将线程的任务（要执行的代码）与代码运行机制（Thread类）分离开来。你需要实现Runnable接口的run()方法，然后将其传递给Thread类的构造函数，最后调用start()方法启动线程。

继承Thread类的案例实操

创建步骤：

创建一个继承Thread父类的子类；
重写Thread类的run方法 >重写在该方法的方法体是多线程运行的主体;
创建Thread类的子类的对象；
通过此对象调用start()方法，当调用此方法的时候会自动执行run()方法；
当你再次去启动一个线程，调用同个方法就会throws当前线程异常-IllegalThreadStateException，所以当你需要调用多个线程的时候，要重新创建对象，而不是一个对象执行多个线程

public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建继承Thread类的子类的对象
        MyThread myThread = new MyThread();
        //不能通过子类对象直接调用run()方法，虽然不会报错。
        //但调用此方法的线程无法执行，依然会执行主线程的main()方法
        //myThread.run();
        //通过子类对象的start()方法来启动线程执行run()方法
        myThread.start();
        //再次使用已创建的子类对象调用start()方法时，
        //会报IllegalThreadStateException(非法线程异常)，
        //当你要再次执行子类中的run()方法时，需要重新创建子类对象类调用start()方法
        //myThread.start();
        //当需要执行一个线程时，需要重新创建对象，而不是一个对象对同个线程的多次执行
        MyThread mt = new MyThread();
        mt.start();

        //当前的遍历方法仍然是在主线程main中执行
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + i + " ");
            }
        }
    }
}

//1. 创建一个继承Thread类的子类
class MyThread extends Thread{
    //2. 重写run方法
    @Override
    public void run() {
        //变量100内的偶数
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + i + " ");
            }
        }
    }
}

---------------------创建Thread类的匿名子类-----------------------
//创建Thread类的匿名子类方式
new Thread(){
    @Override
    public void run() {
        //变量100内的偶数
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + i + " ");
            }
        }
    }
}.start();

实现Runnable接口的案例实操

创建步骤：

创建一个实现了Runnable接口的实现类
实现类去实现Runnable中的抽象方法:run();
创建实体类的对象
将实体类对象作为参数传递到Thtread类中的构造器,创建Thread的对象
通过Thread类的对象调用start()开启线程，调用Runnable子类接口的run()方法

public class ThreadTest2 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread2 mt2 = new MyThread2();
        //4. 创建Thread类对象，将实现类对象作为参数传到Thread类的构造器中
        Thread t1 = new Thread(mt2);
        //设置线程名
        t1.setName("线程1");
        //通过Thread类的对象调用start()方法，然后启动线程，调用当前线程的run()，同时调用了Runnable()中的target参数
        t1.start();
        //创建Thread类对象，将实现类对象作为参数传到Thread类的构造器中
        Thread t2 = new Thread(mt2);
        t2.setName("线程2");
        t2.start();
        //创建Thread类对象，将实现类对象作为参数传到Thread类的构造器中
        Thread t3 = new Thread(mt2);
        t3.setName("线程3");
        t3.start();
        //创建匿名对象方式1
        new Thread(new MyThread2()).start();
      
        //创建匿名实现类的匿名对象
        new Thread(new Runnable{
            private int ticket = 100;
            @Override
            public void run() {
                while (true){
                    if (ticket > 0){
                        System.out.println(Thread.currentThread().getName() + "-" + ticket);
                        ticket--;
                    } else {
                        break;
                    }
                }
        }).start();
    }
}
//1. 创建实现Runnable接口的类
class MyThread2 implements Runnable{

    //实现Runnable接口天然的实现了数据共享，不需要使用static来修饰实现类的数据共享
    //因为创建实现类对象时只需要创建一次，所以通过创建多个线程来调用一个对象
    //2. 重写Runnable接口中的run()抽象方法
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName() + "-" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

对比创建线程的两种(Thread&Runnable)方式

实际开发中，创建线程Runnable方式优先级对比Thread的方式比较高,一般情况下使用实现Runnable的方式。

首先实现Runnable方式没有类的单继承局限性；更加适合处理多个线程的共享数据。
当然两者之间都有共同点和连接点，像Thread类它也实现了Runnable类的抽象方法，并且两种方式都需要重写run()方法，将线程要执行的业务逻辑都声明在run()方法中。

//两种方式的联系点 
public class Thread implements Runnable{}

说明：
Thread类实现了Runnable接口中的run()；当我们继承Thread类并实现其中的run()，相当于间接的实现了Runnable接口中的方法；所以我们可以直接去实现Runnable接口。

继承Thread类方式的解析图

实现Runnable接口方式的解析图

多线程的常用方法

start() - 启动当前线程，调用当前线程的run()
run() - 通常需要重写Thread类中的此方法，返回执行当前代码的线程
currentThread() - 静态方法return当前代码的线程
getName() - 获取当前线程的名字
setName() - 设置当前线程的名字
yield() - 释放当前cpu的执行权(通俗讲：当某个条件满足时，跳过当前线程操作之后，其它线程或当前线程交互来继续执行下一步线程操作)
join - 在线程A中调用线程B的join()时，线程A进入阻塞状态，当线程B的程序执行完时，线程A结束阻塞状态继续执行下去。
stop - 该方法在JDK1.8以后已弃用,当调用此方法时，强制结束当前线程
slepp - 让当前线程睡眠(阻塞),指定参数millitime为毫秒,当指定的线程在毫秒内，该线程是睡眠状态(1000毫秒=1秒)
isAlive() - 判断当前线程是否存活(指当前线程执行结束，完成了生命周期)

public class ThreadTest1 {
    public static void main(String[] args) {
        //构造器方式设置线程名
        MyThread1 mt1 = new MyThread1("线程");
        //调用Thread类中的setName(name)方法设置线程名
        //mt1.setName("线程一");
        mt1.start();
        //直接调用Thread类设置线程名
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);
        }
    }
}

// 创建继承Thread类的子类
class MyThread1 extends Thread{
    //创建子类带参构造器,来设置线程名
    public MyThread1(String name){
        super(name); //调用父类带参构造器
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("重写Thread类中的run()方法-" + Thread.currentThread().getName() + i);
        }
    }
}

多线程的生命周期

Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下一些状态：

JDK1.5之前：5种状态

线程的生命周期有五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

线程的生命周期

出生 -> 就绪 -> 运行 -> 堵塞 -> 消亡

JDK1.5中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新线程的对象。java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建(出生)：
当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此时它和其他Java对象一样，仅仅由JVM为其分配了内存，并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征，程序也不会执行它的线程体run()。
就绪：
但是当线程对象调用了start()方法之后，就不一样了，线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器，当然，处于这个状态中的线程并没有开始运行，只是表示已具备了运行的条件，随时可以被调度。至于什么时候被调度，取决于JVM里线程调度器的调度。

注意：
程序只能对新建状态的线程调用start()，并且只能调用一次，如果对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

运行：
如果处于就绪状态的线程获得了CPU资源时，开始执行run()方法的线程体代码，则该线程处于运行状态。如果计算机只有一个CPU核心，在任何时刻只有一个线程处于运行状态，如果计算机有多个核心，将会有多个线程并行(Parallel)执行。
当然，美好的时光总是短暂的，而且CPU讲究雨露均沾。对于抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务，当该时间用完，系统会剥夺该线程所占用的资源，让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会，而在选择下一个线程时，系统会适当考虑线程的优先级。
阻塞：当在运行过程中的线程遇到如下情况时，会让出 CPU 并临时中止自己的执行，进入阻塞状态：
- 线程调用了sleep()方法，主动放弃所占用的CPU资源；
- 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；
- 线程执行过程中，同步监视器调用了wait()，让它等待某个通知（notify）；
- 线程执行过程中，同步监视器调用了wait(time)
- 线程执行过程中，遇到了其他线程对象的加塞（join）；
- 线程被调用suspend方法被挂起（已过时，因为容易发生死锁）；

当前正在执行的线程被阻塞后，其他线程就有机会执行了。针对如上情况，当发生如下情况时会解除阻塞，让该线程重新进入就绪状态，等待线程调度器再次调度它：

线程的sleep()时间到；
线程成功获得了同步监视器；
线程等到了通知(notify)；
线程wait的时间到了
加塞的线程结束了；
被挂起的线程又被调用了resume恢复方法（已过时，因为容易发生死锁）；

死亡：线程会以以下三种方式之一结束，结束后的线程就处于死亡状态：

run()方法执行完成，线程正常结束
线程执行过程中抛出了一个未捕获的异常（Exception）或错误（Error）
直接调用该线程的stop()来结束该线程（已过时）

JDK1.5及之后：6种状态

在java.lang.Thread.State的枚举类中这样定义：

public enum State {
    //尚未启动的线程的线程状态。
    NEW,
    /*
    可运行线程的线程状态。
    处于可运行状态的线程正在Java虚拟机中执行，但它可能正在等待来自操作系统(如处理器)的其他资源。
    */
    RUNNABLE,
    /*
    等待监视器锁的线程的线程状态。
    处于阻塞状态的线程正在等待监视器锁进入同步块/方法，或者在调用Object.wait后重新进入同步块/方法。
    */
    BLOCKED,
    /*
    等待线程的线程状态。线程由于调用以下方法之一而处于等待状态:
    Object.wait with no timeout
    Thread.join with no timeout
    LockSupport.park
    处于等待状态的线程正在等待另一个线程执行特定的操作。
    例如，在一个对象上调用object. wait()的线程正在等待另一个线程在该对象上
    调用object. notify()或object. notifyall()。调用thread .join()的线程正在等待指定的线程终止。
    */
    WAITING,
    /*
    指定等待时间的等待线程的线程状态。
    线程处于定时等待状态，因为调用了以下方法之一，并指定了正等待时间:
    Thread.sleep
    Object.wait with timeout
    Thread.join with timeout
    LockSupport.parkNanos
    LockSupport.parkUntil
    */
    TIMED_WAITING,
    /*
    终止线程的线程状态。线程已完成执行。
    */
    TERMINATED;
}

NEW（新建）：线程刚被创建，但是并未启动。还没调用start方法。
RUNNABLE（可运行）：这里没有区分就绪和运行状态。因为对于Java对象来说，只能标记为可运行，至于什么时候运行，不是JVM来控制的了，是OS来进行调度的，而且时间非常短暂，因此对于Java对象的状态来说，无法区分。
Teminated（被终止）：表明此线程已经结束生命周期，终止运行。
根据Thread.State的定义，阻塞状态分为三种：BLOCKED、WAITING、TIMED_WAITING。(重点)
- BLOCKED（锁阻塞）：在API中的介绍为：一个正在阻塞、等待一个监视器锁（锁对象）的线程处于这一状态。只有获得锁对象的线程才能有执行机会。

比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

TIMED_WAITING（计时等待）：在API中的介绍为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。

当前线程执行过程中遇到Thread类的sleep或join，Object类的wait，LockSupport类的park方法，并且在调用这些方法时，设置了时间，那么当前线程会进入TIMED_WAITING，直到时间到，或被中断。

WAITING（无限等待）：在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
当前线程执行过程中遇到遇到Object类的wait，Thread类的join，LockSupport类的park方法，并且在调用这些方法时，没有指定时间，那么当前线程会进入WAITING状态，直到被唤醒。

通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒；
通过Condition的await进入WAITING状态的要有Condition的signal方法唤醒；
通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒
通过Thread类的join进入WAITING状态，只有调用join方法的线程对象结束才能让当前线程恢复；

说明：当从WAITING或TIMED_WAITING恢复到Runnable状态时，如果发现当前线程没有得到监视器锁，那么会立刻转入BLOCKED状态。

多线程的生命周期

我们在查看API的时候会发现Timed Waiting（计时等待）与 Waiting（无限等待）状态联系还是很紧密的，
比如Waiting（无限等待）状态中wait方法是空参的，而timed waiting（计时等待）中wait方法是带参的。
这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是
如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两
得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态，直到倒计时完毕自动醒来；如果在倒
计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

线程安全问题及解决

当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题。但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。

同一个资源问题和线程安全问题
场景案例：
火车站要卖票，我们模拟火车站的卖票过程。因为疫情期间，本次列车的座位共100个（即，只能出售100张火车票）。我们来模拟车站的售票窗口，实现多个窗口同时售票的过程。注意：不能出现错票、重票。

局部变量不能共享

class Window extends Thread {
    public void run() {
        int ticket = 100;
        while (ticket > 0) {
            System.out.println(getName() + "卖出一张票，票号:" + ticket);
            ticket--;
        }
    }
}

public class SaleTicketDemo1 {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

结果：发现卖出300张票。
问题：局部变量是每次调用方法都是独立的，那么每个线程的run()的ticket是独立的，不是共享数据。

不同对象的实例变量不共享

public class WindowTest02 {
    public static void main(String[] args) {
        SellTicket02 st1 = new SellTicket02("窗口1");
        SellTicket02 st2 = new SellTicket02("窗口2");
        SellTicket02 st3 = new SellTicket02("窗口3");

        st1.start();
        st2.start();
        st3.start();
    }
}

class SellTicket02 extends Thread {
    
    public SellTicket02(String name) {
        super(name);
    }

     private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + "卖票,票号:" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

结果：发现卖出300张票。
问题：不同的实例对象的实例变量是独立的。

静态变量是共享的

public class WindowTest02 {
    public static void main(String[] args) {
        SellTicket02 st1 = new SellTicket02("窗口1");
        SellTicket02 st2 = new SellTicket02("窗口2");
        SellTicket02 st3 = new SellTicket02("窗口3");

        st1.start();
        st2.start();
        st3.start();
    }
}

class SellTicket02 extends Thread {
    
    public SellTicket02(String name) {
        super(name);
    }

     private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + "卖票,票号:" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

结果：发现卖出近100张票。
问题1：但是有重复票或负数票问题。
原因：线程安全问题
问题2：如果要考虑有两场电影，各卖100张票等
原因：TicketThread类的静态变量，是所有TicketThread类的对象共享

同一个对象的实例变量共享
使用实现Runnable接口的方式，天然的共享数据。

public class WindowTest01 {
    public static void main(String[] args) {
        SellTicket01 st = new SellTicket01();

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        Thread t3 = new Thread(st);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class SellTicket01 implements Runnable {
    //票数
    int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖票,票号:" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

结果：发现卖出近100张票。
问题：但是有重复票或负数票问题。
原因：线程安全问题

抽取资源类，共享同一个资源对象

//1、编写资源类
class Ticket {
    private int ticket = 100;

    public void sale() {
        if (ticket > 0) {
            try {
                Thread.sleep(10);//加入这个，使得问题暴露的更明显
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖出一张票，票号:" + ticket);
            ticket--;
        } else {
            throw new RuntimeException("没有票了");
        }
    }

    public int getTicket() {
        return ticket;
    }
}

public class SaleTicketDemo5 {
    public static void main(String[] args) {
        //2、创建资源对象
        Ticket ticket = new Ticket();

        //3、启动多个线程操作资源类的对象
        Thread t1 = new Thread("窗口一") {
            public void run() {
                while (true) {
                    ticket.sale();
                }
            }
        };
        Thread t2 = new Thread("窗口二") {
            public void run() {
                while (true) {
                    ticket.sale();
                }
            }
        };
        Thread t3 = new Thread(new Runnable() {
            public void run() {
                ticket.sale();
            }
        }, "窗口三");


        t1.start();
        t2.start();
        t3.start();
    }
}

针对上述案例出现的问题分析
在上述案例中虽然逐步解决了数据共享的问题，但结果还是出现重票、错票的情况，这是因为多个线程在运行时，一个线程还没结束，另外一个线程进来运行，导致出现重票好错票现象，是线程安全的问题，此时需要使用线程的同步机制解决。

同步机制

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制
(synchronized)来解决。

线程同步机制
根据场景案例简述:
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。注意:在任何时候,最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。

同步机制原理

Java中的同步机制主要用于控制多个线程对共享资源的访问，以避免出现并发问题。以下是同步机制的主要作用：

防止数据不一致：当多个线程同时访问和修改共享资源时，可能会导致数据的不一致性。同步机制可以确保同一时间只有一个线程能够访问共享资源，从而保证数据的一致性。
避免资源竞争：当多个线程同时访问共享资源时，可能会引发资源竞争，导致程序出现异常。同步机制可以确保在任何时候只有一个线程能够访问共享资源，从而避免资源竞争。
保证程序的正确性：在某些情况下，程序的正确性取决于共享资源的状态。通过同步机制，可以确保在任何时候共享资源的状态都是正确的，从而保证程序的正确性。
提高程序的性能：虽然同步机制可能会降低程序的性能，但是在某些情况下，为了确保程序的正确性和数据的一致性，必须使用同步机制。通过合理的同步策略，可以在保证程序正确性的同时，提高程序的性能。

在Java中，可以通过synchronized关键字、ReentrantLock、Semaphore等方式来实现同步机制。这些机制可以有效地控制多个线程对共享资源的访问，确保程序的正确性和数据的一致性。

同步机制解决场景案例出现的问题

在没有进行同步之前，进行多线程操作，会出现重数，错数的出现，线程间有很大的安全隐患，所以这个时候需要进行同步机制来解决安全隐患。
安全隐患出现的过程：当一个线程A执行操作时，执行过程还没完成，其它线程就参与了进来，也执行了同样的操作。
解决方案：当一个线程A在执行操作的时候，其他线程不要参与进来，直到线程A执行完整个操作，下一个线程才会进来执行，这种情况下即使线程A出现了堵塞，也不能改变这个过程;所

以这个时候就需要同步机制来解决线程安全隐患。

synchronized的使用

在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
synchronized的锁是什么
同步锁对象可以是任意类型，但是必须保证竞争“同一个共享资源”的多个线程必须使用同一个“同步锁对象”。

对于同步代码块来说，同步锁对象是由程序员手动指定的（很多时候也是指定为this或类名.class），但是对于同步方法来说，同步锁对象只能是默认的：

静态方法：当前类的Class对象（类名.class）
非静态方法：this

同步操作的思考顺序
1、如何找问题，即代码是否存在线程安全？（非常重要）
（1）明确哪些代码是多线程运行的代码
（2）明确多个线程是否有共享数据
（3）明确多线程运行代码中是否有多条语句操作共享数据
2、如何解决呢？（非常重要）
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
即所有操作共享数据的这些语句都要放在同步范围中
3、切记：
范围太小：不能解决安全问题
范围太大：因为一旦某个线程抢到锁，其他线程就只能等待，所以范围太大，效率会降低，不能合理利用CPU资源。

案例实操

同步方法方式
当操作共享数据的代码完整的声明在一个方法体中，此时可以将整个方法同步。
同步方法中的同步监视器(锁)不显式的声明,默认是this(当前类对象)。
非静态的同步方法，同步监视器是this。
静态的同步方法，同步监视器是当前类(xxx.class)。

示例1：静态同步方法，继承Thread类

public class WindowTest03 {
    public static void main(String[] args) {
        Window01 w1 = new Window01("窗口1");
        Window01 w2 = new Window01("窗口2");
        Window01 w3 = new Window01("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window01 extends Thread {
    public Window01(String name) {
        super(name);
    }

    private static int ticket = 100;

    @Override
    public void run() {//直接锁这里，肯定不行，会导致，只有一个窗口卖票
        while (ticket > 0) {
            saleOneTicket();
        }
    }

    //静态方法同步加锁
    public static synchronized void saleOneTicket() {//静态同步监视器默认是当前类本身，即WindowTest03.class
        //不加条件，相当于条件判断没有进入锁管控，线程安全问题就没有解决
        if (ticket > 0) {
            try {
                Thread.sleep(10); //加阻塞时间，更直观的看多个窗口卖票
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖了一张票,票号:" + ticket);
            ticket--;
        }
    }
}

示例2：非静态同步方法，实现Runnable接口

public class WindowTest04 {
    public static void main(String[] args) {
        Window2 w1 = new Window2();
        Thread t1 = new Thread(w1, "窗口1");
        Thread t2 = new Thread(w1, "窗口2");
        Thread t3 = new Thread(w1, "窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window2 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (ticket > 0) {
            saleOneTicket();
        }
    }

    public synchronized void saleOneTicket() { //非静态同步方法默认同步监视器是this
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖了一张票,票号:" + ticket);
            ticket--;
        }
    }
}

同步代码块方式
① 操作共享数据的代码，即为需要被同步的代码。
② 同步监视器，俗称：锁，任何一个类的对象都可以作为同步监视器。

要求：多个线程共享同一把锁，保证锁的唯一性。

③ 继承Thread类的多线程方式尽量使用顶级父类Object作为同步监视器
④ 实现Runnable接口的多线程方式可使用this作为同步监视器，也可以使用任意类的对象，保持唯一性即可

示例1：使用同步代码块实现Runnable接口

public class WindowTest01 {
    public static void main(String[] args) {
        SellTicket01 st = new SellTicket01();

        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class SellTicket01 implements Runnable {
    //票数
    int ticket = 100;
    //创建顶级父类作为同步监视器
    //private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            //被同步的代码块
            //synchronized (obj){
            synchronized (this) { //此时的this表示唯一的当前类(Window)的对象
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖票,票号:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

示例2：使用同步代码块继承Thread类的方式

public class WindowTest02 {
    public static void main(String[] args) {
        SellTicket02 st1 = new SellTicket02("窗口1");
        SellTicket02 st2 = new SellTicket02("窗口2");
        SellTicket02 st3 = new SellTicket02("窗口3");

        st1.start();
        st2.start();
        st3.start();
    }
}

class SellTicket02 extends Thread {

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

     //数据共享
    private static int ticket = 100;

     //声明静态顶级父类对象作为唯一的同步监视器
    private static final Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            //synchronized (this) { //this此时创建了三个对象：st1、st2、st3,不能保证锁的唯一性
            //synchronized (obj) { //使用static修饰后，保证锁的唯一性
          
            synchronized (SellTicket02.class) { //通过反射获取当前类，保证锁的唯一性
                if (ticket > 0) {
                    try {
                        sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + "卖票,票号:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

Lock锁的使用

JDK1.5新特性，java提供了更强大的线程同步机制；通过显式定义同步锁对象来实现同步。

同步锁使用Lock对象充当。

Lock锁的主要用途是在多线程编程中提供同步机制，以避免线程之间的竞争条件和互斥访问。Lock锁的作用具体包括以下几点：

提供互斥访问：Lock锁提供了互斥访问的机制，只有一个线程可以持有锁，并访问被保护的代码段。
提供可重入性：与synchronized不同，Lock锁提供了可重入性，即同一个线程可以多次获得锁，而不会出现死锁。
提供条件变量：Lock锁提供了Condition条件变量，可以使用它来实现线程之间的协调和通信。
提供公平性：Lock锁提供了公平性机制，可以通过构造器参数控制锁的获取顺序，从而避免线程饥饿现象。
控制线程等待：Lock锁提供了Condition接口，可以用于控制线程等待和唤醒。通过调用Condition接口的await()方法将线程挂起，等待条件满足后再被唤醒。
限时等待：Lock锁可以指定线程等待的时间，在超时后自动唤醒线程。
可中断等待：Lock锁可以响应线程中断请求，在等待锁的过程中可以被中断。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能一个线程对Lock对象加锁，线程开始访问共享资源之前应先获取Lock对象。
ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显式加锁、释放锁。

public class LockTest {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window3 implements Runnable {

    private int ticket = 100;

    //创建lock对象，需要确保多个线程共用同一个Lock对象
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //调用lock锁方法，锁定同步资源的调用
                lock.lock();
                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖票,票号:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                //调用unlock解锁方法
                lock.unlock();
            }

        }
    }
}

synchronized与lock的异同

相同点：两者都可以解决线程安全问题。

不同点：
synchronized机制在执行完相应的同步代码以后，自动释放同步监视器。
lock需要手动的启动同步(lock()),同时也需要手动解锁(unlock())。

synchronized与lock的对比

Lock是显式锁(需要手动启动和关闭锁)，synchronized是隐式锁，出了同步资源自动释放锁。
Lock只有代码块锁，synchronized有代码块锁和方法锁。
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)。

开发经验：优先使用顺序
Lock->同步代码块(已经进入到方法体，分配了相应资源)->同步方法(在方法体外)

Semaphore的使用

Semaphore是一个计数信号量，可以用来控制对共享资源的访问。你可以使用Semaphore.acquire()方法获取许可，并使用Semaphore.release()方法释放许可。这样可以确保在任何时候都有一定数量的线程能够访问共享资源，从而避免重数问题。

public class SemaphoreTest {
    public static void main(String[] args) {

        Window window = new Window5();

        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {
    private int ticket = 100;

    //创建信号量对象，并设置每次一个线程访问共享资源
    private final Semaphore semaphore = new Semaphore(1);

    @Override
    public void run() {
        while (true) {
            try {
                //获取许可
                semaphore.acquire();
                if (ticket > 0) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "卖票，票号:" + ticket);
                    ticket--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //释放许可，允许其它线程访问共享资源
                semaphore.release();
            }
        }
    }
}

lock和semaphore的异同

Java中的Lock和Semaphore都是用于控制多线程对共享资源访问的工具，但它们有一些不同之处。

相同点：

两者都可以控制多个线程对共享资源的访问，避免并发问题。
两者都提供了获取和释放锁或许可的方法，以确保在访问共享资源之前获取锁或许可，并在访问完成后释放锁或许可。

不同点：

Lock是一个接口，而Semaphore是一个类。
Lock提供了更灵活的锁控制，它提供了多种获取锁和释放锁的方法，如tryLock()、tryLock(long timeout, TimeUnit unit)等。而Semaphore则提供了更简单的许可控制，它只提供了获取许可和释放许可的方法。
Lock不支持公平锁和非公平锁的切换，而Semaphore则可以通过构造函数设置是否为公平锁。
Lock没有提供等待可用的线程数量或等待时间的方法，而Semaphore则提供了这些方法。
Lock通常用于控制对共享资源的访问，而Semaphore则通常用于控制对共享资源的访问数量。

总之，选择使用Lock还是Semaphore取决于你的具体需求。如果你需要更灵活的锁控制，可以选择使用Lock；如果你需要更简单的许可控制，可以选择使用Semaphore。

线程的死锁

线程的同步机制引起的死锁问题。

死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

线程死锁问题

【小故事】
面试官：你能解释清楚什么是死锁，我就录取你！
面试者：你录取我，我就告诉你什么是死锁！
….
恭喜你，面试通过了

一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

案例实操

public class DeadLockTest {
    public static void main(String[] args) {

        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();

        new Thread() {
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");
                    
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);

                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);

                    }

                }
            }
        }.start();

    }
}

诱发死锁的原因：

互斥条件
占用且等待
不可抢夺（或不可抢占）
循环等待

以上4个条件，同时出现就会触发死锁。
解决死锁：
死锁一旦出现，基本很难人为干预，只能尽量规避。可以考虑打破上面的诱发条件。
针对条件1：互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。
针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。
针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放掉已经占用的资源。
针对条件4：可以将资源改为线性顺序。申请资源时，先申请序号较小的，这样避免循环等待问题。

public class ThreadTest {
    public static void main(String[] args) {
        //同步监视器s1
        StringBuffer s1 = new StringBuffer();
        //同步监视器2
        StringBuffer s2 = new StringBuffer();

        //继承Thread类的匿名方法
        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("c");
                    //线程进入阻塞，通过死锁的概率
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("d");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        //实现Runnable接口的匿名方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("e");
                    s2.append("f");
                    //线程进入阻塞，通过死锁的概率
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("s");
                        s2.append("x");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

线程的通信

为什么要处理线程间通信：

当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—等待唤醒机制。

等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。

在一个线程满足某个条件时，就进入等待状态（wait() / wait(time)），等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
线程通信的三个方法：

wait() - 一旦执行此方法，当前线程就进入到堵塞状态，并释放同步监视器。
线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
notify() - 一旦执行此方法，就会唤醒被wait的一个线程；如果有多个线程被wait,就唤醒优先级高的那个线程。
否则选取所通知对象的 wait set 中的一个线程释放；
notifyAll() - 一旦执行此方法,就会唤醒所有被wait的线程。
否则释放所通知对象的 wait set 上的全部线程。

注意：
被通知的线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下：

如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运>行）状态；

否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁）状态

说明：
三个方法必须使用在同步代码块或同步方法中。
三个方法的调用者必须是同步代码块或同步方法当中的同步监视器，否则会报异常IllegalMonitorStateException。
三个方法都是定义在java.lang.Object类中。

案例实操

场景：线程通信的实现：使用两个线程交替打印1-100

/**
 * 线程通信的实现：使用两个线程交替打印1-100
 * 线程通信的三个方法：
 *    wait():一旦执行此方法，当前线程会进入到堵塞状态，并释放同步监视器。
 *    notify():一旦执行此方法，就会唤醒被wait的一个线程；
               如果被wait多个线程，会唤醒优先级高的那个线程；
               如果线程优先级相同则随机唤醒
 *    notifyAll():一旦执行此方法，就会唤醒被wait的所有线程。
 *
 * 说明：wait()、notify()、notifyAll()的三个方法必须使用在同步代码块或同步方法当中，
 *      同时它们三者的调用者必须是同步代码块或同步方法当中的同步监视器,否则会报异常IllegalMonitorStateException。
          wait()、notify()、notifyAll()的三个方法同时定义在java.lang.Object
 *
 */
public class NumberTest {
    public static void main(String[] args) {
        Number number = new Number();

        Thread t1 = new Thread(number, "线程1");
        Thread t2 = new Thread(number, "线程2");

        t1.start();
        t2.start();
    }
}

class Number implements Runnable {

    private int num = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                this.notify();//唤醒被wait的线程
                if (num <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "打印:" + num );
                    num++;
                    try {
                        this.wait(); //线程执行此方法，进入等待状态，会同时释放同步监视器的调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

sleep() 与 wait() 的异同

相同点：一旦执行此方法，都可以进入到堵塞状态
不同点：
两个方法声明位置不同；sleep()在Thread类，wait()在Object类。

调用方法的位置不同，sleep()可以在任何执行线程场景下出现，wait()只能出现在同步代码块或同步方法当中。

关于是否释放同步监视器，如果两个方法都是用在同步代码块或同步方法当中，sleep()不会释放锁，wait()会自动释放锁。

综合案例：生产者/消费者问题

生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店内有空位放产品了再通知生产者继续生产，如果店内没有产品了，店员会通知消费者等一下，如果店内有产品了再通知消费者来取走产品。
这里可能会出现两个问题：
- 生产者比消费者快时，消费者会漏掉一些数据没有取走。
- 消费者比生产者快时，消费者会取相同的数据。

/**
 *
 *
 * 生产者将产品交给店员，而消费者从店员处取走产品，
 * 店员一次只能持有固定的产品数量，如果生产者试图生产更多的产品，店员会叫生产者停一下，
 * 如果店内有空位可以放置产品再通知生产者继续生产，如果店内没有产品了，店员会告诉消费者
 * 等一下，如果店内有产品了再通知消费者过来取走产品
 *
 * 分析：
 *    是否多线程的问题？是，生产者和消费者两个线程
 *    是否有线程安全问题(是否有共享数据)？是，店内产品
 *    如何解决线程安全问题？同步机制(synchronized和lock),三个方法(同步代码块、同步方法和lock)
 *    是否涉及到线程通信问题？是
 *
 *
 * @author Evan
 * @description 线程通信的经典使用场景案例
 * @createTime 2023-04-07 17:24
 */
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Thread productThread = new Thread(new Product(clerk));
        productThread.setName("生产者");

        Thread consumerThread = new Thread(new Consumer(clerk));
        consumerThread.setName("消费者");

        productThread.start();
        consumerThread.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 consumeProduct() {
        if (productCount > 0){
            System.out.println(Thread.currentThread().getName() + "开始消费第" + productCount + "个产品");
            productCount--;
            notify();
        } else {
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class Product implements Runnable{  //生产者

    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "，开始生产产品......");
        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.produceProduct();
        }
    }
}

class Consumer implements Runnable{

    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "，开始消费产品......");
        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.consumeProduct();
        }
    }
}

哇！Java最全面的多线程基本教程来了!

程序、进程、线程的概念

直观理解进程和线程之间的关系

单核CPU和多核CPU的理解

并行与并发的理解

多线程的优点

线程分类

线程的调度

线程的优先级

案例实操

多线程的创建

继承Thread类的案例实操

实现Runnable接口的案例实操

对比创建线程的两种(Thread&Runnable)方式

多线程的常用方法

多线程的生命周期

JDK1.5之前：5种状态

JDK1.5及之后：6种状态

线程安全问题及解决

同步机制

同步机制原理

synchronized的使用

案例实操

Lock锁的使用

synchronized与lock的异同

synchronized与lock的对比

Semaphore的使用

lock和semaphore的异同

线程的死锁

案例实操

线程的通信

案例实操

sleep() 与 wait() 的异同

综合案例：生产者/消费者问题

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

知识库