java多线程基础知识

1|0一，线程安全问题

1|11，线程安全问题概述
  • 首先，什么是线程安全问题呢？

线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。

下面通过一个取钱的案例给同学们演示一下。案例需求如下

场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，
小红和小明同时来取钱，并且2人各自都在取钱100元，可能出现什么问题呢？

如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的

​ ① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。

​ ② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。

​ ③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。

​ ④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-100000。

你会发现，在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱啊！！！

以上取钱案例中的问题，就是线程安全问题的一种体现。

1|22，线程安全问题代码演示

先定义一个共享的账户类

public class Account {
    private double money = 100000;

    public void getMoney() {
            if (money > 0) {
                    try {
                        //浅睡一下   1ms
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                money -= 100000;
                // （2）
                System.out.println(Thread.currentThread().getName()+"取款成功，还剩" + money);
            } else {
                System.out.println("取款失败余额不足");
            }

    }
}

在定义一个是取钱的线程类

class Test {
    public static void main(String[] args) {
        Account account = new Account();
        //通过方法引用传入参数
        // 线程1取钱
        new Thread(account::getMoney).start();
        // 线程2取钱
        new Thread(account::getMoney).start();
    }
}

控制台输出：分析，在线程1取钱，线程0也通过了判断进入然后也取钱。a就为负数了

Thread-1取款成功，还剩0.0
Thread-0取款成功，还剩-100000.0

还有其他的情况，这里再举一个都是-100的例子：

Thread-0取款成功，还剩-100000.0
Thread-1取款成功，还剩-100000.0

在共享账户类中，当两个线程都跑到标号为（2）的位置，这个时候就是账户金额经历了两次的减法，所以就还有-100000，那么两个账户再去获取的时候，就是-100000

1|33，并发和并行

在说并发和并行的含义之前，我们先来了解一下什么是进程、线程？

  • 正常运行的程序（软件）就是一个独立的进程
  • 线程是属于进程，一个进程中包含多个线程
  • 进程中的线程其实并发和并行同时存在（继续往下看）

我们可以打开系统的任务管理器看看（快捷键：Ctrl+Shfit+Esc），自己的电脑上目前有哪些进程。

首先，来学习一下什么是并发？ 强调的是时间段，微观上在一段时间内，几个线程交替执行

进程中的线程由CPU负责调度执行，但是CPU同时处理线程的数量是优先的，为了保证全部线程都能执行到，CPU采用轮询机制为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。（简单记：并发就是多条线程交替执行）

下面，再来学习一下什么是并行？ 强调的是时刻，在同一时间多个线程被执行

并行指的是，多个线程同时被CPU调度执行。如下图所示，多个CPU核心在执行多条线程

那么多线程到底是并发还是并行呢？

其实多个线程在我们的电脑上执行，并发和并行是同时存在的。

1|44，线程同步方案

线程同步的思想

让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。

在这里插入图片描述

等小红线程执行完了，把余额改为0，出去了就会释放锁。这时小明线程就可以加锁进来执行，如下图所示。

采用加锁的方案，就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢？Java提供了三种方案

1.同步代码块
2.同步方法
3.Lock锁

1|55，（ 方案一）同步代码块

同步代码块的作用 就是把访问共享数据的代码锁起来，以此保证线程安全。

原理： 每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
    //...访问共享数据的代码...
}

使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改Account类中的代码即可。

    public void getMoney() {
        synchronized (this){
            if (money > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                money -= 100000;
                System.out.println(Thread.currentThread().getName()+"取款成功，还剩" + money);
            } else {
                System.out.println("取款失败余额不足");
            }
        }
    }

锁对象该如何选择呢？

1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法，建议使用this作为锁对象
3.对于静态方法，建议把类的字节码(类名.class)当做锁对象

1|66，（方案二）同步方法

接下来，学习同步方法解决线程安全问题。其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

    public synchronized void getMoney() {
        if (money > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money -= 100000;
            System.out.println(Thread.currentThread().getName() + "取款成功，还剩" + money);
        } else {
            System.out.println("取款失败余额不足");
        }
    }

