当前位置:首页 > 编程教程 > java技术文章 > java线程池使用后到底要关闭吗

java线程池使用后是否需要关闭

  • 发布时间:
  • 作者:码农之家
  • 点击:52

这篇文章主要知识点是关于java、线程池、java线程池需要关闭、java多线程教程之如何使用线程池详解 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子书

RxJava 2.x 实战
RxJava 2.x 实战完整清晰版
  • 类型:RxJava大小:149 MB格式:PDF作者:沈哲
立即下载

java线程池使用后到底要关闭吗

线程池做什么

网络请求通常有两种形式:

第一种,请求不是很频繁,而且每次连接后会保持相当一段时间来读数据或者写数据,最后断开,如文件下载,网络流媒体等。

另一种形式是请求频繁,但是连接上以后读/写很少量的数据就断开连接。考虑到服务的并发问题,如果每个请求来到以后服务都为它启动一个线程,那么这对服务的资源可能会造成很大的浪费,特别是第二种情况。

因为通常情况下,创建线程是需要一定的耗时的,设这个时间为T1,而连接后读/写服务的时间为T2,当T1>>T2时,我们就应当考虑一种策略或者机制来控制,使得服务对于第二种请求方式也能在较低的功耗下完成。

通常,我们可以用线程池来解决这个问题,首先,在服务启动的时候,我们可以启动好几个线程,并用一个容器(如线程池)来管理这些线程。

当请求到来时,可以从池中取一个线程出来,执行任务(通常是对请求的响应),当任务结束后,再将这个线程放入池中备用;

如果请求到来而池中没有空闲的线程,该请求需要排队等候。最后,当服务关闭时销毁该池即可。

然而最近在开发中用到了java的线程池,然后就很疑惑这个线程池到底要不要手动关闭,感觉是要关闭的,但是没人强调线程池用完要关闭。so今天来试验下到底线程池用完要不要关闭。

直接上实验代码

public static void main(String[] args) throws Exception {
  //用于获取到本java进程,进而获取总线程数
 RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();
 String jvmName = runtimeBean.getName();
 System.out.println("JVM Name = " + jvmName);
 long pid = Long.valueOf(jvmName.split("@")[0]);
 System.out.println("JVM PID = " + pid);
 ThreadMXBean bean = ManagementFactory.getThreadMXBean();
 int n = 30000;
 for (int i = 0; i < n; i++) {
  ThreadPoolExecutor executor = new ThreadPoolExecutor(10,20,1000,TimeUnit.SECONDS,new LinkedBlockingDeque<>());
  for(int j=0;j<10;j++){
   executor.execute(()->{
    System.out.println("当前线程总数为:"+bean.getThreadCount());
   });
  }
 }
 Thread.sleep(10000);
 System.out.println("线程总数为 = " + bean.getThreadCount());
}

简单来说就是在一个 for 循环中创建线程池,然后执行一个打印任务(不执行任务线程不会真正创建),打印出当前 java 进程的总线程数,下面是打印部分结果:

java线程池使用后到底要关闭吗

线程

可以看到在创建到 15 万个线程是爆内存,内存占用百分百后 java 应用崩溃。说明线程未被回收。

PS:内存占用百分百后,部分应用开始出现异常,界面花屏,闪屏,不能正常绘制gui,不知道为啥,即使后面内存占用降下来也一样,只能重启应用。

结论

使用完线程池一定记得回收,否则跑着跑着就内存爆炸崩溃。回收函数如下:

//执行此函数后线程池不再接收新任务,并等待所有任务执行完毕后销毁线程。此函数不会等待销毁完毕
executor.shutdown();
//立即结束所有线程,不管是否正在运行,返回未执行完毕的任务列表
executor.shutdownNow();

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对码农之家的支持。

java多线程教程之如何使用线程池详解

为什么要用线程池?

诸如 Web 服务器、数据库服务器、文件服务器或邮件服务器之类的许多服务器应用程序都面临处理来自某些远程来源的大量短小的任务。请求以某种方式到达服务器,这种方式可能是通过网络协议(例如 HTTP、FTP 或 POP)、通过 JMS 队列或者可能通过轮询数据库。不管请求如何到达,服务器应用程序中经常出现的情况是:单个任务处理的时间很短而请求的数目却是巨大的。

