javaSE学习笔记（八）-多线程

目录

九、多线程

1.概述

线程

多线程并行和并发的区别

Java程序运行原理

多线程为什么快

如何设置线程数比较合理

CPU密集型程序

I/O密集型程序

注意

线程的五种状态

新建状态（new）

就绪（runnable）

运行状态（running）

阻塞状态（blocked）:

终止状态（terminated）

线程方法

2.多线程实现方式

多线程程序实现的方式1 继承Thread

多线程程序实现的方式2 实现Runnable接口

多线程的实现方式3，实现Callable接口

三种方式的区别

多线程的实现方式4，线程池

3.线程安全问题

4.线程同步

5.死锁

6.线程池

概述

使用线程池的好处

线程池体系结构

线程池参数理解

线程池工作原理

基本使用

其它的内置功能线程池

总结

线程池提交任务，任务代码抛出异常会怎么样

线程池两种提交任务方式的区别

7.ThreadLocal

概述

ThreadLocal与Synchronized的区别

ThreadLocal的简单示例

ThreadLocal常见使用场景

如何正确的使用ThreadLocal

内存泄漏原因

ThreadLocal哈希冲突解决方案：线性探测

如果想共享线程的 ThreadLocal 数据怎么办

8.CountDownLatch

概念

两种用法

9.CyclicBarrier

10.Semaphore

11.@Async-方法默认异步执行

---

九、多线程

1.概述

线程

线程是程序执行的一条路径，一个进程中可以包含多条线程

多线程并发执行可以提高程序的效率，可以同时完成多项工作

多线程并行和并发的区别

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行，需要多核CPU的支持

并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行

比如跟两个人聊天，左手操作一个电脑跟甲聊，同时右手操作另一台电脑跟乙聊天，这就叫并行

如果先给甲发个消息，然后再给乙发个消息，然后再跟甲聊，再跟乙聊，这就叫并发

Java程序运行原理

Java命令会启动JVM（java虚拟机），即启动了一个进程，该进程会自动启动一个主线程，然后主线程去调用某个类的 main 方法

JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的，垃圾回收线程会和主线程并发执行

多线程为什么快

充分利用CPU和I/O

CPU密集型程序，I/O在短时间内完成，CPU有相对大量运算要处理

I/O密集型程序，CPU运算短时间完成，I/O相对占用更长时间

如何设置线程数比较合理

CPU密集型程序

单核CPU：由于每个线程都需要长时间占用CPU才能完成任务，所以单核CPU多线程对速度提升不明显

多核CPU：通常保持线程数=核心数+1，最大化利用CPU核心数，只要有需要就不让任何核心处于长期空闲，多开一条是为了保持异常情况下也能有任务补充进CPU

I/O密集型程序

单核CPU

由于每个线程在执行过程中CPU都存在较长空闲时间所以单核CPU多线程也能提升速度，显然，同样的任务，CPU空闲的越久，应开的线程就越多

假设CPU运算时长为X，I/O是CPU运算时间的两倍即2X，那么整个程序执行就是3X，那么为了3X时长内CPU尽可能的在运算而不是空闲，显然应开三条线程

多核CPU

和单核一样的逻辑，每多一个核心，多开单核情况的的一倍

通常保持线程数=核心数×（1/CPU利用率）=核心数×（1+IO时长/CPU运算时长）

这样的理论只是估算，实际执行速度受多方综合影响，实际上线程开多少条还是需要在估算值的基础上进行一定量的测试

注意

多线程会带来并发问题，如无必要，尽量不要使用多线程，尤其是存在共享数据时

线程的五种状态

新建状态（new）

使用 new 创建一个线程，仅仅只是在堆中分配了内存空间

新建状态下，线程还没有调用 start()方法启动，只是存在一个线程对象而已

Thread t = new Thread();//这就是t线程的新建状态

就绪（runnable）

新建状态调用 start() 方法，线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源

注意：线程对象只能调用一次 start() 方法，否则报错：illegaThreadStateExecptiong

运行状态（running）

线程获得CPU资源正在执行任务（run()方法）

阻塞状态（blocked）:

正在运行的线程因为某种原因放弃 CPU，暂时停止运行，就会进入阻塞状态

此时 JVM 不会给线程分配 CPU，直到线程重新进入就绪状态，才有机会转到运行状态

注意：阻塞状态只能先进入就绪状态，不能直接进入运行状态

阻塞状态分为多种情况，举例：

同步锁：当线程 A 处于可运行状态中，试图获取同步锁时，发现锁已经被 B 线程获取，此时 JVM 把当前 A 线程放入锁池中，A线程进入阻塞状态

IO 请求：当线程处于运行状态时，发出了 IO 请求，此时线程进入阻塞状态

计时等待timed waiting：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态

等待waiting：调用wait()方法(JVM 把该线程放入等待池中)（调用notify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法（调用resume()方法恢复），调用join()方法

