环境：JDK1.8

线程池中如果发生OOM后会如何？

线程池ThreadPoolExecutor当有线程发生了OOM，线程池会停止工作吗？

public static void main(String[] args) {
  ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2)) ;
  pool.execute(() -> {
    int i = 0 ;
    for (;;) {
      System.out.println(Thread.currentThread().getName() + ", i = " + (i++) + "," + pool) ;
		  try {
        TimeUnit.MILLISECONDS.sleep(50) ;
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  });
  pool.execute(() -> {
    int j = 0 ;
    for (;;) {
      System.out.println(Thread.currentThread().getName() + ", j = " + (j++) + "," + pool) ;
      try {
        TimeUnit.MILLISECONDS.sleep(50) ;
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  });
  pool.execute(() -> {
    int k = 0 ;
    List<byte[]> datas = new ArrayList<>() ;
    for (;;) {
      System.out.println(Thread.currentThread().getName() + ", k = " + (k++) + "," + pool) ;
      byte[] buf = new byte[1024 * 100] ;
      datas.add(buf) ;
      try {
        TimeUnit.MILLISECONDS.sleep(20) ;
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  });
}

调整JVM运行内存

-Xms10m -Xmx10m

执行结果：

一开始3个线程交替执行，当其中一个线程发生OOM后，线程池中除了发生OOM的线程池不再继续工作外，其它的线程都继续工作。

自定义线程异常处理

ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 60, TimeUnit.SECONDS,
  new ArrayBlockingQueue<Runnable>(2), new ThreadFactory() {
    private final ThreadGroup group = new ThreadGroup("Pack-Group");
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix = "pool-custom-thread-";

   @Override
  public Thread newThread(Runnable r) {
    Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
    t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
      @Override
      public void uncaughtException(Thread t, Throwable e) {
        System.out.println("自定义线程异常处理：" + t.getName());
        e.printStackTrace();
     }});
    return t;
  }
});

线程池的拒绝策略

代码：

ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), new ThreadPoolExecutor.AbortPolicy()) ;
  for (int i = 0; i < 6; i++) {
    pool.execute(() -> {
      System.out.println(Thread.currentThread().getName() + ", 进入执行") ;
      try {
        TimeUnit.SECONDS.sleep(2) ;
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    });
  }
System.out.println("ActiveCount: " + pool.getActiveCount()) ;
System.out.println("PoolSize: " + pool.getPoolSize()) ;
System.out.println("TaskCount: " + pool.getTaskCount()) ;

1、AbortPolicy策略

ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), new ThreadPoolExecutor.AbortPolicy()) ;

当任务数 > 线程数 + 队列大小。超过的任务直接拒绝并且抛出异常。程序不会继续往下执行。

2、CallerRunsPolicy策略

ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), new ThreadPoolExecutor.CallerRunsPolicy()) ;

超过的任务会由调用者线程（执行execute方法所在的线程）执行任务。

