目的

这一系列的博文的目的是帮助自己对多线程的知识做一个总结，并且将 Java 中的多线程知识做一个梳理。尽量做到全面和和简单易懂。

概念

进程与线程

进程是操作系统级别的，进程是操作系统分配资源的基本单位，一个进程可以包含多个线程，线程共享进程的资源。线程是 CPU 调度的基本单位。

为什么要使用多线程

多线程可以更好的利用多核 CPU 的性能，多核CPU上跑多线程程序往往会比单线程更快，有的时候甚至在单核CPU上多线程程序也会有更好的性能。总结来说，多线程可以更好的利用 CPU 资源。但是多线程也会有上下文切换的性能损耗。

多线程的上下文切换

多线程的执行需要承担线程上下文切换所带来的性能损耗。在多任务处理系统中，CPU 需要处理所有程序的操作，当用户来回切换它们时，需要记录这些程序执行到哪里。上下文切换就是这样一个过程，允许 CPU 记录并恢复各种正在运行的程序的状态，使它们能够完成切换操作。

作业数往往大于 CPU 数，那么一个 CPU 在某一个时刻只能执行一个任务，那么如何让用户感觉好多任务在同时执行哪？操作系统的设计这巧妙的利用了**时间片轮转的方式，每个任务只给一段运行时间，然后保存运行状态，加载下一个任务继续执行。这样来回切换，这个过程就叫做上下文切换。**时间片轮转的方式使一个 CPU 同时执行多个任务变成了可能(归根结底，任务还是串行，一个一个执行的)。

上面文中要保存的内容包括程序运行到哪个位置的信息等等(这个保存在程序计数器中)。

并行与并发

并发：指的是同时运行多少个线程，但是会有线程上下文切换的，同一时刻只有一个线程运行。 并行：针对现在的多核 CPU，多个线程真正的同时运行。同一时刻有多个线程同时运行。

多线程带来的风险

线程安全性问题。 我们的 Java 代码被编译成机器指令后，可能需要多步才能完成，由于CPU对线程进行切换，会导致多步发生线程安全问题。

活跃性问题，死锁(哲学家就餐问题，每个哲学家一支筷子)，饥饿(有的线程永远得不锁，得不到到执行)，活锁。

性能问题，上下文切换。

线程

了解了多线程能够带给我们的好处和问题之后，我们来看看线程的相关知识。

线程的生命周期

新建(new)：创建后尚未启动的线程就处于这种状态。

运行(Runnable)：线程正在运行的状态。

就绪(Ready)：启动并调用 start 方法后就处于就绪状态，等待 CPU 分配时间片后就可以运行。

阻塞(Blocked)：可能是因为调用了 wait 方法进入阻塞(释放锁)，也可能是 sleep 方法进入阻塞(不释放锁)。wait 方法获取锁后是 Ready 状态，等待 CPU 分配时间片才能再次运行。

结束(Terminated)：以终止线程的线程状态，线程已经结束执行。

线程的创建

继承Thread 定义一个线程类并继承Thread类，重写里面的run方法。因为java是单继承的，所以并不推荐这种方式。

public class Main {

public static void main(String[] args) throws Exception {

myThread th1 = new myThread();

myThread th2 = new myThread();

th1.start();

th2.start();

}

}

class myThread extends Thread {

public void run() {

for(int i = 0; i < 5; i++) {

System.out.println(Thread.currentThread().getName() + "运行 : " + i );

}

}

}

实现Runnable 定义一个线程类并实现Runnable接口，使用的时候把这个Runnable实例传入到Thread类中即可。

public class Main {

public static void main(String[] args) throws Exception {

myThread myth = new myThread();

Thread th1 = new Thread(myth);

Thread th2 = new Thread(myth);

th1.start();

th2.start();

}

}

class myThread implements Runnable {

public void run() {

for(int i = 0; i < 5; i++) {

System.out.println(Thread.currentThread().getName() + "运行 : " + i );

}

}

}

实现Callable接口 创建线程类并实现Callable接口，重写call方法，这个方法会有返回值。使用FutureTask对象作为Thread对象的target创建并启动新线程。

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

public class Main {

public static void main(String[] args) {

ThreadDemo td = new ThreadDemo();

// 1.执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果

FutureTask result = new FutureTask<>(td);

new Thread(result).start();

// 2.接收线程运算后的结果

Integer sum;

try {

//等所有线程执行完，获取值，因此FutureTask 可用于 闭锁

sum = result.get();

System.out.println("-----------------------------");

System.out.println(sum);

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

}

}

class ThreadDemo implements Callable {

@Override

public Integer call() throws Exception {

int sum = 0;

for (int i = 0; i <= 10; i++) {

System.out.println(i);

sum += i;

}

return sum;

}

}