终止状态（terminated）

通常称为死亡状态，表示线程终止

正常终止，执行完 run() 方法，正常结束

强制终止，如调用 stop() 方法或 destory() 方法

异常终止，执行过程中发生异常

线程方法

Thread.currentThread() 获取当前线程对象

getName() 获取线程名

setName(String name) 设置线程名

sleep(long millis) 线程休眠：让执行的线程暂停一段时间，进入计时等待状态

调用此方法后，当前线程放弃 CPU 资源，在指定的时间内，sleep 所在的线程不会获得可运行的机会，此状态下的线程不会释放同步锁

wait() 线程等待：一旦一个线程执行到wait()，就释放当前的锁

注意：此方法必须在同步代码块或同步方法中

sleep() 和 wait() 的区别：sleep指定时间内当前线程放弃 CPU 资源，线程不会释放同步锁，wait 会放弃 CPU 资源，同时也会放弃 同步锁

notify()/notifyAll() 唤醒：唤醒wait的一个或所有的线程

注意：此方法需和wait()成对使用，必须在同步代码块或同步方法中

join() 联合线程：表示这个线程等待另一个线程完成后（死亡）才执行，join 方法被调用之后，线程对象处于阻塞状态，写在哪个线程中，哪个线程阻塞（调用join()的线程运行）

这种也称为联合线程，就是说把当前线程和当前线程所在的线程联合成一个线程

yield() 礼让线程：表示当前线程对象提示调度器自己愿意让出 CPU 资源

调用该方法后，线程对象进入就绪状态，所以完全有可能：某个线程调用了 yield() 方法，但是线程调度器又把它调度出来重新执行

sleep() 和 yield() 方法的区别：

都能使当前处于运行状态的线程放弃 CPU资源，把运行的机会给其他线程

sleep 方法会给其他线程运行的机会，但是不考虑其他线程优先级的问题；yield 方法会优先给更高优先级的线程运行机会

调用 sleep 方法后，线程进入计时等待状态，调用 yield 方法后，线程进入就绪状态

setDaemon(Boolean boolean) 守护线程：设置一个线程为守护线程，该线程不会单独执行，当其他非守护线程都执行结束后，自动退出，当其他线程没有退出时，守护线程正常执行

volatile标志位 用来中断线程

interrupt中断机制 用来中断线程

2.多线程实现方式

多线程程序实现的方式1 继承Thread

定义线程类继承Thread，重写run方法

创建对象，start()开启新线程, 内部会自动执行run方法

每一个thread只能被start()一次

public static void main(String[] args) {
    MyThread mt = new MyThread();    //4.创建自定义类的对象
    mt.start();                      //5.开启线程
    
    //匿名内部类的方式
    new Thread() {				//1.new 类(){}继承这个类
        public void run() {		//2.重写run方法
            for(int i = 0; i < 3000; i++) {//3.将要执行的代码,写在run方法中
            	System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
            }
        }
    }.start();
}

class MyThread extends Thread {          //1.定义类继承Thread
    public void run() {                  //2.重写run方法
        for (int i = 0; i < 3000; i++) { //3.将要执行的代码,写在run方法中
            System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        }
    }
}

多线程程序实现的方式2 实现Runnable接口

定义线程类实现Runnable接口，重写run方法；创建自定义的Runnable的子类对象，创建Thread对象, 传入Runnable对象；

调用start()开启新线程, 内部会自动调用Runnable的run()方法

原理：实际上是Thread的run()方法中调用了Runable的run()方法

public static void main(String[] args) {
    MyRunnable mr = new MyRunnable();      //4.创建自定义类对象
    //Runnable target = new MyRunnable();
    Thread t = new Thread(mr);             //5.将其当作参数传递给Thread的构造函数
    t.start();                             //6.开启线程
    

    //匿名内部类的方式		
    new Thread(new Runnable(){		//1.new 接口(){}实现这个接口
        public void run() {		//2.重写run方法
            for(int i = 0; i < 3000; i++) {//3.将要执行的代码,写在run方法中
            	System.out.println("bb");
            }
        }
    }).start(); 
}


class MyRunnable implements Runnable {     //1.自定义类实现Runnable接口
    @Override
    public void run() {                    //2.重写run方法
        for (int i = 0; i < 3000; i++) {   //3.将要执行的代码,写在run方法中
            System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        }
    }
}

多线程的实现方式3，实现Callable接口

定义线程类实现Callable接口，重写call()，call()可以有返回值

创建Callable接口的实现类的实例，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值

使用FutureTask对象作为Thread类的构造函数的target参数创建并启动线程

调用FutureTask对象的get()来获取子线程执行结束的返回值

这种方式实际上几乎不用，因为代码复杂，多线程程序一般也不需要获取返回值

public static void main(String[] args) {
    Callable