【Java】多线程

在进行多线程的内容之前我们需要首先了解涉及操作系统的几个知识点。

一、程序、进程、线程

1. 程序(program)

概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

2. 进程(process)

概念：程序的一次执行过程，或是正在运行的一个程序。
说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

3. 线程(thread)

概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。
说明：线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(PC)，线程切换的开销小。

内存结构：

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

二、并行与并发

1. 单核CPU与多核CPU

• 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。涉及到CPU处理线程的方式，CPU在单位时间内（也就是说一个时间片内）只能处理一个线程，于是就将其他的线程设置为阻塞状态，加入到阻塞队列中，等到处理完成当前线程后从就绪队列中取出新的线程进行处理，由于切换和处理时间很快用户感知不到于是用户便认为CPU在同一时间内处理多个线程。
• 多核CPU，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
• 一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

2. 并行与并发的理解

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事、一个人轮流做多件事

为什么要使用多线程？

当我们在进行商品抢购的时候，在支付按钮上总是有个计时器在进行倒计时，但是我们此时仍然可以进行商品信息的查看，这个计时器和我们浏览商品信息的线程是同时进行的，这样也就实现了抢购场景，增加了用户的体验。

多线程程序的优点：

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

应用的场景

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

三、Thread类

Java语言的JVM允许程序运行多个线程，它通过 java.lang.Thread类来体现

1. Thread类的特性

每个线程都是通过某个特定 Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
通过该 Thread对象的 start()方法来启动这个线程，而非直接调用run()

2. 构造器：

• Thread()：创建新的 Thread对象
• Thread(String threadName)：创建线程并指定线程实例名
• Thread(Runnable target)：指定创建线程的目标对象，它实现了 Runnable接口中的run()方法
• Thread(Runnable target, String name)：创建新的 Thread对象

3.创建多线程的两种方式

3.1. 方式一继承Thread类的方式：

继承Thread类，使我们的类变成线程子类，拥有线程的功能，可作为线程运行。

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过此对象调用start()：①启动当前线程 ②调用当前线程的run()

注意点：

1. 我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。
   如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()。
2. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式
3. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
4. 想要启动多线程，必须调用 start()方法。
5. 一个线程对象只能调用一次 start()方法启动，如果重复调用了，则将抛出异常“IllegalThreadStateException”.

代码示例

//1.继承Thread类
class MyThread extends Thread {
    public MyThread() {
    }

    //2.重run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3.新建Thread对象
        MyThread myThread = new MyThread();
        //4.调用start方法
        myThread.start();
    }
}

3.2. 方式二实现Runnable接口的方式：

实现Runnable接口，使我们的类变成可运行的类，将我们这个可运行的类交给线程去运行即可。

1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()

代码示例：

//1. 创建一个实现了Runnable接口的类
public class RunnableTest implements Runnable {
    // 2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

class test {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        RunnableTest runnableTest = new RunnableTest();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(runnableTest);
        //5. 通过Thread类的对象调用start()
        thread.start();

    }
}

两种方式的对比：

开发中优先选择：实现Runnable接口的方式

原因：

1. 实现的方式没有类的单继承性的局限性

2. 实现的方式更适合来处理多个线程共享数据的情况。

联系：public class Thread implements Runnable

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。 目前两种方式，要想启动线程，都是调用的Thread类中的start()。

也可以采用创建匿名类的方式

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

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

        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();


    }
}

4.Thread类的常用方法

4.1 常用方法：

1. start()：启动当前线程；调用当前线程的run()（让run()交替执行），只有Thread类和他的子类才能调用start()方法

2. run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

3. currentThread()：静态方法，返回执行当前代码的线程

4. getName()：获取当前线程的名字

5. setName()：设置当前线程的名字

6. yield()：释放当前cpu的执行权

7. join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

8. stop()：已过时。当执行此方法时，强制结束当前线程。

9. sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。

10. isAlive()：判断当前线程是否存活

4.2 线程的优先级：

