java多线程

哒哒达达哒哒

已于 2022-05-07 15:48:08 修改

阅读量420

点赞数 1

分类专栏：多线程文章标签： java 后端

于 2021-11-08 09:27:25 首次发布

本文链接：https://blog.csdn.net/qq_36016356/article/details/119036317

版权

多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

零、前言

由于一些技术点不太常用或业务上不需要使用，所以变成生疏或遗忘。最近有些时间了，整理了一下，简单的记录下来，做个笔记。越发觉得只有写下来的东西才不会被遗忘。

一、如何创建一个线程

我知道的常用的就是一共三种方式（还有两种是线程池），
要注意如果继承Runnable的话，线程启动时要使用thread.run，
而不是thread.start，如下:

另外可以通过线程池来Executors.newXXXThread(); 
或者可以使用new ForkJoin(num);

public class Thread_01 {
    public void start(){
        //第一种
        Thread thread=new Thread(()-> System.out.println("one..."));
        thread.start(); //start

        new ThreadCus1().run();//run

        new ThreadCus2().run(); //run 或 start
        new ThreadCus2().start();
    }

    //第二种
     static class ThreadCus1 implements Runnable { //继承Runnable

        @Override
        public void run() {
            System.out.println("two...");
        }
    }
    //第三种
     static class  ThreadCus2 extends  Thread{ //继承Thread
         @Override
         public void run() {
             System.out.println("cus2");
         }
     }
    public static void main(String[] args) {
        Thread_01 t=new Thread_01();
        t.start();
    }
}

二、Thread类内部方法

1.Thread.Sleep

Thread.Sleep(xxx)；执行这段代码的线程睡眠多少秒，什么是睡眠，
让出Cpu的使用权，记录当前执行位置，在睡眠时间的定时器结束之后在去抢

2.Thread.yield

1.  Thread.yield();//CPU的使用权让出一下，别人能不能抢到不管
2. 然后自己开抢

3.线程的状态变化

new ，初始态，没有start状态
blocked, 阻塞态
- 当一条正在执行的线程请求某一资源失败时，就会进入阻塞态。
- 而在Java中，阻塞态专指请求锁失败时进入的状态。
- 由一个阻塞队列存放所有阻塞态的线程。
- 处于阻塞态的线程会不断请求资源，一旦请求成功，就会进入就绪队列，等待执行。
wait,等待状态
- 当前线程中调用wait、join、park函数时，当前线程就会进入等待态。
- 也有一个等待队列存放所有等待态的线程。
- 线程处于等待态表示它需要等待其他线程的指示才能继续运行。
- 进入等待态的线程会释放CPU执行权，并释放资源（如：锁）
就绪状态，获得CPU执行权，正在执行的线程。由于一个CPU同一时刻只能执行一条线程，因此每个CPU每个时刻只有一条运行态的线程。
time_waiting状态，和wait差不多，只不过因为线程再wait、join时指定了超时时间。就会进入到该状态中
terminated 终止态，线程执行结束后的状态

（盗图）

在这里插入图片描述

4 .interupt | stop


可以自己看看源码上已经不推荐使用了。

5.join


先看伪代码
Thread t1=new Thread(()->{
     Thread.sleep(1s);
     sout("t1 end");
});
Thread t2=new Thread(()->{
    sout（“t2 start”）
     t1.join();//等待t1完成后再继续进行
     sout("t2 end");
});
t2.start();
t1.start();
最后输出的结果就是 :
t2start
t1end
t2end

以上可以说明 join是等待其他线程完成之后 ,join调用着的线程才继续执行。

6.notify、notifyAll、wait

1.每个对象都有这三个方法，说明每个对象其实都可以作为锁来使用。
2.notify只会通知这个对象上等待的线程队列的第一个线程
3.notifyAll是通知所有这个对象上等待的线程
4.notify和notifyall不会主动让出锁。
5.wait方法会且只会等待其他线程notify或notifyAll后才会继续去抢锁，否则即使其他线程都挂了，
这个wait的线程也会继续wait，造成死锁。
6.notify后使用wait方法，这样可以主动的将锁给别人用，别人用完后 要记得感恩，使用notify或者notifyAll
告诉人家，谢谢你，我已经用完了，你继续用吧

三、synchronized

这里说的是hotspot jvm里的实现
每个对象头上有两位去记录当前持有该对象使用权的线程

锁了谁


  可以写在方法体 、也可以写在方法上，用在不同位置时，
  其锁的对象也不同，比如：
