一.多线程

1.什么是多线程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程的实际运作单位

简单理解多线程就是应用软件中相互独立，可以同时运行的功能(也可以理解为人体内相互独立，但可以同时运行的器官⌓‿⌓)

我们平时常用的Main方法，就是主线程

2.多线程的作用

单线程运行时，比如我们要创建一个变量，程序是需要等待时间的。而使用多线程，程序可以在多个线程之间来回运行，充分利用等待的时间，从而提高CPU的利用效率

二.多线程的三种实现方式

在Java API中对于Thread类的描述中给出了多线程的两种启动方式

⒈Thread类

线程是程序中的执行线程。Java虚拟机允许应用程序并发地运行多个执行线程

下面我们就来结合多线程的启动方式来了解Thread类

⒉多线程的第一种启动方式

将类声明为Thread的子类

该子类应重写Thread类的run方法

接下来可以分配并启动该子类的实例

如图:我们创建两条线程并启用

⑴此方法中的Thread类

①构造方法

Ⅰ.Thread()

Ⅱ. Thread(String name)

其中的参数传递的就是线程的名字，默认为Thread-序号

②常用方法

Ⅰ start

void start() 使该线程开始执行

start方法是Thread类的基础方法，有了它线程才能够启动执行，而它又不像流那样需要close关闭，当线程结束后它会自动关闭

Ⅱ getName

String getName() 返回该线程的名称

当线程我们没有手动命名，getName默认返回的是Thread-序号

Ⅲ sleep

在多条线程执行时，当一条线程抢占到CPU执行权，它的执行时间是不确定的，那么它就可能一直占有着，当执行完毕后才能轮到下一个线程

比如上图，当一条线程执行完毕后才能轮到下一个线程

那我们想要线程轮流执行，那么就可以使用sleep让线程睡一会 

如图:当我们执行完打印语句后，就让线程睡1毫秒，将执行权让给另一条线程

如图:看运行结果，两条线程就差不多是交替执行，而不是一条线程执行到底

Ⅳ  setPriority

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

void getPriority()  获取线程的优先级

在Java中多条线程的执行是随机的，线程的优先级分为10个等级(1--10)，优先级高的获取到CPU执行权的概率就越高，Java默认优先级为5

如图:优先级高的抢占到执行权的概率越大，而不是一定是它先执行完，这是概率问题

Ⅴ  setDaemon

 void setDaemong(boolean on)  将该线程设置为守护线程

守护线程就是当其他非守护线程执行完毕后，守护线程就没有存在的必要了，就会陆续结束，该守护线程可以不执行完结束

如图:我们将线程1设置为守护线程，线程2为非守护线程，当线程2执行完毕时，线程2会陆续结束，可以不会执行完

 

举个例子，当我们在扣扣的聊天窗口传输数据，聊天窗口就是非守护线程，而传输数据的窗口就是守护线程，当我们把聊天窗口关闭时，数据传输窗口也会陆续关闭

Ⅵ  yield

static void yield()  暂停当前正在执行的线程对象，并执行其他线程

yield方法可以出让当前的CPU执行权，但出让之后该线程仍然可能抢占到CPU执行权

因此除了sleep方法，该方法也可以让线程的执行尽可能的均匀些

Ⅶ  join

join方法设置的线程，当该线程抢占到CPU执行权之后，在规定的等待时间内就会一直执行完毕后，才会让出CPU的执行权

⒊多线程的第二种启用方式

将类声明实现Runable接口

然后实现run方法

最后创建子类对象并传递给Thread对象

如图:我们创建子类对象并传递给线程执行

⑴此方法中的Thread类

①构造方法

方法传递Runable接口的实现类对象 

又因为Runable接口是函数式接口，因此我们可以使用匿名内部类的方式实现

②常用方法

Ⅰ currentThread

static void currentThread()  获取当前线程对象

Ⅱ getName

Runable方法启动线程获取线程名字与Thread方法获取不同

在Runable实现类中我们实现的是Runable接口，该类与Thread是没有关系的，那么我们就不能像第一种启用方式那样直接getName获取到线程的名字了

那怎么解决呢？

