Java-线程池

最新推荐文章于 2022-04-01 15:33:44 发布

骑在自行车上的马云

最新推荐文章于 2022-04-01 15:33:44 发布

阅读量147

点赞数

分类专栏：线程文章标签：线程池

本文链接：https://blog.csdn.net/qq_42933931/article/details/113940424

版权

线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

线程池

无论是面试还是平时的工作中，都会设计线程池的使用，掌握这块我认为作为java程序员必不可少的技能。传统模式的线程创建，在多线程大并发环境下，我们不建议单个去创建线程。第一效率低，第二就是浪费资源。所以如果采用线程池会很好的解决这方面的问题。

合理的使用线程池的好处

java中的线程池用场景最多的并发框架，几乎所有需要异步或者并发执行的程序都可以使用线程池。在开发过程中，合理的使用线程池能够带来下面3个好处：
1.降低资源消耗。通过重复利用已经创建的线程降低线程的创建和销毁造成的消耗。
2.提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
3.提高线程的可管理性，线程是稀缺资源，如果无限的创建资源，不仅会消耗资源，还会降低系统的稳定性，使用线程可以进行同一分配。调优和监控，但是要做到合理利用线程池，必须对齐实现原理了如指掌。

线程池的主要工作流程图

ThreadPoolExecutor执行示意图：
在这里插入图片描述

ThreadPoolExecutor执行excute方法下面四种情况:

1.如果当前运行的线程少于核心线程数（corePoolSize),则创建新的线程执行任务。
2.如果运行的线程等于或多余corePoolSize,则将任务加入BockingQueue阻塞队列。
3.如果阻塞队列已经满，则创建的线程处理任务。如果创建新线程后使当前运行的线程数大于maxPoolSize最大线程数,任务将被拒绝，并调用RejectedExecutionHandler方法。

线程池处理任务简单案例

package com.second.app.thread.pool;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

/**
 * @Author soul yzg
 * @Date 2021/2/22 13:42
 * 努力学习 天天进步
 */

@Slf4j
public class Main {

    private final static Integer CORE_POOL_SIZE = 1;

    private final static Integer MAX_POOL_SIZE = 1;

    private final static Integer LOOP_COUNT = 10;

    static BlockingQueue<Runnable> workQueue = new LinkedBlockingDeque<>(5);

    public static void main(String[] args) {

        ThreadPoolExecutor executor = new ThreadPoolExecutor
                (CORE_POOL_SIZE, MAX_POOL_SIZE, 0,
                        TimeUnit.MILLISECONDS, workQueue, Executors.defaultThreadFactory(), new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                     log.info("RejectedExecutionHandler is {}",r.toString());
                    }
                });
        Service service = new Service();
        for (int i = 0; i < LOOP_COUNT; i++) {
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    log.info("workQueue size equal {}",workQueue.size());
                    service.methodService();
                }
            });
        }
        executor.shutdown();
    }
}

package com.second.app.thread.pool;

/**
 * @Author soul yzg
 * @Date 2021/2/22 13:37
 * 努力学习 天天进步
 */
public class Service {

    public void methodService() {
        try {
            System.out.println(Thread.currentThread().getName() + " is running" );
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

在这里插入图片描述

创建线程池的参数

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

创建一个线程池需要输入几个参数：
1.corePoolSize(线程池的基本大小)：当提交一个任务到线程池时，线程会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会去创建线程，等需要执行任务的线程数大于corePoolSize线程池基本大小时就不在创建了。如果调用线程池的preStartAllCoreThreads方法(),线程会提前创建并启动所有基本线程。

2.runnableTaskQueue(任务队列)；用来保存等待执行的任务阻塞队列。

常见的几种阻塞队列：

ArrayBlockingQueue:基于数组结构的有界阻塞队列，此队列按FIFO先进先出原则对元素进行排序。
LinkedBlockingQueue:基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量高于ArrayBlockingQueue。静态工厂方法Excutors.newFixedThreadPool()使用这个队列。
synchronousQueue:一个不存储元素的阻塞队列，每个插入操作必须要等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，静态工厂方法Excutors.newCachedThreadPool()使用这个队列。
PriorityBlockingQueue:一个具有优先级的无限阻塞队列。

3.maximumPoolSize：线程池允许创建的最大线程数，如果阻塞队列满了，并且已经创建的线程数小于maximumPoolSize，则线程池会创建新的线程执行任务。值得注意的是，如果采用无界的任务队列时，这个参数就没什么效果。

4.ThreadFactory :用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更具有意义的名字。使用开源框架guva提供的 ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字。代码如下

new ThreadFactoryBuilder.setNameFormat("XX-task-%d").build();

5.RejectedExecutionHandler饱和策略：当队列和线程都满了，说明线程池处于饱和状态，那么必须采用一种策略处理新提交的任务。

AbortPolicy:直接抛出异常
CallerRunsPolicy：只用调用者所在线程来运行任务。
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
DiscardPolicy：不处理，丢弃掉。

当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务。

6.keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。
所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS）、小时（HOURS）、分（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和纳秒（NANOSECONDS，千分之一微秒）。

自定义处理线程池策略

package com.second.app.handler;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author soul yzg
 * @Date 2021/2/22 18:29
 * 努力学习 天天进步
 */
@Slf4j
public class MyRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        log.info("Begin exception handler");
        Thread thread = new Thread(r);
        thread.start();
        log.info("exception handler currentThreadName is {}",thread.getName());
    }
}

package com.second.app.config;

import com.second.app.handler.MyRejectedExecutionHandler;
import org.springframework.stereotype.Component;

import java.util.concurrent.*;

/**
 * @Author soul yzg
 * @Date 2021/2/22 18:19
 * 努力学习 天天进步
 */
public class ExecutorsConfig {

