详解-ThreadPollExecutor-并发编程(Java)

最新推荐文章于 2023-02-02 11:12:20 发布

gaog2zh

最新推荐文章于 2023-02-02 11:12:20 发布

阅读量566

点赞数

分类专栏： # 并发编程文章标签：并发编程线程池

本文链接：https://blog.csdn.net/gaogzhen/article/details/121712548

版权

并发编程专栏收录该内容

44 篇文章 0 订阅

订阅专栏

文章目录

1、池状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K7Abs67x-1638586536124)(I:\study\java\note\concurrent\thread-pool\ExecutorService.png)]

ThreadPoolExecutor使用int的高3位来表示线程池状态，低29位表示线程数量。

状态名	高3位	接收新任务	处理阻塞任务队列	说明
RUNNING	111	Y	Y
SHUTDOWN	000	N	Y	不会接收新任务，但是会处理阻塞队列的剩余任务
STOP	001	N	N	会中断正在执行的任务，并抛弃阻塞队列任务
TIDYING	010	-	-	任务全执行完毕，活动线程为0即将进入终结
TERMINATED	011	-	-	终结状态

这些信息存储在一个原子变量ctl中，目的是将线程状态和线程数合二为一，这样就可以用一次cas原子操作进行赋值。

// c为旧值，ctlof返回结果为新值
ctl.compareAndSet(c, ctlof(targetState, workerCountOf(c)));
// rs为高3位代表线程池状态，wc为低29位代表线程数量
private static int ctlof(int rs, int wc) { rerturn rs | wc;}

2、构造方法

public ThreadPoolExecutor(int corePoolSize,
						  int maximumPoolSize,
						  long keepAliveTime,
						  TimeUnit unit,
						  BlockingQueue<Runnable> workQueue,
						  ThreadFactory threadFactory,
						  RejectedExecutionHandler handler)

corePoolSize: 核心线程数
maximumPoolSize：最大线程数
keepAliveTime：生存时间-救急线程
unit：时间单位-救急线程
workQueue：阻塞队列
threadFactory：线程工厂-创建线程
handler：决绝策略

救急线程=最大线程数-核心线程数。用于接收执行阻塞队列满时的任务。

线程池工作过程：核心线程和救急线程都是懒惰（什么时候用什么时候创建）创建，当任务数不超过核心线程数时，线程池创建核心线程执行任务；当任务数超过核心线程数时，任务被放入阻塞队列；当前没有任务时，核心线程会从阻塞队列中获取任务执行；当阻塞队列被塞满时，线程池会创建救急线程执行任务；当任务数超过总线程数+阻塞队列时，线程池会执行决绝策略。

核心线程和救急线程对比：

	核心线程	救急线程
创建时间	线程池初始化后开始执行任务时创建	核心线程满，阻塞队列满
生存时间	执行任务时创建，随线程池销毁	执行完任务，超过生存时间没有新任务销毁

总结：

线程池初始化时没有线程，当一个任务提交给线程池后，线程池才会创建线程来执行任务。
当线程数达到corePoolSize,这时在加入任务，新加的任务会被加入workQueue队列排队，直到有空闲的线程。
如果队列选择了有界队列，那么任务超过队列大小时，会创建maximumPoolSize-corePoolSize数量的线程来救急。
如果线程达到maximumPoolSize任然有新任务时，这时会执行拒绝策略。拒绝策略jdk提供了4中实现，其他著名框架也提供了实现：
- AbortPolicy：让调用者抛出RejectedExecutionException异常，这时默认策略。
- CallerRunsPolicy：让调用者执行任务。
- DiscardPolicy：放弃本任务。
- DiscardOldestPolicy：放弃队列中最早的任务，当前任务取而代之。
- Dubbo的实现，在抛出RejectedExecutionException异常之前会记录日志，并dump线程栈信息，方便定位问题。
- Netty的实现，是创建一个新线程来执行任务。
- ActiveMQ的实现，带超时等待尝试放入队列。
- Pinpoint的实现，它使用了一个拒绝策略链，会逐一尝试策略链中的每种拒绝策略。
当高峰过去，超过corePoolSize的救急线程如果过一段时间没有任务做，需要结束以节省资源，这个时间由keepAliveTime和unit来控制

根据这个构造方法，JDK Executors类中提供了众多的工厂方法来创建各种用途的线程池

3、三种常用线程池

3.1、固定大小线程池：FixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
	return new ThreadPoolExecutor(nThreads, nThreads,
									0L, TimeUnit.MILLISECONDS,
									new LinkedBlockingQueue<Runnable>());	
}

特点

核心线程数=对大线程数（没有救急线程），因此无需超时时间
阻塞队列是无界的，可以放任意数量的任务
适用：适用于任务量已知，相对耗时的任务

示例：

import lombok.extern.slf4j.Slf4j;

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

@Slf4j(topic = "c.TestFixedThreadPoolExecutor01")
public class TestFixedThreadPoolExecutor01 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        // 自定义实现线程工厂
//        ExecutorService pool = Executors.newFixedThreadPool(2, new ThreadFactory() {
//            private final AtomicInteger t = new AtomicInteger(1);
//
//            @Override
//            public Thread newThread(Runnable r) {
//                return new Thread(r, "mypool" + t.getAndIncrement());
//            }
//        });

        pool.execute(() -> {
            log.debug("1");
        });

        pool.execute(() -> {
            log.debug("2");
        });

        pool.execute(() -> {
            log.debug("3");
        });
    }
}

3.2、带缓冲的线程池：CachedThreadPool

