线程池参数的解释


在Java中,线程池是一种池化技术,用于管理和复用线程,提高线程的利用率和性能。下面是一些常见的线程池参数及其解释:

1. corePoolSize(核心线程数):线程池中保持活动状态的最小线程数,即使是空闲状态也不会被回收。
2. maximumPoolSize(最大线程数):线程池中允许存在的最大线程数,包括核心线程数和非核心线程数。
3. keepAliveTime(线程空闲时间):当线程池中的线程数超过核心线程数时,空闲线程等待新任务的最长时间,超过这个时间将被回收销毁。
4. TimeUnit(时间单位):设置keepAliveTime的时间单位,如秒、毫秒等。
5. workQueue(任务队列):用于存放等待执行的任务的阻塞队列,可以选择不同类型的队列,如ArrayBlockingQueue、LinkedBlockingQueue等。
6. threadFactory(线程工厂):用于创建线程的工厂类,可以自定义线程的名称、优先级等属性。
7. rejectedExecutionHandler(任务拒绝策略):当线程池无法接收新任务时,执行的策略,如抛出异常、丢弃任务或者调用主线程来执行任务。

核心线程、最大线程数、线程空闲时间之间的关系:

  • 当有新任务提交到线程池时,首先线程池会尝试使用核心线程来处理任务。
  • 当核心线程都在执行任务且工作队列已满时,线程池会创建新的非核心线程来处理任务,直到达到最大线程数。
  • 当非核心线程完成任务后,如果在线程空闲时间内没有新任务提交,这些线程将被销毁,以避免线程过多占用系统资源。

在Java中,常见的线程池类型包括以下几种:

  1. FixedThreadPool(固定大小线程池):该线程池维护一个固定数量的线程。无论任务多少,都只会创建固定数量的线程来执行任务。当所有线程都处于忙碌状态时,新任务将被放入队列等待。

  2. CachedThreadPool(缓存线程池):该线程池根据任务的数量动态调整线程的数量。如果有可用的空闲线程,则会重用它们;如果没有可用的线程,则会创建新的线程。如果线程空闲时间过长,超过一定阈值,那么这些空闲线程将会被终止并移除。

  3. SingleThreadPool(单线程池):该线程池只包含一个线程,用于顺序执行所有任务。即使任务异常或终止,也会有新线程取代它。适用于需要按顺序执行任务的场景。

  4. ScheduledThreadPool(调度线程池):该线程池用于执行延迟任务或周期性任务。可以指定任务的执行时间或间隔,并由线程池自动触发执行。

  5. WorkStealingPool(工作窃取线程池):该线程池是Java 8新增的一种线程池类型,基于Fork/Join框架实现。它使用一种工作窃取算法,可以高效地处理大量的任务。它会尝试从其他线程的队列中“窃取”任务来执行。

线程的状态:
在线程的生命周期中,线程可以处于不同的状态。Java中的线程共有6种状态:

1. 新建(New):通过创建Thread对象来新建一个线程,但还未调用start方法。
2. 可运行(Runnable):线程正在Java虚拟机中执行,或者等待系统资源的分配,在就绪队列中等待被调度执行。
3. 运行(Running):线程正在执行其任务代码。
4. 阻塞(Blocked):线程被阻塞并等待监视器锁,通常发生在获取同步锁失败、执行sleep方法或等待输入输出等操作时。
5. 等待(Waiting):线程正在等待其他线程的特定操作,通过调用wait或join方法等进入该状态。
6. 终止(Terminated):线程已经执行完其任务代码,终止运行。

yield、sleep、wait和join是Java中用于线程控制的方法,它们之间有以下区别:

1. yield()方法:
   - yield()方法是Thread类的静态方法,可以通过Thread.yield()调用。
   - yield()方法会让当前线程主动放弃CPU执行时间,使得其他具有相同优先级的线程有机会执行。
   - yield()方法不会进入阻塞状态,而是重新进入就绪状态,等待CPU调度器分配执行时间。

