01蚂蚁-并发编程——并发编程线程池原理——2.线程池的原理

线程池

目的：

1. 降低资源消耗:通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
2. 提高响应效率:当任务到达时，任务可以不需要等到线程创建就能立即执行。
3. 方便管理：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配，调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

线程池的四种创建方式

Executors
1.newCachedThreadPool——创建一个缓存线程池

package thread_day05;

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

public class Test0006 {
    public static void main(String[] args) {
        //可缓存的线程池重复利用 无限大小
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        for(int i=0;i<10;i++) {
            final int temp = i;
            //可执行线程 executor 方法表示启动线程
            newCachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+","+temp);
                }
            });
        }
    }
}

2.newFixedThreadPool——创建一个固定的线程池

package thread_day05;

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

public class Test0007 {
    public static void main(String[] args) {
        //可固定长度的线程池
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
        for(int i=0;i<10;i++) {
            final int temp = i;
            //可执行线程 executor 方法表示启动线程
            newFixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+","+temp);
                }
            });
        }
    }
}

3.newScheduledThreadPool——创建一个定时的线程池

package thread_day05;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test0008 {
    public static void main(String[] args) {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(3);
        for(int i=0;i<10;i++) {
            final int temp = i;
            //可执行线程 executor 方法表示启动线程
            newScheduledThreadPool.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+","+temp);
                }
            } ,3, TimeUnit.SECONDS);
        }
    }
}

4.newSingleThreadExecutor——创建一个单个的线程池

package thread_day05;

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

public class Test0009 {
    public static void main(String[] args) {
        //单线程
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for(int i=0;i<10;i++) {
            final int temp = i;
            //可执行线程 executor 方法表示启动线程
            newSingleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+","+temp);
                }
            });
        }
        newSingleThreadExecutor.shutdown(); //会停止线程池
    }
}

1.线程池源码分析(核心)

1.所有的创建线程池的方法都会去执行ThreadPoolExecutor这个方法。所有的四个创建线程池的方法都包装了这个方法。

原理流程图

源码分析

所有的创建线程的四种方法都是包装了ThreadPoolExecutor的构造函数。所有我们要实现自定义线程池的时候，我们就需要自己包装这个构造函数。

package thread_day05;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test0010 {
    public static void main(String[] args) {
        //核心线程数1 最大线程数2
        ThreadPoolExecutor threadPoolExecutor =  new ThreadPoolExecutor(1, 2,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(3));
        //任务1现在创建线程 在执行
        threadPoolExecutor.execute(new TaskThread("任务1"));
        //任务2存放在队列缓存
        threadPoolExecutor.execute(new TaskThread("任务2"));
        //任务3存放在队列缓存
        threadPoolExecutor.execute(new TaskThread("任务3"));
        //任务4存放在队列缓存
        threadPoolExecutor.execute(new TaskThread("任务4"));
        //任务5存放在队列缓存
        //超过核心线程数加队列数就会创建另一个线程。看上图就明白了。
        threadPoolExecutor.execute(new TaskThread("任务5"));
       //任务6存放在队列缓存
        //在这个地方就会报错了，因为最大线程数和队列的数加起来5已经满了。所以6个就报错了。最多就是最大线程加队列缓存
        threadPoolExecutor.execute(new TaskThread("任务6"));
    }
}
class TaskThread implements Runnable{
    private String threadName;
    TaskThread(String threadName){
        this.threadName = threadName;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":"+threadName);
    }
}