Java JUC线程池

//创建线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
//使用线程池创建线程
executorService.execute(()->{
            System.out.println(Thread.currentThread().getName() + "ok");
        });
//线程池使用完 使用shutDown()关闭线程池
    executorService.shutdown();
//创建一个单例线程
ExecutorService executorService = Executors.newSingleThreadExecutor();
//使用线程池创建线程的话 就不使用new Thread了  而且使用execute来创建线程
try {
for (int i = 0; i < 10; i++) {
        executorService.execute(()->{
            System.out.println(Thread.currentThread().getName() + "ok");
        });
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
  //线程池使用完 使用shutDown()关闭线程池
    executorService.shutdown();
}

package com.wyh.ThreadPool;
import java.util.concurrent.Executors;
/**
 * @program: JUC
 * @description: 线程池
 * @author: 魏一鹤
 * @createDate: 2022-02-28 22:14
 **/
public class ThreadPoolDemo01 {
public static void main(String[] args){
        //Executors其实就是个工具类,3大方法都在它里面
        //3大方法 1 newSingleThreadExecutor得到一个单一的线程池 这个线程池只有一个线程处理
        Executors.newSingleThreadExecutor();
        //3大方法 2 newFixedThreadPool得到一个固定的线程池大小  参数就是线程池大小
        Executors.newFixedThreadPool(5);
        //3大方法 3 newFixedThreadPool得到一个缓存的线程池 可以伸缩的 遇强则强遇弱则弱
        Executors.newCachedThreadPool();
    }
}

Executors.newSingleThreadExecutor();  //得到一个单一的线程池 这个线程池只有一个线程处理

package com.wyh.ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @program: JUC
 * @description: 线程池
 * @author: 魏一鹤
 * @createDate: 2022-02-28 22:14
 **/
public class ThreadPoolDemo01 {
public static void main(String[] args){
        //创建一个单例线程
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //使用线程池创建线程的话 就不使用new Thread了  而且使用execute来创建线程
        try {
for (int i = 0; i < 10; i++) {
            //使用线程池创建线程的话 就不使用new Thread了  而且使用execute来创建线程
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
  //线程池使用完 使用shutDown()关闭线程池
            executorService.shutdown();
        }
    }
}

package com.wyh.ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @program: JUC
 * @description: 线程池
 * @author: 魏一鹤
 * @createDate: 2022-02-28 22:14
 **/
public class ThreadPoolDemo01 {
public static void main(String[] args){
        //创建一个固定个数的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
//使用线程池创建线程的话 就不使用new Thread了  而且使用execute来创建线程
        try {
for (int i = 0; i < 10; i++) {
            //使用线程池创建线程的话 就不使用new Thread了  而且使用execute来创建线程
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
//线程池使用完 使用shutDown()关闭线程池
            executorService.shutdown();
        }
    }
}

package com.wyh.ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @program: JUC
 * @description: 线程池
 * @author: 魏一鹤
 * @createDate: 2022-02-28 22:14
 **/
public class ThreadPoolDemo01 {
public static void main(String[] args){
        ExecutorService executorService = Executors.newFixedThreadPool(1);
try {
for (int i = 0; i < 10; i++) {
//使用线程池创建线程的话 就不使用new Thread了  而且使用execute来创建线程
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
//线程池使用完 使用shutDown()关闭线程池
            executorService.shutdown();
        }
    }
}

package com.wyh.ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @program: JUC
 * @description: 线程池
 * @author: 魏一鹤
 * @createDate: 2022-02-28 22:14
 **/
public class ThreadPoolDemo01 {
public static void main(String[] args){
            //创建一个可缓存的线程池 会随着线程个数提高并发量 遇强则强遇弱则弱,强弱根据线程数决定
        ExecutorService executorService = Executors.newCachedThreadPool();
try {
for (int i = 0; i < 50; i++) {
//使用线程池创建线程的话 就不使用new Thread了  而且使用execute来创建线程
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
//线程池使用完 使用shutDown()关闭线程池
            executorService.shutdown();
        }
    }
}

//本质 ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize, //核心线程池大小
int maximumPoolSize, //最大线程池大小
long keepAliveTime, //超时等待 (超时了没有还调用会释放)
                          TimeUnit unit, //超时时间单位
                          BlockingQueue<Runnable> workQueue, //阻塞队列
                          ThreadFactory threadFactory, //线程工厂 创建线程的 一般不用动
                          RejectedExecutionHandler handler //拒绝策略) {
if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
            AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}

//使用ThreadPoolExecutor自定义线程池 它有7个参数
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,//核心线程池大小 正常只有2个线程处理
        5, //最大线程池大小  并发量大的时候最多处理的线程数
        3, //等待时间  3
        TimeUnit.SECONDS, //时间单位  秒
        new LinkedBlockingDeque<>(3),//阻塞队列  存放的队列数
        Executors.defaultThreadFactory(),//线程工程  Executors的defaultThreadFactory方法默认创建的线程工厂 一般不用变
        new ThreadPoolExecutor.AbortPolicy());//拒绝策略 如果队列满了 还有队列进来 就不处理满了之后进来的队列,并且抛出异常

Runtime.getRuntime().availableProcessors() //获取cpu处理器个数 也叫CPU密集型
//使用ThreadPoolExecutor自定义线程池 它有7个参数
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,//核心线程池大小 正常只有2个线程处理
       //最大线程数一般写电脑的处理器个数 使用CPU密集型   Runtime.getRuntime().availableProcessors() 获取该电脑有多少cpu处理器
        Runtime.getRuntime().availableProcessors(), //最大线程池大小  并发量大的时候最多处理的线程数
        3, //等待时间  3
        TimeUnit.SECONDS, //时间单位  秒
        new LinkedBlockingDeque<>(3),//阻塞队列  存放的队列数
        Executors.defaultThreadFactory(),//线程工程  Executors的defaultThreadFactory方法默认创建的线程工厂 一般不用变
        //拒绝策略
        // 1 AbortPolicy  如果队列满了 还有队列进来 就不处理满了之后进来的队列,并且抛出异常
        //new ThreadPoolExecutor.AbortPolicy()
        // 2 CallerRunsPolicy 哪来的去哪里 new ThreadPoolExecutor.CallerRunsPolicy
        // 3 DiscardPolicy  队列满了,丢掉多余的任务 不会抛出异常   ThreadPoolExecutor.DiscardPolicy()
        // 4 DiscardOldestPolicy 队列满了,会尝试和旧的队列（最早加入的队列）竞争 也不会抛出异常  new ThreadPoolExecutor.DiscardOldestPolicy()
        new ThreadPoolExecutor.DiscardOldestPolicy());