只有当任务都是同类型并且相互独立时,线程池的性能才能达到最佳。如果将运行时间较长的与运行时间较短的任务混合在一起,那么除非线程池很大,否则将可能造成拥塞,如果提交的任务依赖于其他任务,那么除非线程池无线大,否则将可能造成死锁。

例如饥饿死锁:线程池中的任务需要无限等待一些必须由池中其他任务才能提供的资源或条件。

ThreadPoolExecutor的通用构造函数:(在调用完构造函数之后可以继续定制ThreadPoolExecutor)

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

饱和策略:

ThreadPoolExecutor允许提供一个BlockingQueue来保存等待执行的任务。

当有界队列被填满后,饱和策略开始发挥作用。可以通过调用setRejectedExecutionHandler来修改。

中止是默认的饱和策略,该策略将抛出未检查的RejectedExecutionException,调用者可以捕获这个异常,然后根据需求编写自己的处理代码。

调用者运行策略实现了一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将某些任务回退到调用者,从而降低新任务的流量。

例如对于WebServer,当线程池中的所有线程都被占用,并且工作队列被填满后,下一个任务在调用execute时在主线程中执行。

由于执行任务需要一定的时间,因此主线程至少在一段时间内不能提交任何任务,从而使得工作者线程有时间来处理完正在执行的任务。

在这期间,主线程不会调用accept,因此到达的请求将被保存在TCP层的队列中而不是在应用程序的队列中,如果持续过载,那么TCP层最终发现它的请求队列被填满,同样会开始抛弃请求。

因此当服务器过载时,这种过载会逐渐向外蔓延开来---从线程池到工作队列到应用程序再到TCP层,最终到达客户端,导致服务器在高负载下实现一种平缓的性能降低。

exec.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

当工作队列被填满后,没有预定于的饱和策略来阻塞execute。而通过Semaphore来现在任务的到达率,可以实现。

/**
 * 设置信号量的上界设置为线程池的大小加上可排队任务的数量,控制正在执行和等待执行的任务数量。
 */
public class BoundedExecutor {
 
 private final Executor exec;
 private final Semaphore semaphore;
 
 public BoundedExecutor(Executor exec,int bound){
  this.exec = exec;
  this.semaphore = new Semaphore(bound);
 }
 
 public void submitTask(final Runnable task) throws InterruptedException{
  semaphore.acquire();
  try{
   exec.execute(new Runnable(){
    public void run(){
     try{
      task.run();
     }finally{
      semaphore.release();
     }
    }
   });
  }catch(RejectedExecutionException e){
   semaphore.release();
  }
 }
}

线程工厂

线程池配置信息中可以定制线程工厂,在ThreadFactory中只定义了一个方法newThread,每当线程池需要创建一个新线程时都会调用这个方法。

public interface ThreadFactory{
 Thread newThread(Runnable r);
}
// 示例:将一个特定于线程池的名字传递给MyThread的构造函数,从而可以再线程转储和错误日志信息中区分来自不同线程池的线程。
 public class MyThreadFactory implements ThreadFactory{
 
 private final String poolName;
 
 public MyThreadFactory(String poolName){
  this.poolName = poolName;
 }
 
 public Thread newThread(Runnable runnable){
  return new MyThread(runnable,poolName);
 }
}
// 示例:为线程指定名字,设置自定义UncaughtExceptionHandler向Logger中写入信息及维护一些统计信息以及在线程被创建或者终止时把调试消息写入日志。
public class MyThread extends Thread{
 public static final String default_name = "myThread";
 private static volatile boolean debugLifecycle = false;
 private static final AtomicInteger created = new AtomicInteger();
 private static final AtomicInteger alive = new AtomicInteger();
 private static final Logger log = Logger.getAnonymousLogger();

 public MyThread(Runnable runnable){
  this(runnable,default_name);
 }

