1 多线程的基础知识

1.1 单核CPU和多核CPU

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

只有在多核 CPU 系统中，这些程序彩色真正意义上的的同时执行。

目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。通过任务管理器可以很方便地查看自己电脑CPU的核数，如下图所示。

1.2 并行与并发的区别

• 并行：多个CPU在同一时刻执行多个任务。（同时执行）
• 并发：一个CPU(采用时间片)在同一个时间段内执行多个任务。(交替执行)

1.3 什么是程序、进程、线程？

程序(program)：一段代码。静态的。

进程(process)：一个正在运行的一个程序。动态的。进程是资源分配的最小单位，有独立的内存空间，即进程中的数据存放空间（堆空间和栈空间）是独立的。

线程(thread)：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。线程堆空间是共享的（这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。），栈空间是独立的，线程消耗的资源比进程小的多。

tips:

1. 一个进程中的多个线程是并发运行的，从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。
2. 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()
   垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
3. 由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。

1.4 多线程编程的优点

使用单个线程先后完成多个任务（调用多个方法），比用多个线程来完成用的时间更短，但是多线程编程具有以下优点：

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

在程序需要同时执行两个或多个任务；程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等；需要一些后台运行的程序时，我们就需要多线程编程。

2 java.lang.Thread类

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

2.1 Thread类的构造方法

• public Thread():分配一个新的线程对象。
• public Thread(String name):分配一个指定名字的新的线程对象。
• public Thread(Runnable target):分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

2.2 Thread类的常用方法

• public static Thread currentThread():返回对当前正在执行的线程对象的引用。
• public String getName():获取当前线程名称。
  线程存在默认名称：
  子线程的默认名称是：Thread-索引；
  主线程的默认名称就是：main；
• public void setName(String name):设置该线程名称
• public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
• public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run():此线程要执行的任务在此处定义代码。
• public static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程；若队列中没有同优先级的线程，忽略此方法。
• join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止（低优先级的线程也可以获得执行）
• stop(): 强制线程生命期结束，不推荐使用
• boolean isAlive()：返回boolean，判断线程是否还活着

3 Java创建线程的三种方式（重点）

3.1 继承Thread类

具体步骤：

1. 定义子类继承Thread类，并重写该类的构造器（根据需求选择是否重写）以及run()方法，run()方法的方法体就代表了线程需要完成的任务,因此将其称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象。
3. 调用线程对象的start()方法来启动该线程。

优缺点
优点：编码简单。
缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）

代码示例：

public class ThreadDemo {// 启动后的ThreadDemo当成一个进程。// main方法是由主线程执行的，理解成main方法就是一个主线程public static void main(String[] args) {// 3.创建一个线程对象Thread t = new MyThread();// 4.调用线程对象的start()方法启动线程,最终还是执行run()方法t.start();for(int i = 0 ; i < 10 ; i++ ){System.out.println("main线程："+i);}}
}// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{// 2.重写run()方法@Overridepublic void run() {// 线程执行体for(int i = 0 ; i < 10 ; i++ ){System.out.println("子线程："+i);}}
}

运行结果：

说明：每次运行的结果都有所差异（并发随机性），也会出现某个线程全部执行完才执行另一个线程的情况。

main线程输出：0
main线程输出：1
main线程输出：2
main线程输出：3
main线程输出：4
子线程输出：0
main线程输出：5
子线程输出：1
子线程输出：2
子线程输出：3
main线程输出：6
main线程输出：7
子线程输出：4
main线程输出：8
main线程输出：9
子线程输出：5
子线程输出：6
子线程输出：7
子线程输出：8
子线程输出：9

tips：

1. 想要启动多线程，必须调用start方法。如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式，此时将只有主线程在执行他们。start()方法底层其实是给CPU注册当前线程，并且触发run()方法执行，run()方法由JVM调用，什么时候调用，执行的过程控制都由操作系统的CPU 调度决定。
2. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。
3. 建议线程先创建子线程，主线程的任务放在之后。否则主线程永远是先执行完！

3.2 实现Runnable接口

具体步骤：

1. 定义子类，实现Runnable接口，并重写该接口的run()方法。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。

优缺点

Runnable方式避免了单继承的局限性；实现解耦操作，线程任务代码可以被多个线程共享，代码和线程独立；线程池只能放入实现Runable或Callable类线程（语法上：Thread作为Runable接口的实现类，其对象实例也能放入线程池）。但是，Runnable方式的代码与继承Thread方式相比复杂了一丢丢。

代码示例：

