1、juc入门(线程池原理详解一)

1. 线程的6种状态

   1、新建状态(New)：新创建了一个线程对象。

   2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权，

      即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。

   3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

   4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

      阻塞的情况分三种：

   ①.等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，

      必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，

   ②.同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。

   ③.其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时，

      或者I/O处理完毕时，线程重新转入就绪状态。

   5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

2. 

3. 如何理解内存泄漏问题？有哪些情况会导致内存泄露？如何 解决？

   1. 什么是内存泄露：内存泄露的定义：对于应用程序来说，当对象已经不再被使用，但是Java的垃圾回收器不能回收它们的 时候，就产生了内存泄露。
   2. 上图中包含了未引用对象和引用对象。未引用对象将会被垃圾回收器回收，而引用对象却不会。未引用 对象很显然是无用的对象。然而，无用的对象并不都是未引用对象，有一些无用对象也有可能是引用对 象，这部分对象正是内存泄露的来源。
   3. 为什么内存泄露会发生 让我们用下面的例子来看看为什么会发生内存泄露。如上图所示，对象A引用对象B，A的生命周期（t1- t4）比B的生命周期（t2-t3）要长，当B在程序中不再被使用的时候，A仍然引用着B。在这种情况下， 垃圾回收器是不会回收B对象的，这就可能造成了内存不足问题，因为A可能不止引用着B对象，还可能 引用其它生命周期比A短的对象，这就造成了大量无用对象不能被回收，且占据了昂贵的内存资源。 同样的，B对象也可能引用着一大堆对象，这些被B对象引用着的对象也不能被垃圾回收器回收，所有的 这些无用对象消耗了大量内存资源。
   4. 怎样阻止内存泄露
      1. 使用List、Map等集合时，在使用完成后赋值为null
      2. 使用大对象时，在用完后赋值为null
      3. 目前已知的jdk1.6的substring()方法会导致内存泄露
      4. 避免一些死循环等重复创建或对集合添加元素，撑爆内存
      5. 简洁数据结构、少用静态集合等
      6. 及时的关闭打开的文件，socket句柄等
      7. 多关注事件监听(listeners)和回调(callbacks)，比如注册了一个listener，当它不再被使用的时候，忘 了注销该listener，可能就会产生内存泄露

4. 线程池的原理，为什么要创建线程池？创建线程池的方式;

   ---

    原理:

   线程池的优点 

           1、线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用。

           2、可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。

   线程池的创建

   public ThreadPoolExecutor(int corePoolSize, //线程池核心线程数量
       int maximumPoolSize, //线程池最大线程数量
       long keepAliveTime, //当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间
       TimeUnit unit, //存活时间的单位
       BlockingQueue<Runnable> workQueue, //存活时间的单位
       RejectedExecutionHandler handler) //：超出线程范围和队列容量的任务的处理程序

   ---

   线程池的实现原理

   1.   提交一个任务到线程池中，线程池的处理流程如下：

      1. 判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创 建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

      2. 线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如 果工作队列满了，则进入下个流程。

      3. 判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已 经满了，则交给饱和策略来处理这个任务。

• ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 60,
  TimeUnit.SECONDS, queue);
  线程池中活跃的线程数： 1
  线程池中活跃的线程数： 2
  线程池中活跃的线程数： 3
  线程池中活跃的线程数： 4
  线程池中活跃的线程数： 5
  线程池中活跃的线程数： 5
  ----------------队列中阻塞的线程数1
  线程池中活跃的线程数： 5
  ----------------队列中阻塞的线程数2
  线程池中活跃的线程数： 5
  ----------------队列中阻塞的线程数3
  线程池中活跃的线程数： 5
  ----------------队列中阻塞的线程数4
  线程池中活跃的线程数： 5
  ----------------队列中阻塞的线程数5
  线程池中活跃的线程数： 6
  ----------------队列中阻塞的线程数5
  线程池中活跃的线程数： 7
  ----------------队列中阻塞的线程数5
  线程池中活跃的线程数： 8
  ----------------队列中阻塞的线程数5
  线程池中活跃的线程数： 9
  ----------------队列中阻塞的线程数5
  线程池中活跃的线程数： 10
  ----------------队列中阻塞的线程数5
  Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task
  Thread[Thread15,5,main] rejected from
  java.util.concurrent.ThreadPoolExecutor@232204a1[Running, pool size = 10, active
  threads = 10, queued tasks = 5, completed tasks = 0]
  at
  java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPool
  Executor.java:2047)
  at
  java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
  at
  java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
  at test.ThreadTest.main(ThreadTest.java:17)
  

  从结果可以观察出：

  1、创建的线程池具体配置为：核心线程数量为5个；全部线程数量为10个；工作队列的长度为5。

  2、我们通过queue.size()的方法来获取工作队列中的任务数。

  3、运行原理：

  刚开始都是在创建新的线程，达到核心线程数量5个后，新的任务进来后不再创建新的线程，而是将任 务加入工作队列，任务队列到达上线5个后，新的任务又会创建新的普通线程，直到达到线程池最大的线 程数量10个，后面的任务则根据配置的饱和策略来处理。我们这里没有具体配置，使用的是默认的配置 AbortPolicy:直接抛出异常。

---

5.RejetedExecutionHandler：饱和策略

当队列和线程池都满了，说明线程池处于饱和状态，那么必须对新提交的任务采用一种特殊的策略来进 行处理。这个策略默认配置是AbortPolicy，表示无法处理新的任务而抛出异常。JAVA提供了4中策略：

1、AbortPolicy：直接抛出异常

2、CallerRunsPolicy：只用调用所在的线程运行任务

3、DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。

4、DiscardPolicy：不处理，丢弃掉。

 丢弃策略

 public static void main(String[] args){
     LinkedBlockingQueue<Runnable> queue =
            new LinkedBlockingQueue<Runnable>(3);
     RejectedExecutionHandler handler = 
            newThreadPoolExecutor.DiscardPolicy();

     ThreadPoolExecutor threadPool = new 
            ThreadPoolExecutor(2, 5, 60,TimeUnit.SECONDS, queue,handler);
    for (int i = 0; i < 9 ; i++){
        threadPool.execute(
        new Thread(new ThreadPoolTest(), "Thread".concat(i + "")));
        System.out.println("线程池中活跃的线程数： " +
        threadPool.getPoolSize());
        if (queue.size() > 0)
            {
            System.out.println("----------------队列中阻塞的线程数" +
            queue.size());
        }
    }
    threadPool.shutdown();
}

/*
线程池中活跃的线程数： 1
线程池中活跃的线程数： 2
线程池中活跃的线程数： 2
----------------队列中阻塞的线程数1
线程池中活跃的线程数： 2
----------------队列中阻塞的线程数2
线程池中活跃的线程数： 2
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 3
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 4
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数3

*/

这里采用了丢弃策略后，就没有再抛出异常，而是直接丢弃。在某些重要的场景下，可以采用记录日志 或者存储到数据库中，而不应该直接丢弃。

设置策略有两种方式：

1.

RejectedExecutionHandler handler = 
            new ThreadPoolExecutor.DiscardPolicy();
ThreadPoolExecutor threadPool = 
            new ThreadPoolExecutor(2, 5, 60,TimeUnit.SECONDS, queue,handler);

2.

ThreadPoolExecutor threadPool = 
                new ThreadPoolExecutor(2, 5, 60,TimeUnit.SECONDS, queue);
threadPool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());