那么同步方法有没有锁对象？锁对象是谁？

同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。
1.对于实例方法，锁对象其实是this（也就是方法的调用者）
2.对于静态方法，锁对象时类的字节码对象（类名.class）

对比同步代码块和同步方法那个更好？

1.不存在哪个好与不好，只是一个锁住的范围大，一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住

1|77，（方案三）Lock锁

接下来，我们再来学习一种，线程安全问题的解决办法，叫做Lock锁。

Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
	private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
	 lk.lock(); // 加锁
	 //...中间是被锁住的代码...
	 lk.unlock(); // 解锁

使用Lock锁改写前面Account中取钱的方法，代码如下

    public void getMoney() {
        lock.lock();
        if (money > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            money -= 100000;
            System.out.println(Thread.currentThread().getName() + "取款成功，还剩" + money);
            
        } else {
            System.out.println("取款失败余额不足");
        }
        lock.unlock();
    }

可以试想一下，这种方法没有问题？lock方法是获得这个锁对象，unlock是释放这个锁对象，那么万一在释放锁之前程序已经崩了，那么这个对象就永远也释放不了了。存在很大的缺陷，那么有没有什么解决办法呢？看一下API有没有解决办法。

他让我们放在finally中，这样即使崩了也会释放这个锁

2|0二，线程通信

首先，什么是线程通信呢？

  • 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。

线程通信的常见模式：是生产者与消费者模型

  • 生产者线程负责生成数据
  • 消费者线程负责消费生产者生成的数据
  • 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。

Object类的等待和唤醒方法：

方法名称 说明
void wait() 让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法
void notify() 唤醒正在等待的单个线程
void notifyAll() 唤醒正在等待的所有线程 
注意：上述方法应该使用当前同步锁对象进行调用。

比如下面案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。

在这里插入图片描述

接下来，我们先分析一下完成这个案例的思路

1.先确定在这个案例中，什么是共享数据？
	答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。

2.再确定有那几条线程？哪个是生产者，哪个是消费者？
	答：厨师是生产者线程，3条生产者线程； 
	   顾客是消费者线程，2条消费者线程
	   
3.什么时候将哪一个线程设置为什么状态
	生产者线程(厨师)放包子：
		 1)先判断是否有包子
		 2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待
		 3)有包子时，不做包子了，直接唤醒别人、然后让自己等待
		 	
	消费者线程(顾客)吃包子：
		 1)先判断是否有包子
		 2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待
		 3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待

按照上面分析的思路写代码。先写桌子类，代码如下

public class Desk {
    private List<String> list = new ArrayList<>();

