java 多线程编程（包括创建线程的三种方式、线程的生命周期、线程的调度策略、线程同步、线程通信、线程池、死锁等）

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 static void sleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
• public static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程；若队列中没有同优先级的线程，忽略此方法。

实例方法

• public String getName():获取当前线程名称。
  线程存在默认名称：
  子线程的默认名称是：Thread-索引；
  主线程的默认名称就是：main；
• public void setName(String name):设置该线程名称
• public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run():此线程要执行的任务在此处定义代码。
• public final void join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止（低优先级的线程也可以获得执行）
• public final void stop(): 强制线程生命期结束，不推荐使用
• public final boolean isAlive()：返回boolean，判断线程是否还活着

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

3.1 继承Thread类

具体步骤：

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

优缺点
优点：编码简单，如果需要访问当前线程，则无须使用Thread.currentThread()方法，直接使用this即可获得当前线程。
缺点：线程类已经继承了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()方法
    @Override
    public 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方式相比复杂了一丢丢，如果需要访问当前线程，则必须使用Thread.currentThread()方法。

代码示例：

// 1。定义子类，实现Runnable接口
class MyRunnable implements Runnable{
    // 2.重写该接口的run()方法
    @Override
    public 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() {
            @Override
            public 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接口 ， 申明线程执行的结果类型，并重写线程任务类的call方法。
2. 创建一个Callable实现类的实例。
3. 把Callable的线程任务对象实例包装成一个FutureTask未来任务对象实例，并以此实例作为Thread的target来创建Thread对象。
4. 调用线程的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方法！
    @Override
    public 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 线程的生命周期

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

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

java.lang.Thread.State这个枚举类中给出了六种线程状态，与传统的五种状态一些许差异，可以通过IDEA等集成开发环境查看java源码，下面给出了源码翻译：

• 新建（NEW）：线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread只有线程对象，没有线程特征。
• 可运行（RUNNABLE）：线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
• 锁阻塞（BLOCKED）：当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
• 无限等待（WAITING）：一个线程在调用wait(不带参数)后会进入Waiting状态，等待另一个线程执行一个（唤醒）动作时。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。锁会释放。
• 计时等待（TIMED_WAITING）：同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait（带参数）。锁不会释放。
• 被终止（TERMINATED）：因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。
  

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 ，是可重入、互斥、实现了Lock接口的锁，它与synchronized具有相同的基本行为和语义，并且扩展了其能力。

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 线程的通信

线程通信实际上是一种等待唤醒机制。

8.1 核心方法

• wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
• notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
• notifyAll ()：唤醒正在排队等待资源的所有线程结束等待。

tips:

• 线程通信前一定要保证线程安全，否则毫无意义。
• 这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。
• 因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。