Java 线程池 newCachedThreadPool缓存线程池、newFixedThreadPool固定线程池

---

•  多进程、多线程、多线程中的共享变量的安全问题、同步锁、线程同步、ThreadLocal

• Java 线程池 newCachedThreadPool缓存线程池、newFixedThreadPool固定线程池

---

 

package src.main.sample;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class ThreadPoolExecutorTest
{
    public static void main(String[] args) throws InterruptedException
    {
        /*
        newCachedThreadPool：
                Executors.newCachedThreadPool()缓存线程池 与 固定线程池Executors.newFixedThreadPool(N) 的区别在于对于需要执行很多短期异步任务的程序来说，
                缓存线程池可以提高程序性能，因为长时间保持空闲的这种类型的线程池不会占用任何资源，调用缓存线程池对象将重用以前构造的线程（线程可用状态），
                若线程没有可用的，则创建一个新线程添加到池中，缓存线程池将终止并从池中移除60秒未被使用的线程。
                它是一个可以无限扩大的线程池；

         public static ExecutorService newCachedThreadPool()
         {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
         }
        corePoolSize为0，maximumPoolSize为无限大，意味着线程数量可以无限大；keepAliveTime为60S，意味着线程空闲时间超过60S就会被杀死；
        采用SynchronousQueue装等待的任务，这个阻塞队列没有存储空间，这意味着只要有请求到来，就必须要找到一条工作线程处理他，
        如果当前没有空闲的线程，那么就会再创建一条新的线程
         */

//        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        ExecutorService cachedThreadPool = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 100; i++)
        {
            final int index = i;

            cachedThreadPool.execute(new Runnable()
            {
                @Override
                public void run()
                {
                    System.out.println("线程名:"+Thread.currentThread().getName() + " \t index:" + index);

//                    System.out.println(Thread.currentThread().isInterrupted()); //isInterrupted() 默认返回为 false
                    Thread.currentThread().interrupt(); //发送 interrupt线程停止标志，此时 isInterrupted() 返回为 true，表示 interrupt线程停止标志生效
//                    System.out.println(Thread.currentThread().isInterrupted()); //true 表示 interrupt线程停止标志生效
                      //stop()：已过时，不建议使用
//                    Thread.currentThread().stop();

                    if (Thread.currentThread().isInterrupted())
                    {
                        return;
                    }
                    System.out.println("执行了 interrupt():线程已停止，此处不执行打印输出信息");
                  }
            });
        }


        /*
        shutdown()
            将线程池状态置为SHUTDOWN，但并不会立即停止，而是首先停止接收外部submit/execute提交的的任务，
            内部正在跑的任务和队列里等待的任务，会等待执行完成后，才真正停止线程池。
        */
        cachedThreadPool.shutdown();// 只是声明线程池不再接收新的任务提交，即不再创建子线程，但是仍然会执行完所有已经提交创建的子线程
        //仅是判断线程池是否发出了shutdown的信号，然后就返回true，但是仍然会执行完所有已经提交创建的子线程
        System.out.println("isShutdown:"+cachedThreadPool.isShutdown());
        //在发出shutdown的信号后，所有已经提交创建的子线程都执行完成后，才返回true
        System.out.println("isTerminated:"+cachedThreadPool.isTerminated());
        while(true)
        {
            /*
                isShutDown当调用shutdown()或shutdownNow()方法后返回为true。 
                isTerminated当调用shutdown()方法后，并且所有提交的任务完成后返回为true;
                isTerminated当调用shutdownNow()方法后，成功停止后返回为true;
            */
            if(cachedThreadPool.isTerminated())
            {
                System.out.println("所有的子线程都结束了！");
                break;
            }
         }
//        //JAVA中获取可用的CPU数量
//        int cpuNum = Runtime.getRuntime().availableProcessors();
//        System.out.println("JAVA中获取可用的CPU数量:"+cpuNum);
    }
}