线程池详解1

最新推荐文章于 2024-01-28 23:21:48 发布
最新推荐文章于 2024-01-28 23:21:48 发布
阅读量321 收藏
点赞数
分类专栏： Java知识点 文章标签： 线程池

Java线程池主要是Executor接口，实现(间接实现该接口)类具体为ThreadPoolExecutor类，下面是关于该类的详解

一.ThreadPoolExecutor提供了四个构造函数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

(1)int corePoolSize：线程池中核心线程数最大值，线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过核心线程，则新建的是非核心线程，核心线程默认情况下会一直存活在线程池中，即时该核心线程处于闲置状态，如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程超过一定时间会被回收

(2)int maximumPoolSize：该线程池中线程总数的最大值

线程总数 = 线程总数 + 非核心线程数

(3)long keepAliveTime：一个非核心线程，如果长期处于闲置状态的时间超过这个参数所设定的时长，就会被销毁掉，如果设置allowCoreThreadTimeOut这个属性为true，该属性同样作用于核心线程

(4)TimeUnit unit：keepAliveTime的单位，是一个枚举类型

NANOSECONDS：1微毫秒=1微秒/1000  MICROSECONDS：1微秒=1毫秒/1000  MILLISECONDS：1毫秒=1秒/1000

SECONDS：秒       MINUTES：分       HOURS：小时       DAYS：天

 (5)BlockingQueue workQueue：该线程池中的任务队列，维护着等待执行的Runnable对象，当所有的核心线程都在工作，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务，常用的工作队列：

SynchronousQueue：这个队列接受到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作就新建一个线程来处理这个任务，所以为了保证不出现线程数达到了maximumPoolSize而不能新建线程的错误，使用该类型一般设置maximumPoolSize为Integer.MAX_VAUE无限大

LinkedBlockingQueue：这个队列接受到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务，如果当前线程数等于核心线程数，则进入队列等待，由于这个队列没有最大值限制，即所有超过核心线程数的任务即将被添加到队列中，也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize

ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了核心线程数就入队等候，如果队列已满，则新建线程(非核心)线程执行任务，如果线程总数达到了maximumPoolSize，并且队列也满了，则发生错误

DelayQueue：队列内元素必须实现Delayed接口，即任务必须实现Delayed接口，队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

(5)ThreadFactory threadFactory：创建线程的方式，一个接口，实现该接口时需要重写它的Thread newThread(Runnable r)

(6)RejectedExecutionHandler handler：异常发生，抛出异常

二.向ThreadPoolExecutor添加任务

ThreadPoolExecutor.execute(Runnable command)方法可向线程池添加一个任务

线程池的策略：

1.线程数量为达到corePoolSize，则新建一个线程(核心线程)执行任务

2.线程数量达到了corePoolSize，则将任务队列移入队列等待

3.队列已满，新建线程(非核心任务)执行任务

4.队列已满，总线程数又达到了maximumPoolSize，就会由(RejectedExceptionHandler)抛出异常

 

Java通过Executors提供了各种已定义好的线程池，此四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现

package java.util.concurrent;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
import java.security.PrivilegedActionException;
import java.security.AccessControlException;
import sun.security.util.SecurityConstants;

