线程池（简单实现自定义线程池）

目录

并发队列

ConcurrentLinkedDeque

BlockingQueue

线程池

线程池的好处

线程池四种创建方式

①newCachedThreadPool

②newFixedThreadPool

③newScheduledThreadPool

④newSingleThreadExecutor

线程池原理

自定义线程线程池

---

并发队列

在并发队列上JDK提供了两套实现

       一个是以ConcurrentLinkedQueue为代表的高性能非阻塞队列，

       另一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。

ConcurrentLinkedDeque

ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列，通过无锁的方式，实现
了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue.它
是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先
加入的，尾是最近加入的，该队列不允许null元素。

BlockingQueue

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：

在队列为空时，获取元素的线程会等待队列变为非空。

当队列满时，存储元素的线程会等待队列可用。

阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

阻塞队列是线程安全的。

下面就用BlockingQueue演示生产者消费者场景

//生产者
class ProducerThread extends Thread{
    //阻塞队列
    private BlockingQueue<String> blockingQueue;
    //原子操作
    private AtomicInteger count = new AtomicInteger();
    //标记生产者生产状态
    public volatile static boolean flag = true;

    public ProducerThread(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        while (flag){
            String data = String.valueOf(count.incrementAndGet());
            try {
                blockingQueue.offer(data, 2, TimeUnit.SECONDS);
                Thread.sleep(1000);
            }catch (Exception e){

            }
        }
        System.out.println("生产者已停止");
    }
    public void end(){
        this.flag = false;
    }
}
//消费者
class ConsumerThread extends Thread{
    //阻塞队列
    private BlockingQueue<String> blockingQueue;

    public ConsumerThread(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        while (ProducerThread.flag){
            try {
                String data = blockingQueue.poll(2,TimeUnit.SECONDS);
                System.out.println("消费者获取到队列信息成功,data:" + data);
            }catch (Exception e){

            }
        }
    }
}
public class BlockingQueueT {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new LinkedBlockingDeque<String>(10);
        ProducerThread producerThread = new ProducerThread(blockingQueue);
        ConsumerThread consumerThread = new ConsumerThread(blockingQueue);
        producerThread.start();
        consumerThread.start();
        try {
            //10秒后 停止线程..
            Thread.sleep(10*1000);
            producerThread.end();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程池

线程池的好处

第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源。

线程池四种创建方式

①newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

public static void main(String[] args) {
		 //可以缓存的线程池
		 ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
		 for (int i = 0; i < 100; i++) {
			 newCachedThreadPool.execute(new Runnable() {
					@Override
					public void run() {
                        try {
                        	 Thread.sleep(100);
						} catch (Exception e) {
							// TODO: handle exception
						}
                      System.out.println(Thread.currentThread().getId());
					}
			});
		}
	}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。 

②newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

public static void main(String[] args) {
		// 控制并发数的线程池
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			newFixedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName());
				}
			});
		}
}

③newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行。

public static void main(String[] args) {
		// 可以定时线程池
		ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(3);
		for (int i = 0; i < 10; i++) {
			newScheduledThreadPool.schedule(new Runnable() {
				public void run() {
					System.out.println(Thread.currentThread().getName());
				}
			}, 3, TimeUnit.SECONDS);//延迟3秒执行
		}
}

④newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
		for (int i = 0; i < 10; i++) {
			final int x = i;
			newSingleThreadExecutor.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+":"+x);
				}
			});
}

线程池原理

提交一个任务到线程池中，线程池的处理流程如下：

1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行

任务。如果已经满了，则交给饱和策略来处理这个任务。

自定义线程线程池

整合懒汉模式和自定义线程池

public class ThreadPools {
    private volatile static ThreadPools threadPool = null;
    //核心线程数，实际运行的线程数
    public static final int corePoolSize = 1;
    //最大线程数
    public static final int maximumPoolSize = 2;
    //存活时间
    public static final long keepAliveTime = 60L;
    public static final TimeUnit unit = TimeUnit.SECONDS;
    //缓存队列
    public static final ArrayBlockingQueue<Runnable> arrayBlockingQueue = new ArrayBlockingQueue(3);
    //线程池
    public static ThreadPoolExecutor threadPoolExecutor = null;
    private ThreadPools(){
        threadPoolExecutor = new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,arrayBlockingQueue);
    }
    public static void executor(int num,Runnable runnable){
        if(num <= 0){
            return;
        }
        if(threadPool == null){
            synchronized (ThreadPools.class){
                if(threadPool == null){
                    threadPool = new ThreadPools();
                }
            }
        }
        for(int i = 0;i < num;i++){
            threadPoolExecutor.execute(runnable);
        }
        threadPoolExecutor.shutdown();
    }
}

class Run implements Runnable{
    @Override
    public void run() {
        //具体操作
        System.out.println(Thread.currentThread().getName());
    }
}
public class Test {
    public static void main(String[] args) {
        ThreadPools.executor(5,new Run());
    }
}