2. sleep()方法:
   - sleep()方法是Thread类的静态方法,可以通过Thread.sleep()调用。
   - sleep()方法会使当前线程暂停执行,进入阻塞状态,但不会释放锁资源。
   - sleep()方法参数为时间,指定线程暂停的时间段,单位是毫秒(也可以使用纳秒)。
   - 在睡眠时间结束后,线程会重新进入就绪状态,等待CPU执行。

3. wait()方法:
   - wait()方法是Object类的方法,可以通过对象实例调用。
   - wait()方法会使当前线程暂停执行,进入阻塞状态,同时释放对象的同步锁资源。
   - wait()方法必须在synchronized代码块或方法中调用。
   - 调用wait()方法后,必须通过其他线程调用该对象的notify()或notifyAll()方法来唤醒等待的线程。

4. join()方法:
   - join()方法是Thread类的方法,可以通过Thread.join()调用。
   - join()方法会让当前线程等待被调用线程执行完毕,即当前线程暂停执行,直到被调用线程执行完毕或超时。
   - join()方法可以用于线程间的协作,使得多个线程按预期的顺序执行。
   - 如果调用join()方法的线程已经是终止状态(Terminated),那么join()方法会立即返回。

总结:
yield()方法是让出CPU执行时间给同优先级的其他线程;
sleep()方法是使当前线程暂停执行一段时间;
wait()方法是使当前线程进入阻塞状态并释放锁资源,需要通过其他线程来唤醒;
join()方法是让当前线程等待被调用线程执行完毕。

线程池的优点包括:

  1. 提高系统性能:使用线程池可以避免频繁创建和销毁线程的开销,减少系统资源的占用。通过对线程的复用,可以高效地处理大量的任务,提高系统的吞吐量和响应速度。

  2. 控制并发线程数量:线程池可以限制并发线程的数量,防止过多的线程竞争导致系统资源的不足或过载。可以通过设置线程池的大小来平衡系统负载,提供更好的性能和稳定性。

  3. 提供线程管理和调度:线程池可以管理线程的生命周期,包括创建、启动、暂停、恢复和销毁。线程池还可以根据任务的优先级和调度策略,合理地分配和调度线程,保证任务的有序执行。

  4. 支持任务队列:线程池通常会使用任务队列来存储待执行的任务。当线程池中的线程都处于忙碌状态时,新任务可以被放入队列中等待执行,避免任务丢失或阻塞。

  5. 提供更好的代码结构和可维护性:使用线程池可以将任务的提交与具体的线程管理分离,使得代码的结构更清晰,易于理解和维护。通过将任务的执行逻辑封装为独立的任务对象,可以提高代码的模块化和复用性。