我们可以利用currentThread方法获取到当前执行线程的对象，然后再调用getName方法获取到当前线程的名字

4.多线程的第三种启用方式

在前面的两种启用方式中，run方法是没有返回值的

因此我们就需要一种有返回值的启用多线程的方法

FutureTask类可以的get方法可以获取到线程方法中的结果，且FutureTast实现了Runable接口，可以在第二种方式的基础上启用线程

而其中构造方法可以传递一个Callable接口的实现类对象

而Callable接口只有一个方法call可以返回线程计算的结果

因此第三种启用方式就是在第二种方式的基础上稍加修改

首先创建Callable实现类并重写call方法

然后创建FutureTesk对象接受Callable实现类运行的结果

最后创建Thread类对象并启动

 

5.三种线程启用方式的对比

对于第一种启用方式，操作简单，可以直接使用Thread类中的方法。但是正因为它继承了Thread类，它就不能再继承其他类了，因此它的扩展性较差

对于第二，三种启用方式，它没有继承任何类，因此它的扩展性就强些。但是它的编程相对的就复杂些，不能直接使用Thread类中的方法

第一，二种启用方式无法获取到方法返回值，因此就有了第三种方式可以获取到方法返回值

三.线程的安全问题

在多线程的执行中，若我们有一个共享的变量size在随着线程的执行变化着，因为线程的执行是随时随机抢占的，那么size就会有线程安全问题

如图所示例子:

那么为了维护线程操作共享数据运行时的安全性问题，我们可以将这共享数据的代码用锁锁起来，当线程进入锁后，其他线程在外等候，当锁里面的代码执行完毕后，其他线程才能抢夺执行

1.同步代码块

格式:

synchronized(锁){操作的共享数据}

这里面的锁对象一定要是唯一的，只有相同的一把锁我们才可以让多条线程开锁解锁

这把锁可以是任意类型的共享对象

如:static Object o=new Object;

但是通常我们会使用本类的字节码文件

类名.class

如图:我们利用本类的字节码文件作为唯一的锁对象

2.同步方法

同步方法就是把synchronized关键字加到方法上，表示把这一个方法的所有代码给锁起来

格式:

修饰符 synchronized 返回值类型 方法名(方法参数){}

同步方法的锁对象我们不能自己指定，Java给我们指定好了锁对象

当是非静态方法时，锁对象是this，表示方法调用者

当是静态方式时，所对象是当前类的字节码文件

如图:在之前我们学习的StringBuffer中，我们同用可以看到同步方法的身影，这表示StringBuffer是线程安全的

3. Lock锁

synchronized操作简单但是我们无法进行更多关于锁的操作，而Lock相比于synchronized可以进行更广泛的锁定操作，允许更灵活的结构，可以支持多个相关的Condition对象

⑴Lock类

如图: Lock类是一个接口，不能直接实例化，我们常用它的实现类ReentrantLock(可重入锁)来实例化

①成员方法

Ⅰ lock和unlock

lock开锁, unlock解锁，这两个方法是最基本的锁，同样的锁对象必须是唯一的

利用lock锁有一个小细节

如图:若我们直接lock与unlock，就会遇到下面的问题，有线程拿着钥匙跑了，其他线程结束不了！！！

因此我们需要一个解决办法，无论线程怎样执行，unlock必须执行。那么我们就可以使用try...finally来包裹unlock,让锁必须释放

Ⅱ newCondition

lock锁通常会与Condition类结合使用来进行一些对于锁的操作

比如在阻塞队列中的使用

https://blog.csdn.net/m0_74808313/article/details/132196171

4.死锁问题

当锁嵌套时，通常会遇到死锁问题

如图:当线程1拿到了A锁等待B锁，而同时线程2拿到了B锁等待A锁，这时就导致了死锁

因此为了防止死锁问题，我们好尽量减少锁的嵌套

四.多线程协作

多线程协作就是线程之间相互配合，共同完成某项工作

比如：一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者是消费者

1.生产者和消费者

生产者和消费者模式是一个十分经典的多线程协作的模式，又叫做等待唤醒机制，打破了线程的随机机制，让多个线程轮流执行

所谓生产者消费者问题，实际上主要是包含了两类线程：