    // 放1个包子的方法
    // 厨师1 厨师2 厨师3
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            // 判断是否有包子。
            if(list.size() == 0){
                list.add(name + "做的肉包子");
                System.out.println(name + "做了一个肉包子~~");
                Thread.sleep(2000);

                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }else {
                // 有包子了，不做了。
                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 吃货1 吃货2
    public synchronized void get() {
        try {
            String name = Thread.currentThread().getName();
            if(list.size() == 1){
                // 有包子，吃了
                System.out.println(name  + "吃了：" + list.get(0));
                list.clear();
                Thread.sleep(1000);
                this.notifyAll();
                this.wait();
            }else {
                // 没有包子
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

再写测试类，在测试类中，创建3个厨师线程对象，再创建2个顾客对象，并启动所有线程

public class ThreadTest {
    public static void main(String[] args) {
        //   需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
        //      2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。
        Desk desk  = new Desk();

        // 创建3个生产者线程（3个厨师）
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师1").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师2").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师3").start();

        // 创建2个消费者线程（2个吃货）
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货1").start();

        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

执行上面代码，运行结果如下：你会发现多个线程相互协调执行，避免无效的资源挣抢。

厨师1做了一个肉包子~~
吃货2吃了：厨师1做的肉包子
厨师3做了一个肉包子~~
吃货2吃了：厨师3做的肉包子
厨师1做了一个肉包子~~
吃货1吃了：厨师1做的肉包子
厨师2做了一个肉包子~~
吃货2吃了：厨师2做的肉包子
厨师3做了一个肉包子~~
吃货1吃了：厨师3做的肉包子

3|0三，线程池

3|11，线程池概述

接下来我们学习一下线程池技术。先认识一下什么是线程池技术？ 其实，线程池就是一个可以复用线程的技术。

要理解什么是线程复用技术，我们先得看一下不使用线程池会有什么问题，理解了这些问题之后，我们在解释线程复用同学们就好理解了。

假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，
下次新的任务过来肯定也会创建新的线程，如果用户量非常大，
创建的线程也就越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。

而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。

但是任务总有被执行完的时候，假设第1个线程的任务执行完了，那么第1个线程就空闲下来了，有新的任务时，空闲下来的第1个线程可以去执行其他任务。依此内推，这3个线程可以不断的复用，也可以执行很多个任务。

所以，线程池就是一个线程复用技术，它可以很好的提高线程的利用率。

3|22，创建线程池

在JDK5版本中提供了代表线程池的接口ExecutorService，对ExecutorService接口中主要的的方法做一个介绍

方法名称 说明
void execute(Runnable command) 执行 Runnable 任务
Future submit(Callable task) 执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown() 等全部任务执行完毕后，再关闭线程池！
List shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。

下面是它的构造器，参数比较多，但是也挺好记忆。根据下面假设的场景来记忆，在一个小公司中

接下来，用这7个参数的构造器来创建线程池的对象。代码如下

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象，从线程工具类中的获取
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

关于线程池，我们需要注意下面的两个问题

  • 临时线程什么时候创建？

    新任务提交时，发现核心线程都在忙、任务队列满了、并且还可以创建临时线程，此时会创建临时线程。

  • 什么时候开始拒绝新的任务？

    核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。

下面对构造方法中的第四个参数和第七个参数做一个说明：

第四个时间的单位：这一看到TimeUnit是一个枚举类，其中包含下面的常量值

在这里插入图片描述

第七个参数：这是ThreadPoolExecutor类的内部类

策略 详解
ThreadPoolExecutor.AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy 丢弃任务，但是不抛出异常 这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy 抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy 由主线程负责调用任务的run()方法从而绕过线程池直接执行

在这里插入图片描述

通过下面的案例对第七个参数进行一个解释：

需求： 使用线程池的继续执行16个打印的任务，打印当前线程的信息以及任务的个数。

public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1, 3, 100,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
            // (1)  new ThreadPoolExecutor.AbortPolicy()  终止策略    默认
            // (2)  new ThreadPoolExecutor.CallerRunsPolicy()
            // (3)  new ThreadPoolExecutor.DiscardOldestPolicy()
            // (4)  new ThreadPoolExecutor.DiscardPolicy()
        );
        for (int i = 1; i <= 16; i++) {
            pool.execute(new MyRunnable(i));
        }
        pool.shutdown();
    }
}
class MyRunnable implements Runnable {
    private int i;
    public MyRunnable(int i) {
        this.i = i;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "  执行了任务" + i);
    }
}

控制台结果如下：

（1）：new ThreadPoolExecutor.AbortPolicy() 当达到了最大线程数，并且队列中也满了的时候，不处理直接报错.

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.yfs1024.demo02_testThreadPoolExecutor.MyRunnable@568db2f2 rejected from java.util.concurrent.ThreadPoolExecutor@378bf509[Running, pool size = 3, active threads = 3, queued tasks = 3, completed tasks = 0]
	at java.base/java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2065)
	at java.base/java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:833)
	at java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1365)
	at com.yfs1024.demo02_testThreadPoolExecutor.TestThreadPoolExecutor.main(TestThreadPoolExecutor.java:22)
pool-1-thread-3  执行了任务6
pool-1-thread-1  执行了任务1
pool-1-thread-2  执行了任务5
pool-1-thread-2  执行了任务4
pool-1-thread-1  执行了任务3
pool-1-thread-3  执行了任务2
// 前几个抢到了资源或者在队列中可以执行

（2） new ThreadPoolExecutor.CallerRunsPolicy()，当线程数达到了maximumPoolSize，并且队列也满了，就让主线程来执行。并且不会漏掉任何一个任务