• MAX_PRIORITY：10
• MIN _PRIORITY：1
• NORM_PRIORITY：5 -->默认优先级

获取和设置当前线程的优先级：

• getPriority()：获取线程的优先级

• setPriority(int p)：设置线程的优先级

说明：高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

线程通信：wait() / notify() / notifyAll()：此三个方法定义在Object类中的。

线程的分类

• 守护线程，如：垃圾回收线程，依赖于主线程而存在
• 用户线程，如：main方法的线程

5.Thread的生命周期

线程的五种状态：

• 新建：当一个 Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
• 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
• 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能
• 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
• 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

说明：

1. 生命周期关注两个概念：状态、相应的方法

2. 关注：状态a-->状态b：哪些方法执行了（回调方法） 某个方法主动调用：状态a-->状态b

3. 阻塞：临时状态，不可以作为最终状态

4. 死亡：最终状态。

四、线程的同步机制

异步、同步、阻塞、非阻塞

在讲同步锁之前，我心里其实一直有一个疑问，为什么要叫同步锁？叫互斥锁代表线程互斥只有一个能执行不好吗？？

所以我搜了搜英文原版的解释：
Synchronized may refer to:
synchronization (US) or synchronisation (UK), the coordination of events to operate a system in unison
Synchronized (album), a 2002 album by sHeavy
synchronized, an Objective-C, D and Java keyword denoting a block of code subject to a mutual exclusion algorithm

可以看到the coordination of events to operate a system in unison这句话，它的意思是协调事件以统一操作系统，大师我悟了！这不就是我们同步锁的目的吗，我们需要协调事件，来达到统一，构成同步！

那这是不是意味着我们也明白了异步的含义，即 不需要协调事件以统一操作系统，英文原版解释the occurrence of events independent of the main program flow, and ways to deal with such events，即 事件的发生与主程序流程以及处理此类事件的方法无关。

---

那么我们就能弄明白同步与异步、阻塞与非阻塞了

• 同步：我需要协调事件以统一操作系统，所以每次请求我都要等着协调，留意等着返回值，再来进行协调。（同步关注请求的返回）
  • 阻塞：等着请求的时候，我不做任何事情，就硬在这里堵着，硬等着返回值，再来进行协调。
  • 非阻塞：等着请求的时候，我去做点别的事，但是我会时不时来轮询一下，看一看有没有返回值过来，有返回值再来进行协调。
• 异步：我又不需要协调事件以统一操作系统，所以我发完请求我就去做别的事了，不管他了，请求成功了他记得告诉我一声就行，我不会再留意他了。（异步不关注请求的返回）

异步

异步就是异步
网上有许多I/O模型的相关文章，主要涉及四个概念：同步(synchronous)，异步(asynchronous)，阻塞(blocking)和非阻塞(non-blocking)。有些文章将这四个作了两两组合，于是有了：异步阻塞和异步非阻塞，可以很明确地说，这完全是牵强之理解。无论是《Unix网络编程》一书中所列的I/O模式，还是POSIX标准，都没有提这两个概念。异步就是异步！只有同步时才有阻塞和非阻塞之分。

异步
异步可以说是I/O最理想的模型：CPU的原则是，有必要的时候才会参与，既不浪费，也不怠慢。
理想中的异步I/O：Application无需等待socke数据（也正是因此进程而被“休息”），也无需copy socket data，将由其它的同学（理想状态，不是CPU）负责将socket data copy到Appliation事先指定的内存后，通知一声Appliation(一般是回调函数)。
copy socket data，Application是不用做了，但事情总是需要做，不管是谁做，CPU是否还是要花费精力去参与呢？
可以用“内存映射”以及DMA等方式来达到“不用CPU去参与繁重的工作”的目的。“内存映射”是不用copy，而DMA是有其它芯片来代替CPU处理。

同步

同步和异步针对应用程序来，关注的是程序中间的协作关系；阻塞与非阻塞更关注的是单个进程的执行状态。

• 同步：执行一个操作之后，等待结果，然后才继续执行后续的操作。