 public MyThread(Runnable runnable, String defaultName) {
  super(runnable,defaultName + "-" + created.incrementAndGet());
  setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
   @Override
   public void uncaughtException(Thread t, Throwable e) {
    log.log(Level.SEVERE,"uncaught in thread " + t.getName(), e); 

   }
  });
 }

 public void run(){
  boolean debug = debugLifecycle;
  if(debug){
   log.log(Level.FINE,"created " + getName());
  }
  try{
   alive.incrementAndGet();
   super.run();
  }finally{
   alive.decrementAndGet();
   if(debug){
    log.log(Level.FINE,"Exiting " + getName());
   }
  }

 }
}

扩展ThreadPoolExecutor

在线程池完成关闭操作时调用terminated,也就是在所有任务都已经完成并且所有工作者线程也已经关闭后。terminated可以用来释放Executor在其生命周期里分配的各种资源,此外还可以执行发送通知、记录日志或者收集finalize统计信息等操作。

示例:给线程池添加统计信息

/**
 * TimingThreadPool中给出了一个自定义的线程池,通过beforeExecute、afterExecute、terminated等方法来添加日志记录和统计信息收集。
 * 为了测量任务的运行时间,beforeExecute必须记录开始时间并把它保存到一个afterExecute可用访问的地方。
 * 因为这些方法将在执行任务的线程中调用,因此beforeExecute可以把值保存到一个ThreadLocal变量中。然后由afterExecute来取。
 * 在TimingThreadPool中使用了两个AtomicLong变量,分别用于记录已处理的任务和总的处理时间,并通过包含平均任务时间的日志消息。
 */
public class TimingThreadPool extends ThreadPoolExecutor{
 
 public TimingThreadPool(int corePoolSize, int maximumPoolSize,
   long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
  super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
 }
 
 private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
 private final Logger log = Logger.getLogger("TimingThreadPool");
 private final AtomicLong numTasks = new AtomicLong();
 private final AtomicLong totalTime = new AtomicLong();
 
 protected void beforeExecute(Thread t,Runnable r){
  super.beforeExecute(t, r);
  log.fine(String.format("Thread %s: start %s", t,r));
  startTime.set(System.nanoTime());
 }
 
 protected void afterExecute(Throwable t,Runnable r){
  try{
   long endTime = System.nanoTime();
   long taskTime = endTime - startTime.get();
   numTasks.incrementAndGet();
   totalTime.addAndGet(taskTime);
   log.fine(String.format("Thread %s: end %s, time=%dns", t,r,taskTime));
  }finally{
   super.afterExecute(r, t);
  }
 }
 
 protected void terminated(){
  try{
   log.info(String.format("Terminated: avg time=%dns", totalTime.get()/numTasks.get()));
  }finally{
   super.terminated();
  }
 }
}

#笔记内容参考  《java并发编程实战》

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对码农之家的支持。

以上就是本次给大家分享的关于java的全部知识点内容总结,大家还可以在下方相关文章里找到相关文章进一步学习,感谢大家的阅读和支持。