1.  Object o=new object();
    synchronized(o){...}  此时锁定的是 o 这个对象
2.public synchronized void fuck(){...}此时锁的是这个实例化的类对象，
   等同于在方法实现里写synchronize(this)，如果这个类是静态类，那锁的就是T.Class这个对象
3.public synchronized  static void fuck(){...}此时锁的是classLoader加载的类，就是T.Class对象


如果锁的对象本身属性改变，不会有影响，如果变成了其他对象，就完了，所以加上final是比较好的。

可重入锁

可重入锁（也必须是可重入锁）：同一个线程，同步方法m1调用同步方法m2，如果m1和m2使用的是同一把锁，那么就可以直接调用。

如果同步方法中程序出现了异常，会自动释放锁

锁升级

锁升级：
sync (object) 
 1.偏向锁：在第一个线程来访问时，会在对象头上有个markword，记录这个线程的ID，
 如果来一个线程A，线程A的id和对象头上记录的线程id相同，那么该线程就可以继续执行。
 2.自旋锁：如果有其他线程B进来想征用这个锁，就升级为自旋锁，发现这个锁被别人占用着，那线程B就走一个while循环，等着这把锁。
 3.如果B等了很多次后，还没有拿到锁，就升级为重量级锁（就是去操作系统那申请资源）（os锁）

结论： 
a. 锁不能降级、只能升级
b.执行时长，线程数长使用系统锁，执行时间短、线程数少用自旋锁。因为自旋是要消耗cpu资源。

Atomic的实现都是自旋锁。
锁的粒度是指 锁的细化和粗化，如果一个方法中很多的业务，但是只有一小端代码是需要加锁的，那只给这一段代码加锁。

自旋锁的特点

1.sychronized 如果升级到了 悲观锁后（os锁）时，其他抢这把锁的线程是阻塞着，不会消耗cpu。
2.自旋锁（cas：compareAndSet）是通过unsafe实现了原子性，是通过对比期待值的内存地址，
   a.不适应于执行时间长的逻辑块,因为 cas 是判断当前内存是否与期待值内存地址相同来设置目标值，
   如果不是期待值，就重新从主存中get值并设置为新的期待值，此过程一直是一个死循环，对长时间
   拿不到锁的线程来说 需要一直原地打转，对cpu有消耗。
   b.普通的CAS会发生ABA问题,ABA问题就是 一共有3个线程，分别为线程一、二、三，有一个变量m，
   线程一、二的目标是把m的值修改为B，线程三的目标是把m修改为A，这时，线程一和线程二执行时，
   由于一些原因，线程二 阻塞了，线程一执行成功，此时m的值变成了B，这时线程三把m又成功的修改
   为A，线程二开始执行，又将A修改为B。因为线程二执行的时候期待值和主存中的指向的地址都是A，
   这就是ABA问题。
     ABA现实中对应的例子：小明去取钱，想取100块钱，他的银行卡里有150，因为提款机年久失修，他点了一下没反应，他就去旁边的提款机上又点了一次，可以理解为这里是线程二（发生故障的提款机）和线程一（好的替换机），这两个线程同时执行，首先去卡里 get期望值为150，目标值肯定是150-100=50，线程一执行完成后，卡里还剩50块钱，这时线程二突然由于一些原因阻塞了（提款机突然不好使了），本来如果不阻塞的话，线程二目标值是150，结果卡里只剩50了，肯定会执行失败的，但是就真的发生了阻塞（提款机卡），而此时这次小明的朋友 给他转了100块钱（线程三执行并结束），然后线程二不阻塞了，发现卡里真的是150，因为（剩余50+朋友转100），结果线程二（坏提款机）又取出100块钱，这时小明没有发现 之前那个提款机好使了，钱已经取出来，他也没看到。
     ABA的解决方式：对值加上版本号，Atomic中提供了一个带版本号的CAS操作的类：
     AtomicStampedReference,下方图片有简单的实例：

不能lock的对象

不能用String常量，Integer Long ,基础类型中的值只要修改一下后，这个对象就会改变。

四、volatile

原理

1.保证线程可见性
2.禁止指令重排序

解释

1.线程将变量的从公共内存堆中拉到自己私有的工作区后，不能保证下次什么时候再去重新获取这个变量的最新值，所以不能保障当一个线程A修改了变量后，线程B可以立即获取到这个变量最新的值。而volatile可以保障线程之间这个变量的值是最新的。volatile的实现原理是MESI、.CPU的缓存一直性协议