• 异步：执行一个操作后，可以去执行其他的操作，然后等待通知再回来执行刚才没执行完的操作。

• 阻塞：进程给CPU传达一个任务之后，一直等待CPU处理完成，然后才执行后面的操作。

• 非阻塞：进程给CPU传达任务后，继续处理后续的操作，隔断时间再来询问之前的操作是否完成。这样的过程其实也叫轮询。

阻塞和非阻塞

我们说阻塞和非阻塞时，要区分场合范围，比如Linux中说的非阻塞I/O和Java的NIO1.0中的非阻塞I/O不是相同的概念。

从最根本来说，阻塞就是进程“被”休息，CPU处理其它进程去了。

非阻塞可以理解成：将大的整片时间的阻塞分成N多的小的阻塞，所以进程不断地有机会“被”CPU光顾，理论上可以做点其它事。

看上去Linux非阻塞I/O要比阻塞好，但CPU会很大机率因socket没数据而空转。虽然这个进程是爽了，但是从整个机器的效率来说，浪费更大了! Java NIO 1.0中的非阻塞I/O中的Selector.select()函数还是阻塞的，所以不会有无谓的CPU浪费。

Java NIO 1.0，与其说是非阻塞I/O，还不如说是多路复用I/O，更好让人理解！

总结

好，上面的可能有点抽象。下面用通俗点的语言来总结一下阻塞、非阻塞、同步、异步：

阻塞、非阻塞：进程/线程要访问的数据是否就绪，进程/线程是否需要等待；
同步、异步：访问数据的方式，同步需要主动读写数据，在读写数据的过程中还是会阻塞；
异步只需要I/O操作完成的通知，并不主动读写数据，由操作系统内核完成数据的读写。

再举个网上流传的,非常容易理解的例子：
老张爱喝茶，废话不多说，煮开水。
出场人物：老张，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。

• 1.老张把水壶放到火上，立等水开（站在水壶跟前等着水烧开）。（同步阻塞）老张觉得自己有点傻
• 2.老张把水壶放到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）
• 老张还是觉得自己有点傻，于是变高端了，买了把会响笛的那种水壶。水开之后，能大声发出嘀~~~的噪音。
• 3.老张把响水壶放到火上，立等水开。（异步阻塞）老张觉得这样傻等意义不大
• 4.老张把响水壶放到火上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）老张觉得自己聪明了。

所谓同步、异步，只是对于水壶而言。普通水壶，同步；响水壶，异步。虽然都能干活，但响水壶可以在自己完工之后，提示老张水开了。这是普通水壶所不能及的。
同步只能让调用者去轮询自己（情况2中），造成老张效率的低下。

所谓阻塞、非阻塞，仅仅对于老张而言。立等的老张，阻塞；看电视的老张，非阻塞。情况1和情况3中老张就是阻塞的，媳妇喊他都不知道。
虽然3中响水壶是异步的，可对于立等的老张没有太大的意义。所以一般异步是配合非阻塞使用的，这样才能发挥异步的效用。

阻塞、非阻塞、多路I/O复用，都是同步I/O，异步必定是非阻塞的，所以不存在异步阻塞和异步非阻塞的说法。真正的异步I/O需要CPU的深度参与。换句话说，只有用户线程在操作I/O的时候根本不去考虑I/O的执行全部都交给CPU去完成，而自己只等待一个完成信号的时候，才是真正的异步I/O。所以，拉一个子线程去轮询、去死循环，或者使用select、poll、epool，都不是异步。

1.背景

例子：创建个窗口卖票，总票数为100张.使用实现Runnable接口的方式

• 问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
• 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
• 如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

2.Java解决方案：同步机制

在Java中，我们通过同步机制，来解决线程的安全问题。

同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

