`
Tonyguxu
  • 浏览: 270403 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

【Java并发】线程池的创建

 
阅读更多

注:《重构与模式》将构造重构成created method,在线程池的创建中隐约看到些影子,故希望能比较下

获得线程池实例

 

1.ThreadPoolExecutor构造

提供了四个构造如下:

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

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

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,

       ThreadFactory threadFactory)

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,

           ThreadFactory threadFactory, RejectedExecutionHandler handler)
 

其中

int corePoolSize:保留在pool中的线程的数目,即使这些线程是idle(空闲)的,也不会terminate。换句话说就是pool会维持corePoolSize数目的线程。

Q:如果有idle thread,那么这些idle thread占用资源情况怎么样?

A:

int maximumPoolSize:pool所容纳线程的最大数目。

long keepAliveTime:当 number of thread > core thread时,this is the maximum time that excess idle threads will wait for new tasks before terminating.对于那些idle thread,会最长等待keepAliveTime时间来获取新任务,如果仍没有新任务的话则terminate。

BlockingQueue<Runnable> workQueue:任务队列,在任务被执行前,workqueue来hold这些任务。该queue只能用来hold那些由execute方法提交的Runnable型的任务。

Q:通过execute提交的任务都会放到任务队列中么?还是当线程池来不及处理execute提交的任务时放到队列里去?

A:

ThreadFactory threadFactory:线程池利用thread factory来创建线程。

RejectedExecutionHandler handler:当任务的执行被blocked(阻塞),会用到RejectedExecutionHandler

Q:何时任务的执行会blocked?

A:the thread bounds and queue capacities are reached。即当线程的数目已经达到maximumPoolSize,并且任务队列也满了。

源码如下:

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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
}

 

 2. Executors静态方法

 

static ExecutorService newFixedThreadPool(int nThreads)

static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

static ExecutorService newSingleThreadExecutor()

static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

static ExecutorService newCachedThreadPool()

static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) 

【示例代码

代码1:

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

ExecutorService executor = Executors.newFixedThreadPool(maxThread, new ThreadFactory() {
         private AtomicInteger seqNo = new AtomicInteger(1);
         
         public Thread newThread(Runnable r) {
            return new Thread(r,"SMS Log Search Engine Thread -- "+seqNo.getAndIncrement());
         }
      });
 

源码如下

//nThreads :fixed number of threads,在任何一个时刻,at most只有nThreads个活跃线程在执行任务
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
 }

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));
    }
//当执行许多short-lived asynchronous tasks时,能显著提高性能,一个线程如果超过imin没有任务执行,就会terminated并从cache中移除
//so 如果没有任务执行的话,线程池不会占用任何资源
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);
    }
 

 

分享到:
评论

相关推荐

    java并发编程:juc线程池

    而了解 Java 并发编程以及其中的 JUC(java.util.concurrent)线程池,对于构建高性能、高可伸缩性的应用程序具有重要意义。 多核处理器的出现使得并发执行成为一种重要的优化手段。了解并发编程和线程池的工作原理...

    Java并发编程相关源码集 包括多任务线程,线程池等.rar

    Java并发编程常见知识点源码集锦,涉及到对象锁,Executors多任务线程框架,线程池等示例,列出一些源码包中包括的内容:  volatile关键字的非原子性、volatile关键字的使用、AtomicInteger原子性操作、线程安全小...

    Java并发编程实战

    1.1 并发简史 1.2 线程的优势 1.2.1 发挥多处理器的强大能力 1.2.2 建模的简单性 1.2.3 异步事件的简化处理 1.2.4 响应更灵敏的用户界面 1.3 线程带来的风险 1.3.1 安全性问题 1.3.2 活跃性问题 1.3.3 ...

    Java几种线程池类型介绍及使用.docx

    2.使用Java线程池的好处: 重用存在的线程,减少对象创建、消亡的开销,提升性能。 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。 提供定时执行、定期执行、单线程、...

    Java 4种线程池的使用

     newFixedThreadPool 创建一个定长线程池,可控制线程大并发数,超出的线程会在队列中等待。  newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。  newSingleThreadExecutor 创建一个单...

    java线程池讲义+代码

    在线程池中维护着多个线程,等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。使用线程池不仅能够保证内核的充分利用,还能防止过分调度。WEB服务器完成网页请求这样的任务...

    java线程池概念.txt

    corePoolSize:核心池的大小,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中; ...

    Java线程池技术详解

    而线程池维护着多个线程,等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用,还能防止过分调度。可用线程数量应该取决于可用的并发处理器...

    龙果java并发编程完整视频

    第8节多种创建线程的方式案例演示(二)使用线程池00:15:40分钟 | 第9节Spring对并发的支持:Spring的异步任务00:11:10分钟 | 第10节使用jdk8提供的lambda进行并行计算00:14:22分钟 | 第11节了解多线程所带来的...

    Java 并发编程实战

    1.1 并发简史 1.2 线程的优势 1.2.1 发挥多处理器的强大能力 1.2.2 建模的简单性 1.2.3 异步事件的简化处理 1.2.4 响应更灵敏的用户界面 1.3 线程带来的风险 1.3.1 安全性问题 1.3.2 活跃性问题 1.3.3 ...

    深入理解Java之线程池

     如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务结束了,这样频繁创建线程会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。  那么有没有一种办法使得线程可以复用,是执行完一个...

    Java并发编程原理与实战

    多种创建线程的方式案例演示(二)使用线程池.mp4 Spring对并发的支持:Spring的异步任务.mp4 使用jdk8提供的lambda进行并行计算.mp4 了解多线程所带来的安全风险.mp4 从线程的优先级看饥饿问题.mp4 从Java字节码的...

    java并发编程脑图

    java并发编程脑图总结,线程池、主要使用场景分析,进程:是CPU分配资源的最小单元,是程序的一次动态执行,它对应着从代码加载,执行至完成的一个完整的过程,它有自己的生命周期。它是应用程序的执行实例,每个...

    Java并发编程(学习笔记).xmind

    Java并发编程 背景介绍 并发历史 必要性 进程 资源分配的最小单位 线程 CPU调度的最小单位 线程的优势 (1)如果设计正确,多线程程序可以通过提高处理器资源的利用率来提升系统吞吐率 ...

    龙果 java并发编程原理实战

    龙果 java并发编程原理实战 第2节理解多线程与并发的之间的联系与区别 [免费观看] 00:11:59分钟 | 第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 [免费观看] 00:13:03分钟 | 第4节学习并发的四...

    Java并发编程最全面试题

    Java并发编程最全面试题,包括并发编程基础知识、并发理论、线程池、并发容器、并发队列、并发工具类等方面的常见面试题。例如线程池的概念、优缺点、创建方式、线程池原理等等。 本文档适用于将要参加Java开发相关...

    java并发编程综合讲解

    您将了解线程池如何管理线程的创建、复用和销毁,以及如何通过适当的配置来提高系统的性能和响应能力。 其次,我们将介绍并发集合类的使用。您将了解如何在多线程环境下安全地进行数据访问,以及如何避免并发访问所...

    java高并发相关知识点.docx

    线程池:Java中的线程池机制,包括线程池的创建、执行任务、关闭等操作。 并发集合:Java中的并发集合,包括ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList等。 并发控制:Java中的并发控制机制,...

    Java 7并发编程实战手册

    java7在并发编程方面,带来了很多令人激动的新功能,这将使你的应用程序具备更好的并行任务性能。 《Java 7并发编程实战手册》是Java 7并发编程的实战指南,介绍了Java 7并发API中大部分重要而有用的机制。全书分为9...

Global site tag (gtag.js) - Google Analytics