3、DiscardOldestPolicy策略

ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), new ThreadPoolExecutor.DiscardOldestPolicy()) ;
for (int i = 0; i < 5; i++) {
  pool.execute(() -> {
    System.out.println(Thread.currentThread().getName() + ", 进入执行") ;
    try {
      TimeUnit.SECONDS.sleep(2) ;
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  });
}
System.out.println("ActiveCount: " + pool.getActiveCount()) ;
System.out.println("PoolSize: " + pool.getPoolSize()) ;
System.out.println("TaskCount: " + pool.getTaskCount()) ;
pool.execute(() -> {
  System.out.println(Thread.currentThread().getName() + ", 我是新入任务") ;
});

执行结果：

该策略会把任务队列中的列头删除，然后将自己放入队列（列尾）

4、DiscardPolicy策略

ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), new ThreadPoolExecutor.DiscardPolicy()) ;
for (int i = 0; i < 7; i++) {
  pool.execute(() -> {
    System.out.println(Thread.currentThread().getName() + ", 进入执行") ;
    try {
      TimeUnit.SECONDS.sleep(2) ;
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  });
}
System.out.println("ActiveCount: " + pool.getActiveCount()) ;
System.out.println("PoolSize: " + pool.getPoolSize()) ;
System.out.println("TaskCount: " + pool.getTaskCount()) ;
TimeUnit.SECONDS.sleep(5) ;
pool.execute(() -> {
  System.out.println(Thread.currentThread().getName() + ", 新任务执行") ;
});

执行结果：

该策略什么也不做，线程池能够正常继续执行下去。

自定义线程池

自定义线程池监控线程执行耗时时间

public class CustomThreadPool extends ThreadPoolExecutor {
  public CustomThreadPool(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);
    if (r instanceof Task) {
      ((Task) r).setStart(System.currentTimeMillis()) ;
      System.out.println(t.getName() + ", 开始执行") ;
    }
  }
  @Override
  protected void afterExecute(Runnable r, Throwable t) {
    super.afterExecute(r, t);
    if (r instanceof Task) {
      ((Task) r).times();
    }
  }
  public void execute(Task command) {
    super.execute(command);
  }
  public static class Task implements Runnable {
    private long start ;
    private Callback callback ;
    public Task(Callback callback) {
      this.callback = callback ;
    }
    @Override
    public void run() {
      if (this.callback != null) {
        this.callback.callback();
      }
    }
    public void times() {
      System.out.println(Thread.currentThread().getName() + " 执行耗时：" + (System.currentTimeMillis() - start) + "ms") ;
    }
    public void setStart(long start) {
      this.start = start;
    }
		
  }
  public static interface Callback {
    void callback() ;
  }
}

重写beforeExecute，afterExecute父类的这两个方法，线程执行前和执行后。

CustomThreadPool pool = new CustomThreadPool(3, 3, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2)) ;
pool.execute(new Task(() -> {
  try {
    TimeUnit.SECONDS.sleep(1) ;
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
})) ;
pool.execute(new Task(() -> {
  try {
    TimeUnit.SECONDS.sleep(3) ;
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
})) ;
pool.execute(new Task(() -> {
  try {
    TimeUnit.SECONDS.sleep(2) ;
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
})) ;

执行结果：

给个关注谢谢

现象

MAC

unable to creat new native thread
window
测试前 在启动测试类之前先将JVM内存调整小一点，不然很容易将电脑跑出问题
在idea里：Run -> Edit Configurations VM options修改成-Xms10M -Xmx10M
（-Xms10M Java Heap内存初始化值 -Xmx10M Java Heap内存最大值）

Exception in thread “main” java.lang.OutOfMemoryError: Java heap space。
代码

public static void main(String[] args) throws InterruptedException {
        AtomicInteger i = new AtomicInteger(0);
        for (; ; ) {
            Executors.newFixedThreadPool(10).submit(() -> System.out.println(i.getAndIncrement()));
            Thread.sleep(4);
        }
    }

循环创建线程池 而并没有关闭线程池，导致线程池的实例会一直存在

源码

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

   public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

原因分析

Java常见的GC Root
Java 进行GC的时候会从GC root进行可达性判断，常见的GC Root有如下：

1. 通过System Class Loader或者Boot Class Loader加载的class对象，通过自定义类加载器加载的class不一定是GC Root
2. 处于激活状态的线程
3. 栈中的对象
4. JNI栈中的对象
5. JNI中的全局对象
6. 正在被用于同步的各种锁对象
7. JVM自身持有的对象，比如系统类加载器等。
   在调查内存泄漏原因的时候可以根据GC Root来推导

当执行一个Runnable时，会先创建一个ThreadPoolExecutor中的内部类Worker对象，将这个Runnable对象作为Worker对象的一个成员变量

 Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
 private volatile ThreadFactory threadFactory;       
 public ThreadFactory getThreadFactory() {
        return threadFactory;
    }       

所以 当线程在执行的时候引用关系如下ThreadPoolExecutor->Worker->thread
一个运行的线程是作为GC ROOT的，不会被GC； 所以要主动shutdown

newSingleThreadExecutor不会有此问题，因为FinalizableDelegatedExecutorService 重写了finalize函数，也就是说这个类会在被GC回收之前，先执行线程池的shutdown方法。

java.util.concurrent.Executors

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

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

线程池的使用注意事项

ThreadPoolExecutor-线程池如何保证线程不被销毁