理解：同步监视器（锁）其实也就只是起到一个标识作用（标识占用状态），如果填入一个对象，那么就代表这个对象作为锁标识了一个占用状态，这个对象锁已经被标识占用了，其他线程如果是一样的锁，那就要等等。也就是说，一个同步代码块在执行之前，先要看看它的锁是不是已经标识了一个占用状态（代表正在使用、占用），协调成一次只能被一个线程使用、占用（即 锁住了，在用）。
这里要注意，并不是说我们真的就用了这个对象把同步代码块给锁住了，不是说对象也正在被我们使用当一个锁，对象不能用了，并不是这样的。
这里不能望文生义，不能理解成一把锁，锁住了一个门，门被占用了打不开，锁我们也正在使用，不能用了。这里的锁，仅仅只是标识，表示占用，不影响对象的使用。

我认为系统内部可能有一个锁标识列表，把正在标识中、正在占用、正在使用的锁放进去，起到标识作用，如果其他线程是同样的锁，那他就要等一等，等这个标识释放，才能把自己的锁放进去表示占用。

类比：假设多个厕所共用一把锁，我们只有锁住了门synchronized()才能占用厕所、使用厕所{使用代码块}，不然厕所门大开，你上厕所试试？
{同步代码块} = 厕所
(对象) = 厕所的门锁，起一个标识的作用，代表有人了、正在占用
synchronized同步锁 = 厕所锁门，正在占用
对象就是一个锁，只允许一个线程获取，占用时锁住{同步代码块}；
厕所就是锁门的作用对象，只允许一个人进入使用，使用时锁住。
synchronized()就是使用对象锁住了、占用了{同步代码块}，再在大括号里执行{同步代码块}。

特别注意：这里需要特别注意，对象只是充当一个锁的标识作用，代表有人了，而真正锁住占用的是{同步代码块}。
所以说，当一个线程进入一个对象的一个 synchronized 方法，获取到改对象作为锁后，其它线程还是可以进入此对象的其它非同步的普通方法的，因为锁住的只有那段{同步代码块}，而不是我们的对象被锁住了，我们的对象只是充当一个标识锁作用，其他非同步的普通方法是不需要锁就可以进入的。
不要以为我们将这个对象作为锁，锁住了{同步代码块}，我们就把这个对象占用住了，我们就不能使用这个对象了，我们的对象只是友情客串，起到一个标识的作用，并没有真正的使用、占用这个对象。
而这个锁是谁、内容是什么并不重要，重要的是我们使用它标识了占用状态，表示有人在用。在使用结束后释放掉它，等待下一个人占用。
也就是说，锁的内容是什么并不重要，你可以不放对象，只要是你放入的那个值能够充当标识，来将线程分开即可。
关于这个问题，大家可以去了解一下我在Redis中写过的《Redis的分布式锁》，Redis里面的锁就是一个字符串而已，充当标识，表示有人在用。

2.1方式一：同步代码块

官方：

synchronized(同步监视器){//同步监视器就是需要同步线程的公共对象（即 作用域，同步作用于的对象，被锁住的对象）
   //需要被同步的代码
    
}

我的：

synchronized(被锁住的对象) {//同步监视器就是需要同步线程的公共对象（即 作用域，同步作用于的对象，被锁住的对象）
   // 锁住、占用对象之后，开始使用对象的代码块
    
}

说明：

1. 操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。

2. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。

3. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

理解：同步监视器（锁）其实也就只是起到一个标识作用，标识占用状态，如果填入一个对象，那么就代表这个对象作为锁标识了一个占用状态。也就是说，一个同步代码块在执行之前，先要看看它的锁是不是已经标识了一个占用状态（代表正在使用、占用），协调成一次只能被一个线程使用、占用（即 锁住了，在用）。
我认为系统内部可能有一个锁标识列表，把正在标识中、正在占用、正在使用的锁放进去，起到标识作用，如果其他线程是同样的锁，那他就要等一等，等这个标识释放，才能把自己的锁放进去表示占用。

4. 要求多个线程必须要共用同一把锁。不然就互不打扰，没办法同步。

• 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

