阿里P8总结出万字图解“Java多线程“并发编程实战，字节跳动基础架构高级工程师

java提供了丰富的api来支持多线程。

为什么用多线程?

========

多线程能实现的都可以用单线程来完成，那单线程运行的好好的，为什么java要引入多线程的概念呢？

多线程的好处：

1. 程序运行的更快！快！快！

2. 充分利用cpu资源，目前几乎没有线上的cpu是单核的，发挥多核cpu强大的能力

多线程难在哪里？

========

单线程只有一条执行线，过程容易理解，可以在大脑中清晰的勾勒出代码的执行流程

多线程却是多条线，而且一般多条线之间有交互，多条线之间需要通信，一般难点有以下几点

1. 多线程的执行结果不确定,受到cpu调度的影响

2. 多线程的安全问题

3. 线程资源宝贵，依赖线程池操作线程，线程池的参数设置问题

4. 多线程执行是动态的，同时的,难以追踪过程

5. 多线程的底层是操作系统层面的，源码难度大

有时候希望自己变成一个字节穿梭于服务器中，搞清楚来龙去脉，就像无敌破坏王一样（没看过这部电影的可以看下，脑洞大开）。

java多线程的基本使用

============

定义任务、创建和运行线程

---

任务： 线程的执行体。也就是我们的核心代码逻辑

定义任务

1. 继承Thread类 （可以说是 将任务和线程合并在一起）

2. 实现Runnable接口 （可以说是 将任务和线程分开了）

3. 实现Callable接口 (利用FutureTask执行任务)

Thread实现任务的局限性

1. 任务逻辑写在Thread类的run方法中，有单继承的局限性

2. 创建多线程时，每个任务有成员变量时不共享，必须加static才能做到共享

Runnable和Callable解决了Thread的局限性

但是Runbale相比Callable有以下的局限性

1. 任务没有返回值

2. 任务无法抛异常给调用方

如下代码 几种定义线程的方式

@Slf4j

class T extends Thread {

@Override

public void run() {

log.info(“我是继承Thread的任务”);

}

}

@Slf4j

class R implements Runnable {

@Override

public void run() {

log.info(“我是实现Runnable的任务”);

}

}

@Slf4j

class C implements Callable {

@Override

public String call() throws Exception {

log.info(“我是实现Callable的任务”);

return “success”;

}

}

创建线程的方式

1. 通过Thread类直接创建线程

2. 利用线程池内部创建线程

启动线程的方式

• 调用线程的start()方法

// 启动继承Thread类的任务

new T().start();

// 启动继承Thread匿名内部类的任务 可用lambda优化

Thread t = new Thread(){

@Override

public void run() {

log.info(“我是Thread匿名内部类的任务”);

}

};

// 启动实现Runnable接口的任务

new Thread(new R()).start();

// 启动实现Runnable匿名实现类的任务

new Thread(new Runnable() {

@Override

public void run() {

log.info(“我是Runnable匿名内部类的任务”);

}

}).start();

// 启动实现Runnable的lambda简化后的任务

new Thread(() -> log.info(“我是Runnable的lambda简化后的任务”)).start();

// 启动实现了Callable接口的任务 结合FutureTask 可以获取线程执行的结果

FutureTask target = new FutureTask<>(new C());

new Thread(target).start();

log.info(target.get());

以上各个线程相关的类的类图如下

上下文切换

---

多核cpu下，多线程是并行工作的，如果线程数多，单个核又会并发的调度线程,运行时会有上下文切换的概念

cpu执行线程的任务时，会为线程分配时间片，以下几种情况会发生上下文切换。

1. 线程的cpu时间片用完

2. 垃圾回收

3. 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当发生上下文切换时，操作系统会保存当前线程的状态，并恢复另一个线程的状态,jvm中有块内存地址叫程序计数器，用于记录线程执行到哪一行代码,是线程私有的。

idea打断点的时候可以设置为Thread模式,idea的debug模式可以看出栈帧的变化

线程的礼让-yield()&线程的优先级

---

yield()方法会让运行中的线程切换到就绪状态，重新争抢cpu的时间片，争抢时是否获取到时间片看cpu的分配。

代码如下

// 方法的定义

public static native void yield();

Runnable r1 = () -> {

int count = 0;

for (;😉{

log.info("---- 1>" + count++);

}

};

Runnable r2 = () -> {

int count = 0;

for (;😉{

Thread.yield();

log.info(" ---- 2>" + count++);

}

};

Thread t1 = new Thread(r1,“t1”);

Thread t2 = new Thread(r2,“t2”);

t1.start();

t2.start();

// 运行结果

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129504

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129505

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129506

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129507

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129508

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129509

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129510

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129511

11:49:15.796 [t1] INFO thread.TestYield - ---- 1>129512

11:49:15.798 [t2] INFO thread.TestYield - ---- 2>293

11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129513

11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129514

11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129515

11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129516

11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129517

11:49:15.798 [t1] INFO thread.TestYield - ---- 1>129518

如上述结果所示，t2线程每次执行时进行了yield()，线程1执行的机会明显比线程2要多。

线程的优先级

​ 线程内部用1~10的数来调整线程的优先级，默认的线程优先级为NORM_PRIORITY:5

​ cpu比较忙时，优先级高的线程获取更多的时间片

​ cpu比较闲时，优先级设置基本没用

public final static int MIN_PRIORITY = 1;

public final static int NORM_PRIORITY = 5;

public final static int MAX_PRIORITY = 10;

// 方法的定义

public final void setPriority