pool-1-thread-3  执行了任务6
pool-1-thread-2  执行了任务5
pool-1-thread-1  执行了任务1
main  执行了任务7
pool-1-thread-2  执行了任务3
pool-1-thread-3  执行了任务2
pool-1-thread-2  执行了任务8
main  执行了任务11
pool-1-thread-3  执行了任务9
pool-1-thread-1  执行了任务4
main  执行了任务15
pool-1-thread-2  执行了任务10
pool-1-thread-1  执行了任务13
pool-1-thread-3  执行了任务12
pool-1-thread-2  执行了任务14
pool-1-thread-1  执行了任务16

（3）new ThreadPoolExecutor.DiscardOldestPolicy(),当线程数达到了maximumPoolSize，并且队列也满了，此时再有新的任务的时候，就把队列中，最先进入的pass掉。

pool-1-thread-2  执行了任务5
pool-1-thread-3  执行了任务6
pool-1-thread-1  执行了任务1
pool-1-thread-2  执行了任务14
pool-1-thread-3  执行了任务15
pool-1-thread-1  执行了任务16

（4）new ThreadPoolExecutor.DiscardPolicy()，当线程数达到了maximumPoolSize，并且队列也满了，如果再有新的任务，不在搭理，直等到队列有位置的时候

pool-1-thread-1  执行了任务1
pool-1-thread-2  执行了任务5
pool-1-thread-3  执行了任务6
pool-1-thread-2  执行了任务3
pool-1-thread-1  执行了任务2
pool-1-thread-3  执行了任务4

3|33，线程池执行Runnable任务

创建好线程池之后，接下来就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是Callable任务。需要任务的返回值用Callable，不需要用Runnable，上面其实已经用过了。

先准备一个线程任务类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 任务是干啥的？
        System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");
        //为了模拟线程一直在执行，这里睡久一点
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解。

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.DiscardPolicy() //拒绝策略
);

Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！

//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);

//下面2个任务，会被创建的两个临时线程处理
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);

3|44，线程池执行Callable任务

使用线程池执行Callable任务。callable任务相对于Runnable任务来说，就是多了一个返回值。执行Callable任务需要用到线程池中的submit方法

方法名称 说明
Future submit(Callable task) 执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果

先准备一个Callable线程任务

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果。
        // 需求：求1-n的和返回。
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}

再准备一个测试类，在测试类中创建线程池，并执行callable任务。

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        // 1、通过ThreadPoolExecutor创建一个线程池对象。
        ExecutorService pool = new ThreadPoolExecutor(
            3,
            5,
            8,
            TimeUnit.SECONDS, 
            new ArrayBlockingQueue<>(4),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy());

        // 2、使用线程处理Callable任务。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        // 3、执行完Callable任务后，需要通过get()方法获取返回结果。和之前我们用Callable方式一样
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

3|55，线程池工具类 Executors <不推荐>

Java为开发者提供了一个创建线程池的工具类，叫做Executors，它提供了方法可以创建各种不能特点的线程池。如下

方法名称 说明
public static ExecutorService newFixedThreadPool(int nThreads) 创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor() 创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ExecutorService newCachedThreadPool() 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。 
注意 ：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

如果有需要的场景用起来还是挺方便的，每个的测试代码如下：

有一个Runnable的实现类，中间有一个任务：

class MyRunnable1 implements Runnable{
    private int i;

    public MyRunnable1(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->" + i);
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

（1） 创建固定线程数量的线程池 newFixedThreadPool (int nThreads)，这些线程会轮流的把任务执行完

先看源码：

// Executors类中的newFixedThreadPool（）方法
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<Runnable>());
}
// ThreadPoolExecutor中这个构造器的主要创建线程池的方法
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
     //                                拒绝策略使用默认策略
     Executors.defaultThreadFactory(), defaultHandler);

可以看到ThreadFactory使用的是 Executors.defaultThreadFactory()
拒绝策略使用默认策略,即 大于 maximumPoolSize+队列中元素的大小就报RejectedExecutionException
但是这里显然不会，因为队列足够大，没有参数就是Integer.Max 也就是 2的23次方 -1