// 1。定义子类，实现Runnable接口
class MyRunnable implements Runnable{// 2.重写该接口的run()方法@Overridepublic void run() {// 线程执行体for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName()+"： "+i);}}
}public class Demo {public static void main(String[] args) {// 3.创建自定义类对象（线程任务对象）MyRunnable mr = new MyRunnable();// 4.创建线程对象Thread t = new Thread(mr, "子线程");// 5.调用线程对象的start()方法启动线程,最终还是执行run()方法t.start();for (int i = 0; i < 10; i++) {System.out.println("main线程： " + i);}}
}

匿名内部类写法：

public class Demo {public static void main(String[] args) {// 1.创建自定义类对象（线程任务对象）Runnable runnable = new Runnable() {@Overridepublic void run() {// 线程执行体for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName()+"： "+i);}}};// 2.创建线程对象Thread t = new Thread(runnable, "子线程");// 3.调用线程对象的start()方法启动线程,最终还是执行run()方法t.start();for (int i = 0; i < 10; i++) {System.out.println("main线程： " + i);}}
}

运行结果：

main线程： 0
子线程： 0
main线程： 1
子线程： 1
main线程： 2
子线程： 2
子线程： 3
子线程： 4
子线程： 5
main线程： 3
main线程： 4
main线程： 5
main线程： 6
main线程： 7
main线程： 8
main线程： 9
子线程： 6
子线程： 7
子线程： 8
子线程： 9

3.3 实现Callable接口

JDK5.0 新增线程创建方式

具体步骤：

1. 定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。
2. 重写线程任务类的call方法，这个方法可以直接返回执行的结果。
3. 创建一个Callable的线程任务对象。
4. 把Callable的线程任务对象包装成一个未来任务对象。
5. 把未来任务对象包装成线程对象。
6. 调用线程的start()方法启动线程

优缺点：

Callable方式具有Runnable方式的所有优点。除此之外，Callable方式还支持泛型的返回值、方法能抛出异常。但Callable方式的编码较为复杂。

代码示例：

public class ThreadDemo {public static void main(String[] args) {// 3.创建一个Callable的线程任务对象Callable<String> call = new MyCallable();// 4.把Callable任务对象包装成一个未来任务对象// 未来任务对象是啥，有啥用？// 未来任务对象其实就是一个Runnable对象（底层同时实现了Runnable, Future接口）// FutureTask既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值FutureTask<String> task = new FutureTask<>(call);// 5.把未来任务对象包装成线程对象Thread t = new Thread(task, "子线程");// 6.启动线程对象t.start();for(int i = 1 ; i <= 10 ; i++ ){System.out.println(Thread.currentThread().getName()+": " + i);}// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果try {String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）System.out.println(rs);}  catch (Exception e) {e.printStackTrace();}}
}// 1.创建一个线程任务类实现Callable接口，泛型指的是线程返回的结果类型
class MyCallable implements Callable<String>{// 2.重写线程任务类的call方法！@Overridepublic String call() throws Exception {// 需求：计算1-10的和返回int sum = 0 ;for(int i = 1 ; i <= 10 ; i++ ){System.out.println(Thread.currentThread().getName()+": " + i);sum+=i;}return Thread.currentThread().getName()+"执行的结果是："+sum;}
}

运行结果：

main: 7
main: 8
main: 9
main: 10
子线程: 1
子线程: 2
子线程: 3
子线程: 4
子线程: 5
子线程: 6
子线程: 7
子线程: 8
子线程: 9
子线程: 10
子线程执行的结果是：55

3.4 总结

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

4 Java的线程调度策略

• 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
• 对高优先级，使用优先调度的抢占式策略

线程优先级：

• MAX_PRIORITY：10
• MIN _PRIORITY：1
• NORM_PRIORITY：5

涉及的方法：

• getPriority()：返回线程优先值
• setPriority(int newPriority)：改变线程的优先级

说明：
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

5 Java线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

• 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
• 守护线程是用来服务用户线程的，通过在start()方法前调用
• thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
• Java垃圾回收就是一个典型的守护线程。
• 若JVM中都是守护线程，当前JVM将退出。

6 线程的生命周期

Thread.State类定义了线程的几种状态

线程的一个完整的生命周期中通常要经历如下的五种状态：

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

7 线程安全问题（重点）

7.1 什么是线程安全问题？

多个线程同时操作同一个共享资源时可能会出现线程安全问题。
一个经典的例子：多个用户同时取同一个账户中的钱。

线程安全问题大多是由 全局变量 及 静态变量 引起的，局部变量逃逸也可能导致线程安全问题。

如果多线程程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，那这个程序就是线程安全的。

7.2 线程安全问题的解决方案——线程同步

核心思想：让多个线程实现先后依次访问共享资源。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作。

下面就来介绍以下java实现线程同步的三种方式。

7.2.1 同步代码块

代码格式：

synchronized (同步锁对象){// 可能会产生线程安全问题的代码
}

tips：

1. 锁对象可以是任意类型。
2. 多个线程对象要使用同一把锁。
3. 锁对象建议使用共享资源。在实例方法中建议使用this作为锁对象；在静态方法中建议使用类名.class作为锁对象。
4. 锁的范围在锁住所有有安全问题的代码的前提下，越小越好。

7.2.2 同步方法

使用synchronized修饰的方法,就叫做同步方法,保证某个线程执行该方法时,其他线程只能在方法外等着。

同步方法的原理和同步代码块的底层原理其实是完全一样的，只是同步方法是把整个方法的代码都锁起来的。

同步方法其实底层也是有锁对象的：如果方法是实例方法：同步方法默认用this作为的锁对象；如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

public synchronized void method(){// 可能会产生线程安全问题的代码
}

7.2.3 Lock锁

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同
步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的
工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象
加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和
内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以
显式加锁、释放锁。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

• public void lock():加同步锁。
• public void unlock():释放同步锁。

代码格式：

class Demo{private final Lock lock = new ReenTrantLock();public void method(){lock.lock(); // 上锁try{// 可能会产生线程安全问题的代码}catch (Exception e){e.printStackTrace();}finally{lock.unlock(); // 解锁} } 
}

tips：
如果同步代码有异常，要将unlock()写入finally语句块。

7.2.4 锁的选择

Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）。

优先级：
Lock（拓展性好） > 同步代码块（作用范围较小） > 同步方法（作用范围较大）

7.3 锁的释放

释放锁的操作

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

不会释放锁的操作

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

8 线程的通信

（未完待续…）