public class Executors {

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

    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

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

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


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

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

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


    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }


    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1, threadFactory));
    }

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

    public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedExecutorService(executor);
    }

    public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedScheduledExecutorService(executor);
    }

    public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
    }

    public static ThreadFactory privilegedThreadFactory() {
        return new PrivilegedThreadFactory();
    }

    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

    public static Callable<Object> callable(Runnable task) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<Object>(task, null);
    }

    public static Callable<Object> callable(final PrivilegedAction<?> action) {
        if (action == null)
            throw new NullPointerException();
        return new Callable<Object>() {
            public Object call() { return action.run(); }};
    }

    public static Callable<Object> callable(final PrivilegedExceptionAction<?> action) {
        if (action == null)
            throw new NullPointerException();
        return new Callable<Object>() {
            public Object call() throws Exception { return action.run(); }};
    }

    public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
        if (callable == null)
            throw new NullPointerException();
        return new PrivilegedCallable<T>(callable);
    }


    public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
        if (callable == null)
            throw new NullPointerException();
        return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);
    }


    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

    static final class PrivilegedCallable<T> implements Callable<T> {
        private final Callable<T> task;
        private final AccessControlContext acc;

        PrivilegedCallable(Callable<T> task) {
            this.task = task;
            this.acc = AccessController.getContext();
        }

        public T call() throws Exception {
            try {
                return AccessController.doPrivileged(
                    new PrivilegedExceptionAction<T>() {
                        public T run() throws Exception {
                            return task.call();
                        }
                    }, acc);
            } catch (PrivilegedActionException e) {
                throw e.getException();
            }
        }
    }


    static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {
        private final Callable<T> task;
        private final AccessControlContext acc;
        private final ClassLoader ccl;

        PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                // Calls to getContextClassLoader from this class
                // never trigger a security check, but we check
                // whether our callers have this permission anyways.
                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);

                // Whether setContextClassLoader turns out to be necessary
                // or not, we fail fast if permission is not available.
                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
            }
            this.task = task;
            this.acc = AccessController.getContext();
            this.ccl = Thread.currentThread().getContextClassLoader();
        }

        public T call() throws Exception {
            try {
                return AccessController.doPrivileged(
                    new PrivilegedExceptionAction<T>() {
                        public T run() throws Exception {
                            Thread t = Thread.currentThread();
                            ClassLoader cl = t.getContextClassLoader();
                            if (ccl == cl) {
                                return task.call();
                            } else {
                                t.setContextClassLoader(ccl);
                                try {
                                    return task.call();
                                } finally {
                                    t.setContextClassLoader(cl);
                                }
                            }
                        }
                    }, acc);
            } catch (PrivilegedActionException e) {
                throw e.getException();
            }
        }
    }


    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

    static class PrivilegedThreadFactory extends DefaultThreadFactory {
        private final AccessControlContext acc;
        private final ClassLoader ccl;

        PrivilegedThreadFactory() {
            super();
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                // Calls to getContextClassLoader from this class
                // never trigger a security check, but we check
                // whether our callers have this permission anyways.
                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);

                // Fail fast
                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
            }
            this.acc = AccessController.getContext();
            this.ccl = Thread.currentThread().getContextClassLoader();
        }

        public Thread newThread(final Runnable r) {
            return super.newThread(new Runnable() {
                public void run() {
                    AccessController.doPrivileged(new PrivilegedAction<Void>() {
                        public Void run() {
                            Thread.currentThread().setContextClassLoader(ccl);
                            r.run();
                            return null;
                        }
                    }, acc);
                }
            });
        }
    }


    static class DelegatedExecutorService extends AbstractExecutorService {
        private final ExecutorService e;
        DelegatedExecutorService(ExecutorService executor) { e = executor; }
        public void execute(Runnable command) { e.execute(command); }
        public void shutdown() { e.shutdown(); }
        public List<Runnable> shutdownNow() { return e.shutdownNow(); }
        public boolean isShutdown() { return e.isShutdown(); }
        public boolean isTerminated() { return e.isTerminated(); }
        public boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.awaitTermination(timeout, unit);
        }
        public Future<?> submit(Runnable task) {
            return e.submit(task);
        }
        public <T> Future<T> submit(Callable<T> task) {
            return e.submit(task);
        }
        public <T> Future<T> submit(Runnable task, T result) {
            return e.submit(task, result);
        }
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
            throws InterruptedException {
            return e.invokeAll(tasks);
        }
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                             long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.invokeAll(tasks, timeout, unit);
        }
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
            throws InterruptedException, ExecutionException {
            return e.invokeAny(tasks);
        }
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                               long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            return e.invokeAny(tasks, timeout, unit);
        }
    }

    static class FinalizableDelegatedExecutorService
        extends DelegatedExecutorService {
        FinalizableDelegatedExecutorService(ExecutorService executor) {
            super(executor);
        }
        protected void finalize() {
            super.shutdown();
        }
    }


    static class DelegatedScheduledExecutorService
            extends DelegatedExecutorService
            implements ScheduledExecutorService {
        private final ScheduledExecutorService e;
        DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
            super(executor);
            e = executor;
        }
        public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
            return e.schedule(command, delay, unit);
        }
        public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
            return e.schedule(callable, delay, unit);
        }
        public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
            return e.scheduleAtFixedRate(command, initialDelay, period, unit);
        }
        public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
            return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);
        }
    }

    private Executors() {}
}

 

 

 