    private final static Integer CORE_POOL_SIZE = 1;

    private final static Integer MAX_POOL_SIZE = 1;

    private final static MyRejectedExecutionHandler MY_REJECTED_EXECUTION_HANDLER = new MyRejectedExecutionHandler();


    static BlockingQueue<Runnable> workQueue = new LinkedBlockingDeque<>(5);

    // static ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();

    public static ThreadPoolExecutor newThreadPoolExecutor() {
    
        ThreadPoolExecutor executor = new ThreadPoolExecutor
                (CORE_POOL_SIZE, MAX_POOL_SIZE,
                        0,
                        TimeUnit.MILLISECONDS, workQueue,
                        Executors.defaultThreadFactory(),
                        MY_REJECTED_EXECUTION_HANDLER);
        return executor;

    }


}

package com.second.app.thread.pool;

import com.second.app.config.ExecutorsConfig;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author soul yzg
 * @Date 2021/2/22 13:42
 * 努力学习 天天进步
 */

@Slf4j
public class Main {


    private static final int LOOP_COUNT = 20;

    public static void main(String[] args) {

        ThreadPoolExecutor executor = ExecutorsConfig.newThreadPoolExecutor();
        
        Service service = new Service();
        
        for (int i=0;i<LOOP_COUNT;i++){
        
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    service.methodService();
                }
            });
        }
        executor.shutdown();

    }
}

运行结果：
在这里插入图片描述

常见的线程池

1.ScheduledThreadPoolExecutor 继承ThreadPoolExecutor，主要用来在给定的延迟之后运行任务，或者定期执行任务。

package com.second.app.thread.pool;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

/**
 * @Author soul yzg
 * @Date 2021/2/23 14:39
 * 努力学习 天天进步
 */
@Slf4j
public class Run {

   private final static int AVAILABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();

    private final static ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("schedule-task-%d").build();

    private final static int LOOP_COUNT = 100;

    public static void main(String[] args) {

        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(AVAILABLE_PROCESSORS, factory);

        for (int i = 0; i < LOOP_COUNT; i++) {
            executor.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    new Service().methodService();
                }
            }, 0, 1, TimeUnit.SECONDS);
        }


    }
}

package com.second.app.thread.pool;

import lombok.extern.slf4j.Slf4j;

/**
 * @Author soul yzg
 * @Date 2021/2/22 13:37
 * 努力学习 天天进步
 */
@Slf4j
public class Service {

    public void methodService() {
        try {
            log.info("{} is running",Thread.currentThread().getName());
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

执行结果：100个任务，利用线程池执行，每次执行完成到下一次任务的执行间隔一秒钟。

Connected to the target VM, address: '127.0.0.1:61529', transport: 'socket'
Disconnected from the target VM, address: '127.0.0.1:61529', transport: 'socket'
16:10:33.613 [schedule-task-0] INFO com.second.app.thread.pool.Service - schedule-task-0 is running
16:10:33.613 [schedule-task-8] INFO com.second.app.thread.pool.Service - schedule-task-8 is running
16:10:33.613 [schedule-task-7] INFO com.second.app.thread.pool.Service - schedule-task-7 is running
16:10:33.613 [schedule-task-2] INFO com.second.app.thread.pool.Service - schedule-task-2 is running
16:10:33.613 [schedule-task-6] INFO com.second.app.thread.pool.Service - schedule-task-6 is running
16:10:33.614 [schedule-task-11] INFO com.second.app.thread.pool.Service - schedule-task-11 is running
16:10:33.613 [schedule-task-3] INFO com.second.app.thread.pool.Service - schedule-task-3 is running
16:10:33.613 [schedule-task-1] INFO com.second.app.thread.pool.Service - schedule-task-1 is running
16:10:33.613 [schedule-task-4] INFO com.second.app.thread.pool.Service - schedule-task-4 is running
16:10:33.613 [schedule-task-5] INFO com.second.app.thread.pool.Service - schedule-task-5 is running
16:10:33.614 [schedule-task-10] INFO com.second.app.thread.pool.Service - schedule-task-10 is running
16:10:33.614 [schedule-task-9] INFO com.second.app.thread.pool.Service - schedule-task-9 is running

Process finished with exit code 130

骑在自行车上的马云

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java-线程池

线程池你好！这是你第一次使用 Markdown编辑器所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。新的改变我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：全新的界面设计，将会带来全新的写作体验；在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式进行展示；增加了图片拖拽功能，你可以将本地
复制链接

扫一扫