Java从零开始 第14讲 多线程
这里写目录标题
什么是多线程
在学习多线程之前，先让我们明白什么是进程，什么是线程
进程是一个内存中运行的应用程序，每个进程都有一个独立的内存空间
而线程，是指进程中的一个执行路径，共享一个内存空间，线程之间可以*切换，并发执行. 一个进程最少 有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程
打开你电脑的任务管理，你就能看到你目前执行的线程和进程的数量
在之前我们所有的编程都是单线程的，即仅有main线程，程序运行的顺序是从头到尾；而当我们学习玩多线程后，我们能够并发的执行多个线程，以达到一些我们需要的功能。
多线程相关概念
调度
目前我们电脑的CPU通常有多核，其中的每一个核，都只能运行单一的线程，为了在不提升运算速率（指处理单个线程的时间）的情况下，提高CPU运算的效率，就必须对合理的调度线程（对于单核而言，并不能提升）
线程的调度，即是对线程运行的调配。在一个进程中，通常所有线程不会一起运行，而是根据需要分次分时的运行，为了能够合理的调度线程，我们有两种基础调度模型：
分时调度：
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间
抢占式调度：
JVM采用的就是抢占式调度，当CPU空闲后，各个线程会开始争抢运行机会，高优先级的线程会更容易抢到运行机会（注意并不是一定抢到）
同步和异步
在我们之前学习常用类库时，我们就提到过同步和异步的概念，现在让我们详细了解一下：
同步（synchronize）-线程排队执行，效率低，但是线程安全
异步（asynchronize）-线程同时执行，效率搞，但是线程不安全
想象一下有一个卖汉堡的汉堡店，同时有几个人一起来买汉堡吃
同步即是几个人排队买汉堡，虽然吃得慢，但是每个人都能安全的吃，如果店家一次能做两个汉堡，则两个人就能一起吃
异步则是围在一起等着吃，当一个人想吃某个汉堡的时候，可能这个汉堡已经被另一个人吃掉了，但是他并不知情，只能打开汉堡盒吃空气，这就是线程不安全（另一个线程篡改了公共的数据，但是执行的线程并不知情）
并发和并行
并发：指两个或多个事件在同一个时间段内发生
并行：指两个或多个事件在同一时刻发生（同时发生，平行发生）
守护线程
之前我们提到过，一个进程通常包括多个线程，至少包括一个线程
当所有的线程全部结束后，一个进程也就自然而然的结束了
线程在其中又可以被分为用户线程和守护线程，守护线程在运行时跟用户线程没有区别，但是如果所有用户线程都结束了，守护线程会自行结束
JVM中一直被我们提到的GC就是一个守护线程，当没有用户线程运行时，GC也会自动结束
多线程编程
学习了那么多概念，现在让我们正式开始学习一下多线程编程，Java中，多线程编程主要通过两种方法实现：
继承Thread类
自行编写一个类并继承Thread类，并且重写其中的run方法，创建该类的对象，调用start方法就能达到多线程的效果，下面让我们看一个简单的例子：
public class multithread {
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
MyThread myThread3 = new MyThread();
myThread1.start();
myThread2.start();
myThread3.start();
}
}
class MyThread extends Thread{
@Override
public void run(){
for(int i=0; i<5; i++)
System.out.print(i);
}
}
在MyThread类中我们重写了run方法，然后在main方法中创建了三个MyThread类的对象，并且一一调用start方法
运行结果可能是：
012340123401234
001234012341234
010123401234234
001234123401234
这正是因为这几个线程拥有相同的优先级，他们不断的抢占运行机会，所以会产生不同的运行结果
实现Runnable接口
实现Runnable接口同样需要重写run方法，但是调用的方法略微有点不同：
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
或者
new Thread(new MyRunnable()).start();
Thread和Runnable比较：
- Runnable更适用于多个线程执行相同的任务，任务和线程分离，健壮性（robustness）更强
- Runnable可以避免单继承的缺陷，即在实现Runnable后还可以继承其他类
- 线程池仅适用于Runnable
但是Thread也有非常好用的地方，比如：
new MyThread().start();
// 通过匿名类快速执行线程
甚至直接使用内部类创建并执行线程：
new Thread(){
@Override
public void run(){
for(int i=0; i<5; i++)
System.out.print(i);
}
}.start();
Thread类详解
无论使用哪种多线程编程，都需要使用Thread类，现在让我们详细学习一下Thread类
首先Thread类有四种常用的构造方法：
Thread();
Thread(Runnable target);
Thread(Runnable target, String name);
Thread(String name);
还有一些我们需要关注的方法：
static void sleep(long milis);// 休眠，单位为毫秒
static void sleep(long milis, int nanos);// 后为纳秒
String getName();// 返回线程的名字（构造时传入）
也可以使用Thread.currentThread().getName();获取名字
void setName(String name);// 设置线程名字
void setDaemon(boolean on);// 设置是否为守护线程
long getId();// 返回线程的ID（标识符）
void setPriority(int newPriority);// 设置优先级
int getPriority();// 返回优先级值
优先级即是我们之前提到过的运行优先级，拥有高优先级的线程会有更高的几率抢到运行，在Java中，最高优先级为10，最低为1，默认为5
void stop();
在目前版本的JDK中，stop是一个已经被汰换的方法，因为使用stop会很容易导致死锁，目前结束线程通常在run方法中写明条件，达到条件后自行结束
Thread中还含有一个内部类State，该类用于指明线程的状态
在其中，线程被分为六种状态，New-刚创建还未启动，Runnable-正在执行，Blocked-被阻塞等待其他线程（即排队中），Waiting-无限期等待（休眠），TimeWaiting-计时等待，Terminated-被终止，已退出竞争
线程问题
线程的结束
一个线程是一个独立的执行路径，注意我们刚刚提到过，一个线程想要结束，最好通过条件让它自行结束，而不是使用stop方法
这时我们就需要使用标识符的方法
public class multithread {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
t1.start();
t1.interrupt();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for(int i=0; i<10; i++) {
System.out.print(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//e.printStackTrace();
System.out.println(1);
}
}
}
}
注意这里的interrupt方法并不是结束这个进程，而是让这个进程执行sleep方法时抛出异常，如果你像这样将异常注释掉，线程也会默默的运行到结束，或者在catch中写上return;，这样线程会立即结束却不报错
线程安全问题
之前我们提到过线程安全问题，现在让我们详细解释一下
同样使用汉堡店的例子，三个人来到汉堡店，但是店家不做汉堡了，目前只有十个汉堡，让我们用抢占式调度完成一下该代码：
public class multithread {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);
t1.start();
t2.start();
t3.start();
}
}
class MyRunnable implements Runnable{
int count = 10;
@Override
public void run() {
int i = 0;
while(count > 0) {
count--;
i++;
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
从逻辑上来看，整段代码没有任何问题，但是当我们运行后，却发现结果：
Thread-1:4
Thread-0:4
Thread-2:5
Process finished with exit code 0
三个人总共竟然买到了13个汉堡，这就是线程不安全的问题，如果一个线程在另一个线程将count减到0之前进行了判断，那么该线程仍然会继续执行，最终导致count变成了负数
处理线程安全问题
为了解决线程安全问题，Java提出了多种解决方案，他们都采用了加锁的机制，即在一个线程执行时通过锁定其他线程，使整体执行变得同步
同步代码块
在第八讲中我们就提到过同步代码块的概念，现在让我们学习一下同步代码块
同步代码块通过如下方式定义
synchronized (对象名){
}
让我们用同步代码块更新一下原先的汉堡店代码：
class MyRunnable implements Runnable{
int count = 10;
Object obj = new Object();
@Override
public void run() {
int i = 0;
while(true) {
synchronized (obj) {// 普通的公共对象
if(count > 0) {
count--;
i++;
System.out.println(Thread.currentThread().getName() + ":" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else
break;// 不然无法结束进程
}
}
}
注意其中的obj只是一个公共的Object对象（必须是公共的）
使用这种方法，能够保证三个顾客总共只能买到10个汉堡，但是同步代码块也有一些问题：
- 效率大幅降低
- 必须为了同步更改代码结构
- 很容易出现一个线程连续运行的情况
同步方法
同步方法即把synchronize关键字修饰到方法上，此时MyRunnable方法就需要改为：
class MyRunnable implements Runnable{
int count = 10;
@Override
public void run() {
while(true)
if(!sale())
break;
}
public synchronized boolean sale(){
if(count > 0) {
count--;
System.out.println(Thread.currentThread().getName() + "购买了一个汉堡");
System.out.println("汉堡余量："+count);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return true;
}
return false;
}
}
相较于同步代码块，同步方法的锁更加不精密
显式锁
在之前我们使用的同步代码块和同步方法都是隐式锁，可以发现整体代码中没有提到过锁，加锁和开锁，而我们现在将要直接使用锁Lock类
Lock lock1 = new ReentrantLock();// 创建锁
lock1.lock();// 加锁
lock1.unlock();// 解锁
它的使用也很直接，可以直接把锁套用在同步代码块的两个大括号处
public void run() {
int i = 0;
while(true) {
lock1.lock();
if(count > 0) {
count--;
i++;
System.out.println(Thread.currentThread().getName() + ":" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else
break;
lock1.unlock();
}
}
为了能让程序正常结束我们还需要在else中添加解锁操作
else {
lock1.unlock();
break;
}
显式锁和隐式锁各有所长，比如显式锁是通过API完成加锁效果的，而隐式锁则是在JVM层面的；显式锁可以对锁进行分组，达到精确唤醒的目的，也可以自己决定是不是公平锁，还可以自行中断，但是Java官方明显还是更偏向于隐式锁，不仅更新不断，官方帮助文档里的描述也是写的满满当当，生怕你看不懂。
公平锁
公平锁的概念即为一个锁解开时，其他线程抢夺是否公平
如果是公平的，那么在锁还没解开是，等待锁解开的线程就开始排队等候，一个个的使用
而不公平的则是锁一旦解开，所有的线程都会同时抢夺该锁
隐式锁和显式锁默认都是非公平的，但是在显式锁的创建时，可以传入一个true参数，来创建一个公平锁
死锁
死锁的概念很简单，正如死结一样，无法通过正常手段解开，一个死锁的产生可以很复杂，也可以很简单（至少需要两个锁）
死锁的概念可以通过一个简单的例子来阐明：一条窄道上有两个英国绅士，绅士们很讲究绅士风度，所以当遇到迎面而来的人时，他们都会让出路来让对面先走
很明显，会产生的结果是，两位绅士都会接连后退，等待对方先过，最后谁也过不去，这就相当于产生了死锁
线程池
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间.
线程池就是一个容纳多个线程的容器，在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务
池中的线程可以反复使用，省去了频繁创建线程对象的操作，降低了资源的消耗，提高了相应速度，还提高了线程的可管理性
Java中有四种线程池，而四种线程池都通过ExecutorServie来实现，让我们一一学习：
缓存线程池
缓存线程池执行流程为：
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在,则创建线程并放入线程池, 然后使用
缓存线程池的长度可以按需不断的延申，没有长度的限制
构建缓存线程池的方法是
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new MyRunnable());
定长线程池
定长线程池执行流程为：
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
定长线程池就相当于长度固定的缓存线程池
定长线程池构建方法是：
ExecutorService service = Executors.newFixedThreadPool(2); // 传入长度
service.execute(new MyRunnable());
单线程线程池
单线程线程池执行流程为：
- 判断线程池中的唯一线程是否空闲
- 空闲则使用
- 不空闲,则等待该线程空闲后使用
单线程线程池就相当于定长为1的定长线程池
单线程线程池构建方法为：
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new MyRunnable());
周期性任务定长线程池
周期性任务定长线程池执行流程为：
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
周期性任务定长线程池根据定时和周期有两种构建方法：
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);// 长度
// 定时执行
service.schedule(new MyRunnable() , 5,TimeUnit.SECONDS);
// 其中第二个参数为时长数字，第三个参数为时长数字的单位，上面代码结果即该线程五秒钟执行一次
// 周期执行
service.scheduleAtFixedRate(new Runnable() ，5,1,TimeUnit.SECONDS);
// 其中二参为第一次执行在多久以后，三参四参同上，上面代码结构即5秒之后每一秒执行一次
多线程通信
多线程通信需要了解四个在Object类中的方法：
void notify();// 随机唤醒某线程
void notifyAll();// 唤醒所有线程
void wait();// 等待，不唤醒则一直等
void wait(long timeoutMilis);// 等待，指定时间
多线程通信中有一个很经典的问题，叫做生产者与消费者问题，也叫做PV操作问题（其中涉及到信号量的问题，但是暂时不用理解），设想刚刚的汉堡店，汉堡店做一个，顾客才能买来吃
让我们用代码来实现一下：
public class multithread {
public static void main(String[] args) {
ProcessSynchronization ps = new ProcessSynchronization();
new Thread(new Producer(ps)).start();
new Thread(new Producer(ps)).start();
new Thread(new Producer(ps)).start();
new Thread(new Consumer(ps)).start();
new Thread(new Consumer(ps)).start();
new Thread(new Consumer(ps)).start();
}
}
//生产者类
class Producer implements Runnable{
ProcessSynchronization ps = new ProcessSynchronization();
Producer(ProcessSynchronization ps){
this.ps = ps;
}
public void run(){
while(true){
try {
this.ps.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//消费者类
class Consumer implements Runnable{
ProcessSynchronization ps = new ProcessSynchronization();
Consumer(ProcessSynchronization ps){
this.ps = ps;
}
public void run(){
while(true){
try {
this.ps.consume();
}catch(Exception e) {
e.printStackTrace();
}
}
}
}
class ProcessSynchronization{
int count = 0;
public synchronized void produce() throws InterruptedException {
Thread.sleep(500);
if (count<10) {
count++;
System.out.println("制造了一个小汉堡，现在余量：" + count);
super.notifyAll();
} else
super.wait();
}
public synchronized void consume() throws InterruptedException {
Thread.sleep(500);
if(count>0) {
count--;
System.out.println("吃掉了一个小汉堡，现在余量：" + count);
super.notifyAll();
} else
super.wait();
}
}
这段代码运行后，就会一直有新的小汉堡被制造，也会一直有顾客吃掉小汉堡
本段代码的难度比较大，如果实在不能理解可以暂时搁置
Callable接口和Lambda
在主流的两种线程创建方法之外，还可以通过实现Callable接口创建线程
Callable的使用比较复杂：
class XXX implements Callable<T> {
@Override
public <T> call() throws Exception {
return T;
}
}// 首先创建类实现，其中T为泛型
MyCallable myCallable = new MyCallable();
FutureTask<String> futureTask = new FutureTask<String>(myCallable);// 这里的String就是类中泛型
Thread thread = new Thread(futureTask);
thread.start();// 一步步构建，最终还是使用Thread类
可以使用futureTask.get();方法或者isDone();方法，等待该对象的线程完成之后再继续执行下去
Callable并不是很经常使用，但是在早期Runnable接口功能不完善时经常被使用，学习该接口有助于阅读源码
学完Runnable和Callable后你可能感觉，创建一个线程也太麻烦了，完整的创建需要创建两三个对象，其实线程中的输出语句就一句，但是为了执行该语句要写很多的结构代码
Java为了提高效率，提出了Lambda表示式，可以省略所有无实际意义的结构代码，很大幅的节约代码量，Lambda表达式通过如下方式使用
Thread thread = new Thread(() -> System.out.println(1));
thread.start();
这一行代码就相当于构建了线程代码，创建了线程并执行，而Lambda表达式其实也可以应用于任何情况，并不是线程的专属，使用Lambda表达式其实就是省略了一个创建内部类的内容
在编程中通常不提倡大量使用Lambda表达式，因为其会对debug的过程带来很多麻烦，虽然整体看起来简洁，但实际上让后续的更改更加麻烦
转载请注明出处
本文地址：https://blog.csdn.net/CheakccL/article/details/112203278