volatile 可以保证线程可见性，但是不具备原子性，所以volatile不能代替synchronize的

2.禁止指令重排序，也是和cpu有关系的，比如代码层面的实现是：

例子一：
a=1;
b=2;
b=4;
cpu为了优化执行效率，很有可能将上述的执行顺序改成
b=2;
b=4;
a=1;

例子二：
Integer a=new Integer(8);
对象创建的过程可以简单分成4步：
1.创建一个栈对象a
2.申请一块内存，并设置初始值为0
3.将内存的值修改为8
4.将栈对象的指针指向这块内存

但是在超高并发的情况有可能出现：
1.创建一个栈对象a
2.申请一块内存，并设置初始化值为0
3.将栈对象的指针指向这块内存
4.指针a指向这块内存

这就是指令排序

结论

Volatile就可以禁止上述的指令重排序,从而在有些情况下线程一创建了一个对象a，线程二判断a是否为空，如果不为空就new一个，反之就返回a，线程一发生了指令重排序，那么线程二可能拿到的a的值是初始化的零，而不是期待的8，如果加上了volatile就不会出现这种情况了

关于volatile 推荐一篇文章：
https://www.zhihu.com/question/329746124

这里写一些自己对volatile不能保证原子性的理解

《深入了解java虚拟机》中说：
 “观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，
 会多出一个lock前缀指令。”
 
 lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：
 
1） 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；
即在执行到内存屏障这句指令时，在它前面的操作已经全部完成。
2）它会强制将对缓存的修改操作立即写入主存；
3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

既然可以保证在修改后 使得其他cpu中缓存行无效，从而会从主存中重新获取变量的值然后拷贝到线程自己的工作
区间，那就可以保证值是最新的啊，为什么还不能保证原子性呢？

答：还有从i++这个操作说起，比如 i 已经被volatile所修饰，i++这个操作大致分为3步。
假设 主存中 i=3;
线程一要去执行i++的操作
1. 获取 i的值 ，即：i =3
2. int tmp=i+1 ,假设这里有个临时变量去存储 i 这个值
3. i = tmp; 将tmp赋值给 i，假设在这一步，还没有把tmp赋值给i，所以不会将i刷新回 主存中，
   此时第二个线程也来操作 i 了，从主存中拿到了 i 的值为3，然后将i 赋值为了10，即执行了
   i=10的操作，并将i=10写回了主存，这时 线程二执行了写操作，会让线程一种的缓存行无效，
   也就是i=3的值在线程一中已经无效了，如果此时此刻，我们去执行tmp =i +1,那么 发现 i 的缓存无效
   后，就会去主存中拿i=10这个值，但是我们的线程一 都已经执行完tmp=i+1=4的操作了 ，
   已经不需要 get  i 的值了，所以接下来会执行 第三部 i=tmp 的命令，将 i 变成了 4，然后写回主存，
   这时主存上的i 变成了 4，显然 线程一和线程二的操作无法让i++ 保证原子性。
   也就是说 写操作的确会让其他cpu中对应的缓存行无效，但是如果其他cpu中已经使用过了这个
   缓存行（已经完成计算了），即使缓存行无效了 ，对人家也没有什么影响。并不能让人家cpu重新计算。

五、Atomic | CAS

能够保证原子性，因为他的操作都是CAS（优化自旋），没有加锁，
没有使用操作系统线程。
使用cpu原语进行读->比较->写

1.compareAndSet

看一段代码

在这里插入图片描述

上述的计算结果还是1，因为期待值是2，所以如果当前值和期待值
不一样的话，就不会修改这个值。如果是期望的值，说明没有人在我之前改过，

cas之后会细致更新一下

六、基于cas的一些新的锁

1.ReenTrantLock

reenTrantLock还是和synchronized进行对比比较好

1.sync和reenlock都是独占锁，但当sync抢锁失败时会一直阻塞，
而后者通过tryLock方法抢锁失败时，会自动放弃，且可以指定尝
试抢锁的时间，但要注意的一点是：当tryLock的结果为false时 使
用lock.unlock会出异常

2.sync不需要手动的去释放锁，当占用锁的线程发生异常或线程
结束后会自动释放锁，但是reenlock需要在finaly中是显式的调用
lock.unlock();

3,reenlock可以可以监听线程的异常而自动释放锁,之后展开说