综上所述,线程池能够提高系统的性能、稳定性和可维护性,为并发编程提供了一种有效的管理和调度机制。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程安全,并发的知识有加深认知;当然,现在用过的东西并不是代表以后还能娴熟的使用,做好笔记非常重要; 1:必须明白为什么要使用线程池:(这点很重要)   a:手上项目所需,因为项目主要的目的是实现多线程的数据推送;需要创建多线程的话,那就要处理好线程安全的问题;因为项目需要,还涉及到排队下载的功能,所以就选择了线程池来管理线程以及线程池里面的任务队列workQueue来实现项目所需的功能;   b:在实际使用中,服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大,甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外,活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程,可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足,服务器应用程序需要采取一些办法来限制任何给定时刻处理的请求数目,尽可能减少创建和销毁线程的次数,特别是一些资源耗费比较大的线程的创建和销毁,尽量利用已有对象来进行服务,这就是“池化资源”技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题(这段是摘自网络) 2:如何创建一个线程池:    复制代码 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; } 复制代码 这里只是创建线程池其中的一个构造函数;其实其他的构造函数最终还是调用的这个构造函数; 说明一下这些参数的作用: corePoolSize:核心池的大小,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中; maximumPoolSize:线程池最大线程数,它表示在线程池中最多能创建多少个线程;这个参数是跟后面的阻塞队列联系紧密的;只有当阻塞队列满了,如果还有任务添加到线程池的话,会尝试new 一个Thread的进行救急处理,立马执行对应的runnable任务;如果继续添加任务到线程池,且线程池中的线程数已经达到了maximumPoolSize,那么线程就会就会执行reject操作(这里后面会提及到) keepAliveTime:表示线程没有任务执行时最多保持多久时间会终止;默认情况下,只有当线程池中的线程数大于corePoolSize时,keepAliveTime才会起作用;即当线程池中的线程数大于corePoolSize时,如果一个线程空闲的时间达到keepAliveTime,则会终止,直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法并设置了参数为true,在线程池中的线程数不大于corePoolSize时,keepAliveTime参数也会起作用,直到线程池中的阻塞队列大小为0;(这部分通过查看ThreadPoolExecutor的源码分析--getTask()部分); unit:参数keepAliveTime的时间单位,有7种取值,在TimeUnit类中有7种静态属性(时间单位) workQueue:一个阻塞队列,用来存储等待执行的任务,这个参数的选择也很重要,会对线程池的运行过程产生重大影响,一般来说,这里的阻塞队列有以下几种选择     ArrayBlockingQueue;   LinkedBlockingQueue;   SynchronousQueue;   ArrayBlockingQueue和PriorityBlockingQueue使用较少,一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。 threadFactory:线程工厂,主要用来创建线程:默认值 DefaultThreadFactory; handler:表示当拒绝处理任务时的策略,就是上面提及的reject操作;有以下四种取值:   ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。(默认handle)   ThreadPoolExecutor.DiscardPolicy:也是丢弃任务,但是不抛出异常。   ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新尝试执行任务(重复此过程)   ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务 3:对线程池的基本使用及其部分源码的分析(注意:这里的源码分析是基于jdk1.6;) a:线程池的状态 volatile int runState; static final int RUNNING = 0; 运行状态 static final int SHUTDOWN = 1; 关闭状态;SHUTDOWN状态,此时线程池不能够接受新的任务,它会等待所有任务执行完毕 static final int STOP = 2;停止状态;此时线程池不能接受新的任务,并且会去尝试终止正在执行的任务 static final int TERMINATED = 3;终止状态;当线程池处于SHUTDOWN或STOP状态,并且所有工作线程已经销毁,任务缓存队列已经清空或执行结束后,线程池被设置为TERMINATED状态 b:参数再次说明。这是摘自网络的解释,我觉得他比喻的很好,所以这里直接就用它的解释   这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。   corePoolSize在很多地方被翻译成核心池大小,其实我的理解这个就是线程池的大小。举个简单的例子:   假如有一个工厂,工厂里面有10个工人,每个工人同时只能做一件任务。   因此只要当10个工人中有工人是空闲的,来了任务就分配给空闲的工人做;   当10个工人都有任务在做时,如果还来了任务,就把任务进行排队等待;   如果说新任务数目增长的速度远远大于工人做任务的速度,那么此时工厂主管可能会想补救措施,比如重新招4个临时工人进来;   然后就将任务也分配给这4个临时工人做;   如果说着14个工人做任务的速度还是不够,此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。   当这14个工人当中有人空闲时,而新任务增长的速度又比较缓慢,工厂主管可能就考虑辞掉4个临时工了,只保持原来的10个工人,毕竟请额外的工人是要花钱的。   这个例子中的corePoolSize就是10,而maximumPoolSize就是14(10+4)。   也就是说corePoolSize就是线程池大小,maximumPoolSize在我看来是线程池的一种补救措施,即任务量突然过大时的一种补救措施。   不过为了方便理解,在本文后面还是将corePoolSize翻译成核心池大小。   largestPoolSize只是一个用来起记录作用的变量,用来记录线程池中曾经有过的最大线程数目,跟线程池的容量没有任何关系。 c:添加线程池任务的入口就是execute(); 复制代码 public void execute(Runnable command) { if (command == null) throw new NullPointerException();//任务为空时抛出异常 //如果线程池线程大小小于核心线程,就新建一个线程加入任务并启动线程 //如果线程池线程大小大于核心线且且添加任务到线程失败,就把任务添加到阻塞队列 if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {//新建线程并启动 if (runState == RUNNING && workQueue.offer(command)) {//添加任务到队列 if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command);//添加到队列失败或已满,做拒接任务处理策略 } //若阻塞队列失败或已满;这里新建一个线程并启动做应急处理(这里就是用到了maximumPoolSize参数) else if (!addIfUnderMaximumPoolSize(command)) reject(command); // 若线程池的线程超过了maximumPoolSize;就做拒绝处理任务策略 } } 复制代码 -->>继续跟踪代码到addIfUnderCorePoolSize(Runnable firstTask):函数名称就可以看出来这个函数要执行的什么;如果线程池的线程小于核心线程数corePoolSize就新建线程加入任务并启动线程【在今后的开发中尽量把需要做的功能在函数名体现出来】 复制代码 private boolean addIfUnderCorePoolSize(Runnable firstTask) { Thread t = null; final ReentrantLock mainLock = this.mainLock;//获取当前线程池的锁 mainLock.lock();//加锁 try { /* 这里线程池线程大小还需要判断一次;前面的判断过程中并没有加锁,因此可能在execute方法判断的时候poolSize小于corePoolSize,而判断完之后,在其他线程中又向线程池提交了任务,就可能导致poolSize不小于corePoolSize了,所以需要在这个地方继续判断 */ if (poolSize < corePoolSize && runState == RUNNING) t = addThread(firstTask);//新建线程 } finally { mainLock.unlock(); } if (t == null) return false; t.start();//若创建线程超过,就启动线程池的线程 return true; } private Thread addThread(Runnable firstTask) { Worker w = new Worker(firstTask);//worker:ThreadPoolExecutor的内部类; Thread t = threadFactory.newThread(w);//使用线程工厂创建一个线程 if (t != null) { w.thread = t; workers.add(w);//保存线程池正在运行的线程 int nt = ++poolSize;//线程池的线程数加1 if (nt > largestPoolSize) largestPoolSize = nt; } return t; } 复制代码 -->>接下来定位worker类,看看线程池里的线程是如何执行的 上面的addIfUnderCorePoolSize(..)已经把线程启动了;现在就直接查看worker 的run()方法了 复制代码 public void run() { try { Runnable task = firstTask;//该线程的第一个任务,执行完后就从阻塞队列取任务执行 firstTask = null; while (task != null || (task = getTask()) != null) {//getTask()从队列去任务执行 runTask(task);//线程执行任务 task = null; } } finally { workerDone(this);//若任务全部执行完,就开始尝试去停止线程池;这部分代码就不再追踪下去,有兴趣的读者可以自己打开源码分析,不必害怕,学习大神们的编码方式,看源码能让你学习到很多 } } private void runTask(Runnable task) { final ReentrantLock runLock = this.runLock; runLock.lock(); try { //多次检查线程池有没有关闭 if (runState < STOP && Thread.interrupted() && runState >= STOP) thread.interrupt(); boolean ran = false; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法,来做一些执行任务之前的统计工作或者用来保存正在执行的任务 beforeExecute(thread, task); try { task.run(); ran = true; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法,来做一些执行任务完成之后的统计工作或者用来保存正在执行的任务 afterExecute(task, null); ++completedTasks;//统计总共执行的任务数 } catch (RuntimeException ex) { if (!ran) afterExecute(task, ex); throw ex; } } finally { runLock.unlock(); } } 复制代码 至此线程池基本的流程完了; 再说说我在项目中的使用: MyExtendThreadPoolExecutor 继承了 ThreadPoolExecutor,并覆盖了其中的一些方法 复制代码 public class MyExtendThreadPoolExecutor extends ThreadPoolExecutor{ public static Logger logger=LoggerFactory.getLogger(MyExtendThreadPoolExecutor.class); /** * 记录运行中任务 */ private LinkedBlockingQueue<Runnable> workBlockingQueue=new LinkedBlockingQueue<Runnable>(); public MyExtendThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); } @Override protected void beforeExecute(Thread t, Runnable r) { super.beforeExecute(t, r); workBlockingQueue.add((GtdataBreakpointResumeDownloadThread)r);//保存在运行的任务 logger.info("Before the task execution"); } @Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); workBlockingQueue.remove((GtdataBreakpointResumeDownloadThread)r);//移除关闭的任务 logger.info("After the task execution"); } /** * * Description: 正在运行的任务 * @return LinkedBlockingQueue<Runnable><br> * @author lishun */ public LinkedBlockingQueue<Runnable> getWorkBlockingQueue() { return workBlockingQueue; } } 复制代码 MyExtendThreadPoolExecutor pool = new MyExtendThreadPoolExecutor(3, 3,60L,TimeUnit.SECONDS,new LinkedBlockingQueue <Runnable>()); //创建线程池 复制代码 public void addToThreadPool(DownloadRecord downloadRecord){ BlockingQueue<Runnable> waitThreadQueue = pool.getQueue();//Returns the task queue LinkedBlockingQueue<Runnable> workThreadQueue =pool.getWorkBlockingQueue();//Returns the running work GtdataBreakpointResumeDownloadThread downloadThread = new GtdataBreakpointResumeDownloadThread(downloadRecord);//需要执行的任务线程 if (!waitThreadQueue.contains(downloadThread)&&!workThreadQueue.contains(downloadThread)) {//判断任务是否存在正在运行的线程或存在阻塞队列,不存在的就加入线程池(这里的比较要重写equals()) Timestamp recordtime = new Timestamp(System.currentTimeMillis()); logger.info("a_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" add to workThreadQueue"); downloadThread.setName("th_"+downloadRecord.getName()); pool.execute(downloadThread);//添加到线程池 }else{ logger.info("i_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" in waitThreadQueue or workThreadQueue"); } }
Java线程池是一种用于管理和复用线程的机制,它可以提高多线程程序的性能和效率。在Java中,线程池由ThreadPoolExecutor类实现,通过设置不同的参数可以对线程池的行为进行调整。 以下是Java线程池的一些常用参数及其解释: 1. corePoolSize(核心线程数):线程池中始终保持的活动线程数,即使它们处于空闲状态。当有新任务提交时,如果活动线程数小于corePoolSize,则会创建新线程来处理任务。 2. maximumPoolSize(最大线程数):线程池中允许存在的最大线程数。当活动线程数达到maximumPoolSize并且工作队列已满时,新任务将会被拒绝。 3. keepAliveTime(线程空闲时间):当线程池中的线程数量超过corePoolSize时,多余的空闲线程在等待新任务到来时的最长等待时间。超过这个时间,空闲线程将被终止。 4. unit(时间单位):keepAliveTime的时间单位,可以是秒、毫秒、微秒等。 5. workQueue(工作队列):用于存储等待执行的任务的阻塞队列。常见的工作队列有ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。 6. threadFactory(线程工厂):用于创建新线程的工厂类。可以自定义线程的名称、优先级等属性。 7. handler(拒绝策略):当线程池无法接受新任务时的处理策略。常见的拒绝策略有AbortPolicy(默认,抛出RejectedExecutionException异常)、CallerRunsPolicy(由调用线程执行任务)、DiscardPolicy(直接丢弃任务)和DiscardOldestPolicy(丢弃最旧的任务)。 这些参数可以根据实际需求进行调整,以达到最佳的线程池性能和资源利用率。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值