JUI（6）线程池

文章目录

• 1、SynchronousQueue
• 2、线程池（重点）
• • 2.1 使用单例
  • 2.2、使用固定大小的线程
  • 2.3、缓存线程池
  • 2.4 七大参数

1、SynchronousQueue

package com.blockingqueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
/**
 * 同步队列  SynchronousQueue不存储元素，put了一个元素，必须从里边先取出来，然后再放入
 */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();//同步队列
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"put2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"put3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}

2、线程池（重点）

线程池：三大方法、7大参数、4种拒绝策略

池化技术
程序的运行、本质：占用系统的资源|优化资源的使用==》池化技术
线程池、连接池、内存池、对象池。。。创建、销毁、浪费资源

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我

线程池的好处：

• 1、降低资源的消耗
• 2、提高响应的的速度
• 3、方便管理
  线程复用、可以控制最大并发数，管理线程

2.1 使用单例

package com.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo1 {
    public static void main(String[] args) {
        ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程
        try {
            for (int i = 0; i < 10; i++) {
                //使用线程池之后，使用线程池来创建线程
                threadpool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadpool.shutdown();
        }
    }
}

2.2、使用固定大小的线程

package com.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo1 {
    public static void main(String[] args) {
//        ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程
        ExecutorService threadpool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池的大小
        try {
            for (int i = 0; i < 10; i++) {
                //使用线程池之后，使用线程池来创建线程
                threadpool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadpool.shutdown();
        }
    }
}

2.3、缓存线程池

package com.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo1 {
    public static void main(String[] args) {
//        ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程
//        ExecutorService threadpool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池的大小
        ExecutorService threadpool = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱
        try {
            for (int i = 0; i < 10; i++) {
                //使用线程池之后，使用线程池来创建线程
                threadpool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadpool.shutdown();
        }
    }
}

2.4 七大参数

源码分析



本质上是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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

四种拒绝策略

1、ThreadPoolExecutor.AbortPolicy()
银行满了，还有人进来，不处理这个人的，抛出异常

2、ThreadPoolExecutor.CallerRunsPolicy()
银行满了，还有人进来，哪来的去哪里

3、ThreadPoolExecutor.DiscardPolicy()
队列满了、不会抛出异常

4、ThreadPoolExecutor.DiscardOldestPolicy()
队列满了、尝试去和最早的竞争，也不会抛出异常

1、cpu密集型，几核，就是几，可以保证CPU的效率最高！！！Runtime.getRuntime().availableProcessors()

2、IO密集型 判断你程序中十分耗IO的线程
程序 15个大型任务，io十分占用资源