一、线程池

ThreadPoolExecutor构造方法的参数

将线程池比作一个公司，每个线程比作一个员工

corePoolSize: 核心线程的数目（一旦创建，永不销毁，正式员工，不会被辞退）
maximumPoolSize:核心线程和非核心线程的总数目（非核心线程：一段时间不工作就销毁，临时工：摸鱼太久就滚蛋）
keepAliveTime：允许非核心线程不工作的时间（允许临时工摸鱼的时间）
unit：控制keepAliveTime的单位（分，秒，毫秒或者其他值）
workQueue：阻塞队列，组织了线程要执行的任务
ThreadFactory：线程的创建方式
RejectedExecutionHandler：拒绝策略（当我们的阻塞队列满了的时候又来了一个新的线程）

AbortPolicy()  抛出异常
CallerRunsPolice()  调用者处理
DiscardOldestPolicy()  丢弃队列中最老的任务
DiscardPolicy()  丢弃最新来的任务

Executors

由于ThreadPoolExecutors使用起来比较复杂，标准库又提供了一组Executors类，这个类相当于封装的ThreadPoolExecutors。这个类相当于一个工厂类，可以创建出不同风格的线程池实例。

1.newFixedThreadPool:创建出一个固定线程数量的线程池。(没有临时工版本)
2.newCachedThreadPool: 创建一个线程数量可变的线程池（没有正式工版本）
3.newSingleThreadPool:创建出一个只包含一个线程的线程池
4.newScheduleThreadPool:能够设定延时的线程池（插入的线程可以等一会儿执行）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ClassName ThreadExecutors
 * @Description 使用Executors类创建线程
 * @Author Rcy
 * @Data 2022/3/9 13:40
 */
public class ThreadExecutors {
    public static void main(String[] args) {
        //没有临时工版本
        //ExecutorService表示一个线程池的实例
        //ExecutorServiced的submit方法可以给线程提交若干任务
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for ( int i = 0; i < 20; i++) {
            int finalI = i;
            executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务" + finalI);
            }
         });
        }
    }
}

到底使用哪种方法建造我们的线程池呢？答案很简单，复杂问题用复杂版本的，简单问题用简单版本的。

二、如何实现一个线程池

import javafx.concurrent.Worker;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * @ClassName MyThreadPool
 * @Description 我的线程池
 * @Author Rcy
 * @Data 2022/3/9 15:18
 */

public class MyThreadPool {
     static  class  Worker extends  Thread{
         private BlockingQueue<Runnable> blockingQueue=null;
         //通过这个构造方法把任务队列传进来
         public Worker(BlockingQueue<Runnable> blockingQueue) {
             this.blockingQueue=blockingQueue;
         }
         @Override
         public void run() {
             //工作线程具体的逻辑
             //需要从阻塞队列当中取任务并且执行
             while(true){
                 try {
                     Runnable command=blockingQueue.take();
                     command.run();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
     static  class ThreadPool{
         //包含一个阻塞队列用来组织任务（任务队列）
         private BlockingQueue<Runnable> blockingQueue= new LinkedBlockingDeque<>();

         //这个list用来存放当前工作的线程（我们只使用他的长度）
         List<Thread> workers = new ArrayList<>();

         private static  final  int MIX_WORKER_COUNT=10;

         //通过submit把任务加入线程池
         //不仅可以把任务放入阻塞队列，还可以创建线程
         public void submit(Runnable command) throws InterruptedException {
             if(workers.size()<MIX_WORKER_COUNT){
                 //如果小于我们就要创建一个新的线程并且加入我们的线程队列中
                 //Worker内部要取到队列的内容，就要把这个队列实例通过构造方法传过去。
                 Worker worker = new Worker(blockingQueue);
                 worker.start();
                 workers.add(worker);
             }
             //把任务放入阻塞队列
             blockingQueue.put(command);
         }
     }

    public static void main(String[] args) throws InterruptedException {
            ThreadPool threadPool = new ThreadPool();
        for (int i =0;i<100;i++) {
            int finalI = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(finalI);
                }
            });
        }
    }
}

三、常见的锁策略

1.乐观锁和悲观锁

乐观锁：
假设锁冲突的概率很低，甚至不会发生冲突，所以在数据提交更新的时候才会进行并发冲突检测，如果发生锁冲突，则返回错误信息，让用户决定如何去做。

乐观锁的一个重要功能就是要检测出数据是否发生冲突，我们需要引入一个‘“版本号”来进行解决，每次线程执行完操作的时候都将自己的版本号加一。
当有两个线程同时想修改一个数据的时候，只有提交的版本号大于当前主内存中存储的版本号才能执行更新。

悲观锁：
假设锁冲突的概率很高，每次拿数据都会被别人修改，所以每次在拿数据的时候都会加锁，这样别人想拿这个数据就要阻塞直到我用完。

2.读写锁

先清晰一个概念：

两个线程都只读一个数据，此时不涉及线程安全问题
两个线程一个读一个写，有线程安全问题
两个线程都写，有线程安全问题

读写锁就是把读操作和写操作区别开，在加锁期间额外表明加锁意图，读操作之间不互斥，写操作与任何人互斥。Java标准库提供了一个ReentrantReadWriteLock类实现读写锁
ReentrantReadWriteLock.ReadLock表示读锁，这个对象提供了lock() 和 unlock() 方法进行加解锁。
ReentrantReadWriteLock.WriteLock表示写锁，这个对象提供了lock() 和 unlock() 方法进行加解锁。

Synchronized不是读写锁，他没有读写的区分，一旦使用必定互斥。