​ 一类是生产者线程用于生产数据

​ 一类是消费者线程用于消费数据

生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

2.等待唤醒机制的实现

⑴仓库，生产者和消费者的逻辑

首先我们需要一个仓库，当生产者生产物件后放入仓库，消费者消费物件拿出仓库

这个仓库需要有一把锁

当生产者进入时，若发现仓库中有物件，那么它就会沉睡等待，若发现仓库中没有物件，那么它就会生产物件并叫醒消费者

当消费者进入时，若发现仓库中没有物件，那么它就会沉睡等待;若发现仓库中有物件，那么它就会消费物件并叫醒生产者

⑵wait和notify

在Java的Object类中提供了相对应的方法来帮助我们解决线程的协作问题

注: wait和notify必须使用在同步方法或同步代码块内

⑶阻塞队列实现

首先我们需要一个阻塞队列，这个阻塞队列就代表仓库

然后我们完成生产者与消费者的逻辑

因为阻塞队列的put与take方法就是生产者与消费者的逻辑，因此我们在写生产者与消费者时就直接put，take，不用再进行逻辑的实现

如图:我们写完生产者与消费者的逻辑，传递阻塞队列查看

 

如图:查看打印语句发现生产者与消费者是轮流执行的，这样就实现了等待唤醒机制的逻辑

细节:因为锁是在put与take方法内部的，而打印语句在锁的外面，但并不影响共享数据的执行，只是不便于我们查看

五.线程状态

在给定的时间点上，一个线程只能处于一种状态。这些状态是虚拟机状态，它们并没有反映所以操作系统线程状态

六.线程池

在以前我们写的多线程有弊端

当我们需要线程时就创建(NEW)，当它运行完后就消失(TERMINAED)，这样的话浪费操作系统的资源

因此我们需要线程池来优化

1.线程池核心原理

我们需要一个容器，当我们提交线程任务时，容器会创建新的线程对象，任务执行完毕，线程存入到容器，到下次直接拿出使用

若提交任务时容器中没有空闲线程且容器满了，那么其他线程排队等待

2.线程池实现

static ExecutorService newCachedThreadPool() 创建一个没有上限的线程池

static ExecutorService newFixedThreadPool(int nThreads) 创建一个有上限的线程池

如图:我们创建一个大小为3的线程池，将前三个任务提交上去

可以看到当前排队的线程为0，工作中的线程为3，而当我们要提交下面的任务时，当前面的线程没结束它就会排队等待，只有当前面的线程运行完毕他们才能工作

3.自定义线程池

当我们查看newFixedThreadPool时，可以看到它的底层是创建了一个ThreadPoolExecutor对象

ThreadPoolExecutor才是真正的线程池对象，它相比于前面的线程池来说更加灵活

⑴ThreadPoolExecutor

ThreadPoolExecutor(int corePoolSize ,  int maximumPoolSize ,  long keepAliveTime ,  TimeUnit unit , BlockingQueue<Runnable> workQueue ,  ThreadFactory threadFactory ,  RejectedExecutionHandler handler)  用给定的初始参数创建线程池

其中共有7个参数

参数一:核心线程数

参数二:最大线程数量

参数三:等待的空闲时间

参数四:时间单位

参数五:任务队列

参数六:创建线程工厂

参数七:要执行的任务过多时的解决方案

其中当我们提交的线程多于核心线程，多出的线程会等待

若线程数量超出最大线程数，那么会创建临时线程(最大线程数-核心线程数)，让多出的线程工作

若线程数量超出最大线程数+临时线程，那么会对超出的线程进行处理

其中的处理方式有四种，分别被定义为内部类

⑵线程池实现

线程池的大小并不是我们随意规定的，而是需要通过公式计算出来的

①CPU密集型运算

当我们的项目中计算多而读取文件少，就要此方式类计算

最大并行数+1

最大并行数与我们电脑CPU的型号相关，因为操作系统不会把所有的线程给同一个软件，因此我们通常利用Java虚拟机来计算最大并行数

②I/O密集型运算

当我们的项目计算少，读取数据多，那么就使用此类方式计算

最大并行数×期望CPU利用率×(总时间／CPU计算时间)

③代码书写