4.reenTrantlock可以指定公平和非公平锁。当为公平锁时，持有该锁的线程调用unlock时，
会从等待队列acquireQueue中拿出head节点，使用lockSupport.unpark激活该等待的线程（其实
这个过程中还要判断是否超时等问题）
当为非公平锁时，没有上述步骤，也就是说公平与非公平实际上是一个双向的链表来维护的。

原理
reenTrantLock的原理是AQS（AbstractQueuedSynchroizer）
画了一个简单的图。
在这里插入图片描述
简单说一下lock.lock()的过程

在这里插入图片描述

2.countDownLaunch

我把它当做一个线程安全的计数器，不需要自己加锁来保证线程的安全，我用它写过让多个线程来分别执行一个事务，当某线程发生异常时，让所有事务回滚，反之所有线程提交事务，主线程await来控制是否执行回滚或者提交。

先上图
在这里插入图片描述

上图中 实例化了一个计数器，可计数为3，创建了三个线程，每个线程执行完后减一，主线程使用await
方法进行阻塞，等三个线程执行完后，阻塞解除并打印 “end wait”，切记是await，不是wait方法

同理可以使用 join来代替countdownlanch, 即：在await代码块上 将3个子线程join一次后，即等待3个子线程都结束后主线程再解除阻塞，如下图代码

在这里插入图片描述

但是countDown更灵活一些，完成可以在一个子线程中countDown 3次，这样也可以解除主线程上await
方法的阻塞

3.CyclicBarrier

循环栅栏，满足了阀值就把栅栏推倒，然后再立起来。我的理解就是人够了就发车

设置一个阀值，当await次数到达了这个阀值后，就会调用这个 Runable实现中的内容，下图例子中是打印了一条
消息“够了，老铁”，循环了101次后，打印了5次。

在这里插入图片描述

变换一下，在一个线程中for缓存101次，如下图：

在这里插入图片描述

会发现并不能打印出信息，说明这个await只在使用不同的线程调用时才会生效

Guava RateLimiter

4.Phaser

Phaser 是让n个线程 按自己设定的阶段 按阶段执行，当线程数量到达了 指定的数量后，就会触发一次
阶段实现，然后可以选择前往下一个阶段或者离开注册。
通过
phaser.bulkRegister（数量）指定当前有多少线程时前往下一个阶段
phaser.arriveAndAwaitAdvance方法可以等待线程达到数量并前往下一个阶段
phaser.arriveAndDeregister 可以取消前往下一个阶段
继承Phaser类，重写onAdvance方法来控制在不同阶段时需要触发的实现
额外要说一点，arriveAndDeregister只能在最后一个阶段使用，在中间阶段使用时会报错（后续研究一下）
简单呈现一下代码，如下

public class TestPhaser_01 {
    MyPhaser p;
    private int id;

    public TestPhaser_01(int id, MyPhaser p) {
        this.p = p;
        this.id = id;
    }

    void origin() {
        a();
        b();
        c();
    }

    void a() {
        System.out.println(id + " finish  a");
        p.arriveAndAwaitAdvance();
    }

    void b() {
        System.out.println(id + " finish  b");
        p.arriveAndAwaitAdvance();
    }

    void c() {
        System.out.println(id + " finish  c");
        if (id == 3 || id == 4)
            p.arriveAndAwaitAdvance();
        else
            p.arriveAndDeregister();
    }
    public static void main(String[] args) {
        MyPhaser myPhaser = new MyPhaser();
        myPhaser.bulkRegister(7);

        for (int i = 0; i < 7; i++) {
            int tmp = i;
            Thread t = new Thread(() -> {
                TestPhaser_01 p = new TestPhaser_01(tmp, myPhaser);
                p.origin();
            });
            t.start();
        }
    }

    static class MyPhaser extends Phaser {

        @Override
        protected boolean onAdvance(int phase, int registeredParties) {
            switch (phase) {
                case 0:
                    System.out.println("第一阶段完成，当前参与人数为 ：" + registeredParties);
                    return false;

                case 1:
                    System.out.println("第二阶段完成，当前参与人数为 ：" + registeredParties);
                    return false;

                case 2:
                    System.out.println("第三阶段完成，当前参与人数为 ：" + registeredParties);
                    return true;
                default:
                    return true;
            }
        }
    }
}

5.重点：读写锁 ReadWriteLock

读锁：共享锁
写锁：排他锁=互斥锁

先说使用的原因