线程池详解：线程池七大核心参数、线程池工作原理、线程池的创建方式、线程池的拒绝策略、如何合理分配线程池大小
小小鱼儿小小林的博客
03-19 1万+
线程池是一种用于管理和复用线程的机制，它允许我们在需要执行一些并发任务时，可以重复使用已经创建好的线程，而不是每次都创建新的线程。这样可以减少线程创建和销毁的开销，提高系统的性能和响应速度。并发线程池的优点包括： 提高系统的性能和吞吐量，因为可以重复使用已经创建好的线程，减少线程创建和销毁的开销。 可以控制并发任务的执行顺序和数量，从而避免系统资源被过度占用。 可以设置线程池的参数，如核心线程数、最大线程数、任务队列等，以满足不同场景的需求。
java parameters 用法_java11教程--类AccessControlContext用法
weixin_31986143的博客
03-06 504
AccessControlContext用于根据其封装的上下文做出系统资源访问决策。更具体地说，它封装了一个上下文，并且有一个方法， checkPermission ，相当于AccessController类中的checkPermission方法，但有一点不同：AccessControlContext checkPermission方法根据它封装的上下文而不是当前执行线程。因此，AccessCon...
线程池详解
我不是知识的搬运工
07-25 310
一.线程池简介 1.为什么要用线程池 （1）减少资源的开销 。减少了每次创建线程、销毁线程的开销。 （2）提高响应速度 ,每次请求到来时，由于线程的创建已经完成，故可以直接执行任务，因此提高了响应速度。 （3）提高线程的可管理性 ,线程是一种稀缺资源，若不加以限制，不仅会占用大量资源，而且会影响系统的稳定性。 因此，线程池可以对线程的创建与停止、线程数量等等因素加以控制，使得线程在一种可控的范围内...
一文读懂Java线程池详解，强力推荐
最新发布
04-12
Java线程池详解 1. 线程池基础 1.1 什么是线程池 1.2 为什么需要线程池 1.3 线程池的核心参数 1.4 线程池工作原理 2. Java中的线程池类型与使用 2.1 常见的线程池类型 2.1.1 FixedThreadPool 2.1.2 CachedThreadPool...
基于tomcat的连接数与线程池详解
09-30
在Tomcat的配置和性能优化中，了解如何设置连接数和线程池是至关重要的。 首先，Connector按照处理连接的方式可以分为不同的协议类型，包括BIO（阻塞IO）、NIO（非阻塞IO）、APR（Apache Portable Runtime）。BIO...
C++实现线程池详解（基于boost源码以及封装等线程池）
10-15
一、要实现高效的线程池，可以考虑以下几点 二、实现线程池可以按照以下步骤进行 三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、...
Java安全——存取控制器
多头注意力探索Now
06-30 846
java存取管理器
Java-重要知识点-SPI机制详解
Java程序员的知识博客
01-28 1285
其实不难发现，SPI 机制的具体实现本质上还是通过反射完成的。我们按照规定将要暴露对外使用的具体实现类在文件下声明。另外，SPI 机制在很多框架中都有应用：Spring 框架的基本原理也是类似的反射。还有 Dubbo 框架提供同样的 SPI 扩展机制，只不过 Dubbo 和 spring 框架中的 SPI 机制具体实现方式跟咱们今天学得这个有些细微的区别，不过整体的原理都是一致的，相信大家通过对 JDK 中 SPI 机制的学习，能够一通百通，加深对其他高深框的理解。
Java多线程之-----实现自己的ThreadFactory
qq_43679366的博客
01-09 596
Java多线程之-----实现自己的ThreadFactory
AccessController类的doPrivileged
星星的技术专栏
09-02 5640
以下摘自JDKhttp://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/java/security/AccessController.html AccessController 类用于与访问控制相关的操作和决定。 更确切地说，AccessController 类用于以下三个目的： 基于当前生效的安全策略决定是
从源码角度详解Java的Callable接口
华为云官方博客
07-28 1219
摘要：本文从源码角度深入解析Callable接口。
线程池研发学习笔记
liuhm的博客
11-30 1606
可以直接叙述,也可以对比连接池介绍```线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程,这里的任务就是我们前面学过的实现了Runnable或Callable接口的实例对象;```1:网购商品秒杀多人同时抢购某件商品,只有部分人会成功,其他人失败;2:云盘文件上传和下载同时可以上传多个文件或下载多个文件,且有最大上传和下载文件的个数限制;3:12306网上购票系统等。
java.security 源码学习08 AccessController
weixin_38389755的博客
06-26 600
1. 源码 /** <p> The AccessController class is used for access control operations and decisions. <p> More specifically, the AccessController class is used for three purposes: ...
java线程池详解
热门推荐
人生就像一场戏
12-01 3万+
1.线程池使用场景？ java中经常需要用到多线程来处理一些业务，我们非常不建议单纯使用继承Thread或者实现Runnable接口的方式来创建线程，那样势必有创建及销毁线程耗费资源、线程上下文切换问题。同时创建过多的线程也可能引发资源耗尽的风险，这个时候引入线程池比较合理，方便线程任务的管理。java中涉及到线程池的相关类均在jdk1.5开始的java.util.concurrent包中，涉及到的几个核心类及接口包括：Executor、Executors、ExecutorService、ThreadPo
Java SPI机制学习
u013761049的专栏
09-14 259
许多框架在编写时，都用到了SPI机制。那我们今天就来说说什么是SPI机制。 SPI机制：service provider interface，弱译：接口提供服务(白话翻译)。 网络语言：基于接口的编程＋策略模式＋配置文件”组合实现的动态加载机制 定义接口类(interface) +多个类对同一接口的实现(implements)+接口类和实现类进行一个配置( src/main/resource...
Java Socket线程池详解与实战
1. `corePoolSize`：这是线程池最小保持的线程数量，任何时候至少有这么多线程在执行任务。 2. `maximumPoolSize`：线程池的最大线程数，当任务队列满且无空闲线程时，超出部分任务会按照`RejectedExecutionHandler`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值