• 在继承Thread类创建多线程的方式中，慎用this（可能对象不唯一，导致线程不是共用一把锁）充当同步监视器，考虑使用当前类（当前类唯一）充当同步监视器。

代码示例：

继承Runnable接口形式同步代码块

public class Ticket implements Runnable {
    private int tick = 100;

    @Override
    public void run() {

        while (true) {
            synchronized (this) {
                if (tick > 0) {
                    System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为：" + tick--);
                } else {
                    break;
                }
            }
        }
    }
}

class TicketTest {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}

继承Thread类形式同步代码块

public class Ticket2 extends Thread {
    private static int tick = 100;
    private static Object object = new Object();

    public Ticket2() {
    }

    @Override
    public void run() {

        while (true) {
            //synchronized (object) {
            synchronized (Ticket2.class) {//通过反射调用当前类
                if (tick > 0) {
                    System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为" + tick--);
                } else {
                    break;
                }
            }

        }
    }
}

class TicketTest2 {
    public static void main(String[] args) {
        Ticket2 ticket1 = new Ticket2();
        Ticket2 ticket2 = new Ticket2();
        Ticket2 ticket3 = new Ticket2();

        ticket1.setName("窗口1");
        ticket2.setName("窗口2");
        ticket3.setName("窗口3");

        ticket1.start();
        ticket2.start();
        ticket3.start();


    }
}

2.2 方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

public synchronized void show(String namer){
    ....
}

代码示例：

public class Ticket3 implements Runnable {
    private int tick = 100;
    private boolean isFlag = true;

    @Override
    public void run() {
        while (isFlag) {
            show();

        }
    }

    public synchronized void show() {//同步show方法，继承Thread类方法一样，只需同步方法即可，同时需要给方法加static关键字，确保不会创建多个对象
        if (tick > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "号窗口买票，票号为：" + tick--);
        } else {
            isFlag = false;
        }
    }
}

class TicketTest3 {
    public static void main(String[] args) {
        Ticket3 ticket = new Ticket3();

        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}

2.3 方式三：Lock锁 --- JDK 5.0新增

• 从JDK 5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
• ReentrantLock类实现了Lock，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 Reentrantlock，可以显式加锁、释放锁。

class A {
    //1.实例化ReentrantLock对象
    private final ReentrantLock lock = new ReentrantLook();
    public void m (){
        lock.lock;//2.先加锁
        try{
            //保证线程同步的代码
        }finally{
            lock.unlock();//3.后解锁
        }
    }
}

//注意：如果同步代码块有异常，要将unlock()写入finally语句块中

代码示例：

class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{

                //2.调用锁定方法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 {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }

        }
    }
}

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

        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();
    }
}

3.同步方法的总结：

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

synchronized的锁是什么：

1. 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）
2. 同步方法的锁：静态方法（类名.class）、非静态方法（this）
3. 同步代码块：自己指定，很多时候也是指定为this或类名.class

注意点：

1. 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
2. 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块自己指定使用的锁，很多时候也是指定为this或类名.class（指定需谨慎，以免有线程安全问题）。
3. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
4. 非静态的同步方法，同步监视器是：this
5. 静态的同步方法，同步监视器是：当前类本身（类名.class）

4.同步的范围：

如何找问题，即代码是否存在线程安全？（非常重要）

（1）明确哪些代码是多线程运行的代码

（2）明确多个线程是否有共享数据

（3）明确多线程运行代码中是否有多条语句操作共享数据

如何解决呢？（非常重要）

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。 即所有操作共享数据的这些语句都要放在同步范围中

注意点：

范围太小：没锁住所有有安全问题的代码
范围太大：没发挥多线程的功能。

5. 面试题：

1. synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）

使用的优先顺序：

Lock---> 同步代码块（已经进入了方法体，分配了相应资源 ) --->同步方法（在方法体之外)

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

2. Java是如何解决线程安全问题的，有几种方式？并对比几种方式的不同

利用同步锁的方式，有三种方式同步代码块、同步方法和用lock方法