如果是使用ReenTrantLock时，这个锁 的 读读、读写、写写三种不同操作时都是互斥的，
所以效率比较低，那如果我们的读操作可以采用共享锁，只有写操作是排他锁，那么就
可以在读操作很多，写操作少的时候大大的提高效率，因此引出了ReadWriteLock，使用
起来很简单。只需要实例化一个对象，并在读方法时使用readLock对象进行lock，写方法
时使用writeLock对象进行lock就可以了

 public class ReadWriteLock_01 {
    public static void main(String[] args) {
        ReadWriteLock lock = new ReentrantReadWriteLock();
        
        Lock readLock = lock.readLock();
        Lock writeLock = lock.writeLock();
        
        read(readLock);
        write(writeLock);
    }

    static void read(Lock lock) {
        lock.lock();
        System.out.println("read");
    }

    static void write(Lock lock) {
        lock.lock();
        System.out.println("write");
    }
}

6.Semaphore

主要用途就是限流，n个线程，但是程序要求最多每次过m个线程，与线程池概念不同。
可以类比高速公路的收费站，一共5个收费口，就是限流。

下面是示例
在这里插入图片描述

7.Exchanger

我的理解是两个线程想要交换数值，先想交换的线程等待第二个线程完成交换后再继续执行
示例如下图
在这里插入图片描述

8.LockSupport

1.某线程内可以直接使用LockSupport的静态方法.park();来暂停当前线程
2.可以在其他线程中使用LockSupport的静态方法unPark（object t） 并将 某线程对象 作为参数传入,
可以让某线程继续运行，但是 同等条件下 却不能让线程t park。

在这里插入图片描述

七、java中的引用类型

1.分别四种类型：分别为: 强引用、软引用、弱引用，虚引用

1.new 出来的对象为强引用
2.softReference 创建出的对象为 软引用，它在gc时可能不被回收，只有在内存不够时才会回收
3.weakReference创建出来的对象为弱引用，gc时必被回收。一般用于容器中
4.虚引用用来直接内存中，比如jvm中的DerectByteBuffer，这部分内存是操作系统管理的，不属于虚拟机，虚引用的对象会将回收后的对象放入一个队列中。

举个weakReference的例子

public class WeakReference_02 {

    //继承弱引用类型
    static class Entry extends WeakReference<Car>{

        private String color;
        //entry作为一个弱引用对象 引用 着car
        public Entry(Car referent,String color) {
            super(referent);
            this.color=color;
        }
    }

    public static void main(String[] args) {
        Car car=new Car();
        car.setAge(1);
        car.setName("哈弗");

        Entry entry=new Entry(car,"黑色");

        car=null; //取消car 指针对car对象的强引用，此时只有entry这个弱应用对象 引用了car
        System.gc();//发生gc，car就会被回收，注意不是entry被回收，是entry引用的car被回收了
        while(true){

            if(null==entry.get()){
                System.out.println("回收");
                return;
            }
        }

    }
}

class Car{
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

以上例子可以感受到，弱引用类型的用户，例如threadLocal, 当某业务代码块中创建了一个threadLocal对象，此时对该对象是强引用，方法结束后，会自己将指向该对象的强引用指针从方法栈中弹出，此时就没有 强引用的指针指向该对象了，但是 thread内部有个threadLocalMap，本质是一个保存键值对的数组，键值对的类型为entry，键类型为threadLocal，entry是一个弱引用类型，引用了threadLocal，当我们业务代码结束后，就只有entry这个弱引用对象应用了threadLocal,所以gc后，该threadLocal就会被回收，但是entry这个弱引用对象不会被回收，如果entry不是弱引用类型，那么threadLocal就被强引用了，gc时也不会被回收，而entry被线程持有，线程可能一直存活在整个程序的运行过程中，就可能发生内存泄露

ThreadLocal源码

和它的名字一样，线程私有，同一个ThreadLocal对象被不同的线程修改后 
就有不同的值，使用后一定要调用 remove方法，不然map中会有大量
null key的情况

下图描述了一下 ThreadLocal的源码实现图，已经为什么entry继承了WeakReference的原因，但是threadLocal 使用完之后要调用remove方法，该方法会将threadLocal从map中移除。

在这里插入图片描述

八、线程池

阿里规范中要求不可以使用Excutors提供的线程池，因为queue的
长度最长为Integer.max，如果到了这个值后就会OOM。

1.Runnable、Callable、Future

1.Runnable和Callable用途是一样的，执行一段想执行的逻辑，但是后者可以拥有返回值
2.Future 提供了拥有阻塞功能的get方法，举个例子，主线程中创建了一个线程池，主线程交了线程池一个任务：让它去把地球挖穿，线程池立刻将Future对象返回给了主线程，并说道：我们即将出发了，你该干什么就干什么去吧，实在没意思的话，你就用这个future.get()方法看我们挖，但是只要开始看就不能停下来了，直到我们挖穿地球为止，这时候主线程心想太好了，就去看了一会片儿，又吃了个苹果，顺便和邻居又生了个孩子，所有琐事都做完后，没事干了，实在太无聊了，那就看看他们挖怎么样了吧，于是调用了future.get(),  看了几分钟后 主线程又点后悔，但是他除了观看以外（阻塞），什么都不能做了，直到线程池挖穿了地球后，主线程才可以去做其他事情。
以上主线程 这样就实现了异步的效果，以下是示例代码

在这里插入图片描述
以上代码执行结果：

另外还有一些类是三者混合的衍生类，需要时可以自己看源码使用一下。

2.ThreadPoolExecutor 线程池

3. 线程池的几种状态

盗图一下
在这里插入图片描述