public class ExecutorsTest {
    public static void main(String[] args) {
        // 得到一个大小为固定为3 的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 1; i <= 10; i++) {
            executorService.execute(new MyRunnable1(i));
        }
//         任务结束之后关闭线程池
        executorService.shutdown();
    }
}

控制台结果：十个任务交替执行，但是始终是三个线程轮流处理任务

pool-1-thread-3--->3
pool-1-thread-2--->2
pool-1-thread-3--->4
pool-1-thread-1--->1
pool-1-thread-3--->6
pool-1-thread-1--->7
pool-1-thread-3--->8
pool-1-thread-1--->9
pool-1-thread-3--->10
pool-1-thread-2--->5

（2）newSingleThreadExecutor() 创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。

源码：队列长度依然是 Integer.MAX，拒绝策略是默认

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,
         new LinkedBlockingQueue<Runnable>()));
}

控制台输出结果：一个线程把所有的任务依次执行

pool-1-thread-1--->1
pool-1-thread-1--->2
pool-1-thread-1--->3
pool-1-thread-1--->4
pool-1-thread-1--->5
pool-1-thread-1--->6
pool-1-thread-1--->7
pool-1-thread-1--->8
pool-1-thread-1--->9
pool-1-thread-1--->10

(3 )newCachedThreadPool() 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。

源码：没有核心线程，全是临时线程，并且没有上限

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

控制台输出结果： 创建了10个线程，来执行这十个任务

pool-1-thread-9--->9
pool-1-thread-10--->10
pool-1-thread-7--->7
pool-1-thread-2--->2
pool-1-thread-3--->3
pool-1-thread-6--->6
pool-1-thread-1--->1
pool-1-thread-8--->8
pool-1-thread-4--->4
pool-1-thread-5--->5

（4）newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
    for (int i = 1; i <= 10; i++) {
        executorService.schedule(new MyRunnable1(i), 10, TimeUnit.SECONDS);
    }
    executorService.shutdown();
}

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

command：执行的任务 Callable或Runnable接口实现类
delay：延时执行任务的时间
unit：延迟时间单位

执行结果：十秒之后五个线程再执行这些任务

// 暂停 10S
pool-1-thread-1--->1
pool-1-thread-4--->3
pool-1-thread-2--->4
pool-1-thread-3--->5
pool-1-thread-5--->2
pool-1-thread-4--->6
pool-1-thread-3--->8
pool-1-thread-1--->7
pool-1-thread-2--->9
pool-1-thread-5--->10

3|66、Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

在阿里巴巴的 开发手册中这样说：

OOM 全称 “Out Of Memory”，表示内存耗尽

在这里插入图片描述

4|0四，线程的生命周期 <重要>

所谓生命周期就是线程从生到死的过程中间有哪些状态，以及这些状态之间是怎么切换的。

为了更好的理解线程的生命周期，先用人的生命周期举个例子，人从生到死有下面的几个过程。在人的生命周期过程中，各种状态之间可能会有切换，线程也是一样的。

Thread的内部中定义了一个枚举类，用来表示线程的六个状态。

​ NEW 、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED

NEW: 新建状态，线程还没有启动
RUNNABLE: 可以运行状态，线程调用了start()方法后处于这个状态
BLOCKED: 锁阻塞状态，没有获取到锁处于这个状态
WAITING: 无限等待状态，线程执行时被调用了wait方法处于这个状态
TIMED_WAITING: 计时等待状态，线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
TERMINATED: 终止状态, 线程执行完毕或者遇到异常时，处于这个状态。

这几种状态之间切换关系如下图所示


__EOF__

本文作者：尼古拉斯_帅气
本文链接：https://www.cnblogs.com/yfs1024/p/17206128.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！
posted @   yfs1024  阅读(18)  评论(0)  编辑  收藏  举报
相关博文：
· java中的特殊文件、日志技术、多线程入门
· 实际线程数量大于maximumPoolSize
· day12-多线程
· 4、多线程
· Java 线程池学习
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！
点击右上角即可分享
微信分享提示