3. synchronized和Lock方式解决线程安全问题的对比

相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

6.死锁问题

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

2. 说明：

• 出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续

• 我们使用同步时，要避免出现死锁。

死锁举例：

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 {
                    Thread.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(new Runnable() {
        @Override
        public void run() {
            synchronized (s2){

                s1.append("c");
                s2.append("3");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (s1){
                    s1.append("d");
                    s2.append("4");

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

}

科普：Redis的分布式锁

在代码中使用分布式锁

使用 当前请求的 UUID + 线程名 作为分布式锁的 value，执行 stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value) 方法尝试抢占锁，如果抢占失败，则返回值为 false；如果抢占成功，则返回值为 true。最后记得调用 stringRedisTemplate.delete(REDIS_LOCK_KEY) 方法释放分布式锁

/**
 * @ClassName GoodController
 * @Description TODO
 * @Author Oneby
 * @Date 2021/2/2 18:59
 * @Version 2.0
 */
@RestController
public class GoodController {

    private static final String REDIS_LOCK_KEY = "lockNemo";

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/buy_goods")
    public String buy_Goods() {
        // 当前请求的 UUID + 线程名
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
        // setIfAbsent() 就相当于 setnx，如果不存在就新建锁
        Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value);

        // 抢锁失败
        if(lockFlag == false){
            return "抢锁失败 o(╥﹏╥)o";
        }

        // 从 redis 中获取商品的剩余数量
        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.parseInt(result);
        String retStr = null;

        // 商品数量大于零才能出售
        if (goodsNumber > 0) {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
            retStr = "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
        } else {
            retStr = "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
        }
        System.out.println(retStr);
        stringRedisTemplate.delete(REDIS_LOCK_KEY); // 释放分布式锁
        return retStr;
    }

}

在上面的代码中可以看到，Redis的string变量名为REDIS_LOCK_KEY，其值为当前请求的 UUID + 线程名。

小伙伴们可以看到，string变量名REDIS_LOCK_KEY属于锁的标识位，而其值当前请求的 UUID + 线程名才是属于一个锁，而这个锁是谁、内容是什么并不重要，重要的是我们使用它标识了占用状态，表示有人在用。在使用结束后释放掉它，等待下一个人占用。

总结：redis用来作为分布式锁，其实就是设置一个字段来作为锁的标识。如果加入成功，那就代表抢到锁了；如果加入失败，那就代表有人在用，没抢到；用完锁就把字段删除，给其他线程加入锁。

五、线程通讯

为了解决线程的死锁问题，引入线程通讯

1. 线程通信涉及到的三个方法：

• wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
• notify()：一旦执行此方法，就会唤醒被wait()的一个线程。如果有多个线程被wait()，就唤醒优先级高的那个。
• notifyAll()：一旦执行此方法，就会唤醒所有被wait()的线程。

2.说明：

• wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。

• wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
  否则，会出现IllegalMonitorStateException异常

• wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

代码示例：

使用两个线程打印 1-100，线程1，线程2 交替打印。

class MyThread implements Runnable {
    private int number = 1;
    private Object object = new Object();

    @Override
    public void run() {
        while (true) {

            synchronized (object) {
                object.notify();//调用notify()方法唤醒线程
                if (number <= 100) {
                    //线程休眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + number);
                    number++;

                    try {
                        object.wait();//打印输出一次后调用wait()方法将线程阻塞
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        Thread thread1 = new Thread(myThread);
        Thread thread2 = new Thread(myThread);

        thread1.setName("线程1:");
        thread2.setName("线程2:");

        thread1.start();
        thread2.start();
    }
}

3.面试题：

sleep() 和 wait()的异同？

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

不同点：

1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()

2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中

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

4. 释放锁的操作：

• 当前线程的同步方法、同步代码块执行结束
• 当前线程在同步代码块、同步方法中遇到 break、return终止了该代码块该方法的继续执行。
• 当前线程在同步代码块、同步方法中出现了未处理的Error或 Exception，导致异常结束。
• 当前线程在同步代码块、同步方法中执行了线程对象的 wait()方法，当前线程暂停，并释放锁

5. 不会释放锁的操作：

• 线程执行同步代码块或同步方法时，程序调用 Thread.sleep()、Thread.yield()方法暂停当前线程的执行
• 线程执行同步代码块时，其他线程调用了该线程的 suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）
• 应尽量避免使用 suspend()和 resume()来控制线程

六、JDK 5.0新增线程创建方式

1.新增方式一：实现Callable接口。

实现方法：

1. 创建一个实现Callable的实现类

2. 实现call()方法，将此线程需要执行的操作声明在call()中

3. 创建Callable接口实现类的对象

4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象

5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()

6. 获取Callable中call()方法的返回值

代码示例：

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

1. call()可以返回值的。
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的

2. 新增方式二：使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程对性能影响很大。

解决方案：

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

类比：类似生活中的公共交通工具。

实现方法：

1. 提供指定线程数量的线程池
2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
3. 关闭连接池

相关API：

JDK 5.0起提供了线程池相关API： ExecutorService和 Executors

ExecutorService：真正的线程池接口。常见子类 ThreadPoolExecutor
void execute(Runnable command）：执行任务/命令，没有返回值，一般用来执行Runnable
<T> Future<T> submit（Callable<T>task）：执行任务，有返回值，一般用来执行Callable
void shutdown()：关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFⅸedThreadPool(n)：创建一个可重用固定线程数的线程池
EXecutors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
Executors.newThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

代码示例：

class NumberThread implements Runnable{

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

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

应用线程池的好处：

1. 提高响应速度（减少了创建新线程的时间）

2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）

3. 便于线程管理

   • corePoolSize：核心池的大小
   • maximumPoolSize：最大线程数
   • keepAliveTime：线程没任务时最多保持多长时间后会终止

面试题：

Java中多线程的创建有几种方式？
四种。

JDK 5.0以前：

• 即继承Thread类重写run()方法
• 实现Runnable接口实现run()方法

JDK 5.0以后：

• 实现callable接口，实现call()方法
• 利用线程池

多线程三步走

关于多线程的操作，我们需要记住下面几句，多线程的企业级模板口诀，多线程口诀：

1. 明确线程结构：线程、操作（方法）、资源类
2. 明确操作流程：判断、干活、通知（唤醒）
3. 防止虚假唤醒：防止多线程状态下的虚假唤醒

多线程的判断一定是使用while()，而不是if()，防止虚假唤醒。
因为我们需要时刻判断是否满足一定的条件，我们才能干活，而使用if会导致我们唤醒线程后，线程不会再判断是否满足条件了，只会继续往下串行执行，可能导致唤醒之后不满足条件了，线程却依然继续执行。

虚假唤醒：多个线程同时等待同一个条件满足时，当signal唤醒线程时，可能会唤醒多个线程，但是如果对应的资源只有一个线程能获得，其余线程就无法获得该资源，因此其余线程的唤醒是无意义的（有时甚至是有危害的），其余线程的唤醒则被称为虚假唤醒。

1. 明确线程结构

1.明确线程结构：线程、操作（方法）、资源类

1. 线程：多线程怎么能没有线程呢？？？实现 Runnable 接口

2. 操作（方法）：实现 run() 方法

3. 资源类：操作共享的资源类

2. 明确操作流程

2.明确操作流程：判断、干活、通知（唤醒）

1. 判断：多线程的判断一定是使用while()，而不是if()，防止虚假唤醒。
   因为我们需要时刻判断是否满足一定的条件，我们才能干活，而使用if会导致我们唤醒线程后，线程不会再判断是否满足条件了，只会继续往下串行执行，可能导致唤醒之后不满足条件了，线程却依然继续执行。

2. 干活：实现目标功能

3. 通知（唤醒）：多个线程同时等待同一个条件满足时，当signal唤醒线程时，可能会唤醒多个线程，但是如果对应的资源只有一个线程能获得，其余线程就无法获得该资源，因此其余线程的唤醒是无意义的（有时甚至是有危害的），其余线程的唤醒则被称为虚假唤醒。

3. 防止虚假唤醒

3.防止虚假唤醒：防止多线程状态下的虚假唤醒

多线程的判断一定是使用while()，而不是if()，防止虚假唤醒。
因为我们需要时刻判断是否满足一定的条件，我们才能干活，而使用if会导致我们唤醒线程后，线程不会再判断是否满足条件了，只会继续往下串行执行，可能导致唤醒之后不满足条件了，线程却依然继续执行。

虚假唤醒：多个线程同时等待同一个条件满足时，当signal唤醒线程时，可能会唤醒多个线程，但是如果对应的资源只有一个线程能获得，其余线程就无法获得该资源，因此其余线程的唤醒是无意义的（有时甚至是有危害的），其余线程的唤醒则被称为虚假唤醒。

三步走实例

我们来试试吧，一个初始值为0的变量，两个线程对其交替操作，一个加1，一个减1，来5轮

我们下面实现一个简单的生产者消费者模式，首先有资源类ShareData

/**
 * 资源类
 */
class ShareData {

    private int number = 0;

    private Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    public void increment() throws Exception{
        // 同步代码块，加锁
        lock.lock();
        try {
            // 判断
            while(number != 0) {
                // 等待不能生产
                condition.await();
            }

            // 干活
            number++;

            System.out.println(Thread.currentThread().getName() + "\t " + number);

            // 通知 唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws Exception{
        // 同步代码块，加锁
        lock.lock();
        try {
            // 判断
            while(number == 0) {
                // 等待不能消费
                condition.await();
            }

            // 干活
            number--;

            System.out.println(Thread.currentThread().getName() + "\t " + number);

            // 通知 唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

里面有一个number变量，同时提供了increment 和 decrement的方法，分别让number 加1和减1

但是我们在进行判断的时候，为了防止出现虚假唤醒机制，不能使用if来进行判断，而应该使用while

// 判断
while(number != 0) {
    // 等待不能生产
    condition.await();
}

不能使用 if判断，因为我们需要时刻判断是否满足一定的条件，我们才能干活，而使用if会导致我们唤醒线程后，线程不会再判断是否满足条件了，只会继续往下串行执行。

// 判断
if(number != 0) {
    // 等待不能生产
    condition.await();
}

完整代码

/**
 * 生产者消费者 传统版
 * 题目：一个初始值为0的变量，两个线程对其交替操作，一个加1，一个减1，来5轮
 * @author: 陌溪
 * @create: 2020-03-16-21:38
 */
/**
 * 线程 操作（方法） 资源类
 * 判断 干活 通知
 * 防止虚假唤醒机制
 */

/**
 * 资源类
 */
class ShareData {

    private int number = 0;

    private Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    public void increment() throws Exception{
        // 同步代码块，加锁
        lock.lock();
        try {
            // 判断
            while(number != 0) {
                // 等待不能生产
                condition.await();
            }

            // 干活
            number++;

            System.out.println(Thread.currentThread().getName() + "\t " + number);

            // 通知 唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws Exception{
        // 同步代码块，加锁
        lock.lock();
        try {
            // 1 判断
            while(number == 0) {
                // 等待不能消费
                condition.await();
            }

            // 2 干活
            number--;

            System.out.println(Thread.currentThread().getName() + "\t " + number);

            // 3 通知 唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}
public class ProdConsumerTraditionDemo {

    public static void main(String[] args) {

        // 高内聚，低耦合    内聚指的是，一个空调，自身带有调节温度高低的方法

        ShareData shareData = new ShareData();

        // t1线程，生产
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        // t2线程，消费
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "t2").start();
    }
}

最后运行成功后，我们一个进行生产，一个进行消费

t1	 1
t2	 0
t1	 1
t2	 0
t1	 1
t2	 0
t1	 1
t2	 0
t1	 1
t2	 0