   解释一下shutDown状态和stop状态
   stop是既不接受新的任务，也要干掉正在执行的任务
   shutDown是不接受新的任务，但是把正在执行的任务执行完
   之后工作线程数为0后，进入Tidying状态，然后执行钩子函数terminated（没有实现，有需要可以去重写。

4. Executors

	这是一个工厂模式的工具类，里面提供了一些创建线程池的方法，包括：

1.Executors.newFixedThreadPool

 1. 创建一个指定核心线程数量=最大线程数
 2. 使用链表形式，长度为integer.max_value的阻塞队列的线程池
 3.可以看到队列中装的元素是runable类型
 4.当工作任务很多，耗时长，工作线程少时，会导致大量的任务堆积，因为该队列能储存 2^32-1个任务
   很可能造成内存溢出

 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,               
                                      new LinkedBlockingQueue<Runnable>());
  }

2.Executors.newSingleThreadExecutor

先看内部实现

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

发现核心线程数=最大线程数=1
也是链表类型的阻塞队列

3. Executors.newCachedThreadPool

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

可以看到没有核心线程数
最多可以创建Integer.max_value个线程
使用的是同步队列
就是说来一个任务，就创建一个线程（如果有其他线程完成任务了并且闲置时间没有超过60s，那就用这个闲置线程）来处理这个任务。

4. Executors.ScheduledThreadPool

 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

可以看出，核心线程数是指定的
最大线程数为Integer.MAX_VALUE
使用的是等待队列

5.Executors.newWorkStealingPool

 public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

可以看出实际上是创建了一个forkjoinpool，它其实一个窃取线程池，就是我干完了，我就帮你干。
之前写过一个功能是10个线程，每个线程干10个事，有的线程干的快，自己很快就干完了，他就去其他线程负责的队列中去拿任务，帮他干干，很有爱的一群线程。可以单独了解了解。

5. 线程池的构造函数

先看源码

 public ThreadPoolExecutor(int corePoolSize, //核心线程数
                          int maximumPoolSize,//最大线程数
                          long keepAliveTime,//非核心线程闲置时间
                          TimeUnit unit,//时间单位
                          BlockingQueue<Runnable> workQueue,//用什么队列保存工作任务（runable）
                          ThreadFactory threadFactory,//用来生成线程的线程工厂
                          RejectedExecutionHandler handler) //拒绝策略

解释一下

什么是核心线程数，就是它不会因为完成任务而销毁，跟随线程池的生命周期走。
什么是最大线程数，就是当队列中储存的任务已满，核心线程们又都在忙碌着，这时候就
新建一个线程，但是此处活动中的总的线程数不能大于该线程数。不过有一种情况就是定义的
线程池的核心线程数本来就是零，那么拿出一个线程来处理这个事。
阻塞队列，可以选择有界的ArrayBlockQueue,链表的linkedBlockQueue，同步队列等
拒绝策略，包括不处理该任务并抛出异常（或不抛出异常），或替换掉最老的任务，或者交给调用线程处理，也可以自定义拒绝策略
线程工程，可以参考Executors.defaultThreadFactory来定义一个，主要是我们要对线程的名称进行自定义。

上一些感觉比较好的连接

第一篇文章比较细，第二篇文章也可以看看，第三个我还没看

https://blog.csdn.net/LitterLy/article/details/107357979
https://blog.csdn.net/weixin_43934607/article/details/109089137
https://www.jianshu.com/p/a977ab6704d7