public static ExecutorService newCachedThreadPool() {
	return new ThreadPoolExecutor(0, Integer.MAX_VALUES,
									60L, TimeUnit.SECONDS,
									new SynchronousQueue<Runnable>());	
}

特点：

核心线程数0，最大线程数Integer.MAX_VALUE，救急线程空闲生成时间60s
- 全部是救急线程
- 救急线程可以无限创建

队列采用了SynchronousQueue，实现特点是，它没有容量，没有线程来取放不进去

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

@Slf4j(topic = "TestSynchronousQueue")
public class TestSynchronousQueue {
    public static void main(String[] args) throws InterruptedException {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        new Thread(() -> {

            try {
                log.debug("putting {}", 1);
                queue.put(1);
                log.debug("{} putted ...", 1);

                log.debug("putting {}", 2);
                queue.put(2);
                log.debug("{} putted ...", 2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {
            try {
                log.debug("taking {}", 1);
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2").start();
    }
}

线程池线程数根据任务量不断增长，没有上限，当任务执行完毕，空闲60s后释放线程
适合任务比较密集，但每个任务执行时间较短的情况

3.3、单线程线程池：SingleThreadPool

public static ExecutorService newFixedThreadPool() {
	return new ThreadPoolExecutor(1, 1,
									0L, TimeUnit.MILLISECONDS,
									new LinkedBlockingQueue<Runnable>());	
}

适用场景：希望多个任务排队执行，线程固定数1，任务多余1时会放入无界队列。任务执行完毕，这唯一的线程也不会释放

自己创建一个线程、SingleThreadPool和 newFixedThreadPool(1)的区别：

自己创建一个单一线程串行执行任务，如果任务执行失败那么没有人补救措施，而线程池会创建一个新线程，保证线程池正常运行
Executors.newSingleThreadPoll()线程数始终为1，不可被修改
- FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了ExecutorService接口，因此不能调用ThreadPoolExecutor中的特有方法
Executors.newFixedThreadPool(1)初始线程数为1，以后可以被修改
- 对外暴露的是ThreadPoolExecutor对象，可以强转后调用setCorePoolSize等方法修改

import lombok.extern.slf4j.Slf4j;

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

@Slf4j(topic = "TestThreadPollExecutor01")
public class TestThreadPollExecutor02 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        pool.execute(() -> {int i = 1/0;});
        pool.execute(() -> log.debug("2"));
        pool.execute(() -> log.debug("3"));
    }
}

4、常用方法

4.1、submit(Runnable thread)：接收Runnable接口的线程

Future为submit返回类型，通过get方法获取线程返回值；get方法为阻塞方法

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

@Slf4j(topic = "c.TestSubmit01")
public class TestSubmit01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);

        Future<String> future = pool.submit(() -> {
            log.debug("running ...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "OK";
        });

        String s = future.get();
        log.debug(s);
    }
}

4.2、invokeAny：接收任一线程返回结果；invokeAll,接收所有线程放回的结果。

import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;

@Slf4j(topic = "TestThreadPollExecutor03")
public class TestThreadPollExecutor03 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        test02(pool);
        pool.shutdown();

    }

    public static void test02(ExecutorService pool) throws InterruptedException, ExecutionException {
        String result = pool.invokeAny(Arrays.asList(
                () -> {
                    log.debug("begin 1");
                    Thread.sleep(1000);
                    return "1";
                }, () -> {
                    log.debug("begin 2");
                    Thread.sleep(500);
                    return "2";
                }, () -> {
                    log.debug("begin 3");
                    Thread.sleep(2000);
                    return "3";
                }
        ));

        log.debug("result {}", result);
    }

    public static void test01(ExecutorService pool) throws InterruptedException {
        List<Future<String>> futures = pool.invokeAll(Arrays.asList(
                () -> {
                    log.debug("begin 1");
                    Thread.sleep(1000);
                    return "1";
                }, () -> {
                    log.debug("begin 2");
                    Thread.sleep(500);
                    return "2";
                },() -> {
                    log.debug("begin 3");
                    Thread.sleep(2000);
                    return "3";
                }
        ));

        futures.forEach(r -> {
            try {
                log.debug("get {}", r.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    }
}

4.3、停止

shutdown：把线程池状态变为SHUTDOWN

不会接收新任务
但已提交任务会执行完
次方法不会阻塞调用线程的执行

JDK源码：

public void shutdown() {
    // 加锁
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 把线程池状态变为SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 中断空闲线程
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    // 尝试终止线程池（没有任务的线程立刻终结，如果还有执行的线程也不会等）
    tryTerminate();
}

shutdownNow：线程池状态变为STOP

不会接收新任务
会将队列中的任务返回
并用interrupt的方式中断正在执行的任务

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP);
        interruptWorkers();
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

其他方法
- isShutdown()：不是RUNNING状态的线程池，返回true
- isTerminated()：判断线程池状态是否TERMINATED
- awaitTermination(long timeout, TimeUnit unit)：调用shutdown后，由于调用并不会等待所有任务执行结束，因此如果它想在线程池TERMINATED后做些事情，可以利用次方法等待

源代码仓库：https://gitee.com/gaogzhen/concurrent

gaog2zh

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
详解-ThreadPollExecutor-并发编程(Java)

文章目录1、池状态2、构造方法3、三种常用线程池3.1、固定大小线程池：FixedThreadPool3.2、带缓冲的线程池：CachedThreadPool3.3、单线程线程池：SingleThreadPool4、常用方法4.1、submit(Runnable thread)：接收Runnable接口的线程4.2、invokeAny：接收任一线程返回结果；invokeAll,接收所有线程放回的结果。4.3、停止1、池状态[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K7
复制链接

扫一扫