您可能感兴趣的文章:

  • 关于java线程池重要设置详解
  • java线程池需要关闭 相关电子书
    学习笔记
    网友NO.725183

    java编写属于自己的线程池

    什么是线程池 线程池就是以一个或多个线程[循环执行]多个应用逻辑的线程集合. 一般而言,线程池有以下几个部分: 完成主要任务的一个或多个线程. 用于调度管理的管理线程. 要求执行的任务队列. 线程池的作用: 线程池作用就是限制系统中执行线程的数量。 根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果;少了浪费了系统资源,多了造成系统拥挤效率不高。用线程池控制线程数量,其他线程排队等候。一个任务执行完毕,再从队列的中取最前面的任务开始执行。若队列中没有等待进程,线程池的这一资源处于等待。当一个新任务需要运行时,如果线程池中有等待的工作线程,就可以开始运行了;否则进入等待队列。 自己实现线程池 根据如上对线程池的理解,我们自己编写一个属于自己的简单线程池: 简单的线程池接口……

    网友NO.861393

    java线程池工作队列饱和策略代码示例

    线程池(Thread Pool) 是并行执行任务收集的实用工具。随着 CPU 引入适合于应用程序并行化的多核体系结构,线程池的作用正日益显现。通过 ThreadPoolExecutor类及其他辅助类,Java 5 引入了这一框架,作为新的并发支持部分。 ThreadPoolExecutor框架灵活且功能强大,它支持特定于用户的配置并提供了相关的挂钩(hook)和饱和策略来处理满队列 Java线程池会将提交的任务先置于工作队列中,在从工作队列中获取(SynchronousQueue直接由生产者提交给工作线程)。那么工作队列就有两种实现策略:无界队列和有界队列。无界队列不存在饱和的问题,但是其问题是当请求持续高负载的话,任务会无脑的加入工作队列,那么很可能导致内存等资源溢出或者耗尽。而有界队列不会带来高负载导致的内存耗尽的问题,但是有引发工作队列已满情况下,新提交的任务如何管理的难……

    网友NO.582252

    java简单实现多线程及线程池实例详解

    本文为大家分享了java多线程的简单实现及线程池实例,供大家参考,具体内容如下 一、多线程的两种实现方式 1、继承Thread类的多线程 /** * 继承Thread类的多线程简单实现 */ public class extThread extends Thread { public void run(){ for(int i=0;i100;i++){ System.out.println(getName()+"-"+i); } } public static void main(String arg[]){ for(int i=0;i100;i++){ System.out.println(Thread.currentThread().getName()+"-"+i); if(i==50){ new extThread().start(); new extThread().start(); } } } } 2、实现Runnable接口的多线程 /** * 实现runable接口的多线程实例 */ public class runThread implements Runnable { public void run(){ for(int i=0;i100;i++){ System.out.println(Thread.currentThread().getName()+"-"+i); } } public static void main(String arg[]){ for(int i=0;i100;i++){ System.out.println(Thread.currentThread().getName()+"-"+i); if(i==50){ runThread rt = new runThread(); new Thread(rt,"新线程1").start(); new Thread(rt,"新线程……

    网友NO.693073

    搞懂Java线程池

    身为程序员我们对线程是再熟悉不过了,多线程并发算是Java进阶的知识,用好多线程不容易有太多的坑。创建线程也算是一个"重"操作。创建线程的语句是new Thread()咋一看好像就是new了一个对象。 没错是new了个对象,但是不仅仅是普通对象那样在堆中分配了一块内存,它还需要调用操作系统内核API,然后操作系统再为线程分配一些资源。所以较普通对象,线程就比较“重了”。所以我们要避免频繁的创建和销毁线程,还得控制一下线程的数量。线程池就是用来完成这一项使命的。 所以多线程就离不开线程池,所以要掌握多线程编程,线程池的了解必不可少。 线程池的设计就是采用生产者-消费者模式,线程池里面的线程是消费者,我们塞给线程池的任务是生产者。可以理解成线程池就是火车站售票厅,线程池里面的线程就是火车站售票厅窗口员工,……

    网友NO.709835

    Java concurrency线程池之线程池原理(二)_动力节点Java学院整理

    线程池示例 在分析线程池之前,先看一个简单的线程池示例。 import java.util.concurrent.Executors;import java.util.concurrent.ExecutorService;public class ThreadPoolDemo1 { public static void main(String[] args) { // 创建一个可重用固定线程数的线程池 ExecutorService pool = Executors.newFixedThreadPool(2); // 创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 Thread ta = new MyThread(); Thread tb = new MyThread(); Thread tc = new MyThread(); Thread td = new MyThread(); Thread te = new MyThread(); // 将线程放入池中进行执行 pool.execute(ta); pool.execute(tb); pool.execute(tc); pool.execute(td); pool.execute(te); // 关闭线程池 pool.shutdown(); }}class MyThread extends Thread { @Override public void run() { System.out.println(Thread.currentThread().getName()+ " is running."); }} 运行结果: pool-1-thread-1 is running.pool-1-thread-2 is running.pool-1-thread-1 is running.pool-1-thread-2 is running.pool-……

    <
    1
    >

    Copyright 2018-2020 www.xz577.com 码农之家

    投诉 / 推广 / 赞助:QQ:520161757