Use the executors class to quickly create a thread pool

       Executors  Class Executor、ExecutorService、ScheduledExecutorService、ThreadFactory and Callable Class factory methods and utility methods . This class supports the following methods :

      One 、 Introduction to methods in this class

          1. Static methods for creating various thread pools , The return value is ExecutorService

Method	describe
newCachedThreadPool()	Create a cache thread pool , Threads in the thread pool will survive 60s
newCachedThreadPool(ThreadFactory threadFactory)	Use the specified factory class , Create a cache thread pool , Threads in the thread pool will survive 60s
newFixedThreadPool(int nThreads)	Create a thread pool with a fixed number of threads
newFixedThreadPool(int nThreads, ThreadFactory threadFactory)	Use the specified factory class , Create a thread pool with a fixed number of threads
newSingleThreadExecutor()	Create a thread pool of threads
newSingleThreadExecutor(ThreadFactory threadFactory)	Use the specified factory class , Create a thread pool of threads

        2. Static methods for creating various thread pools , The return value is ScheduledExecutorService

Method	describe
newScheduledThreadPool(int corePoolSize)	Create a thread pool , The thread pool can schedule commands to run after a given delay or execute periodically
newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)	Use the specified factory class , Create a thread pool , The thread pool can schedule commands to run after a given delay or execute periodically
newSingleThreadScheduledExecutor()	Create a single threaded executor , The actuator can schedule commands to run after a given delay or execute them regularly
newSingleThreadScheduledExecutor(ThreadFactory threadFactory)	Use the specified factory class , Create a single threaded executor , The actuator can schedule commands to run after a given delay or execute them regularly

        3. Create and return one ThreadFactory, The ThreadFactory Set the newly created thread to a known state

Return value	Method	describe
static ThreadFactory	defaultThreadFactory()	Return a default thread factory class to create a new thread
static ThreadFactory	privilegedThreadFactory()	Returns a thread factory , This thread factory is used to create a new thread with the same permissions as the current thread ,privilegedThreadFactory Class inherited defaultThreadFactory class

        4. Create and return a from other closure like forms Callable Methods , Therefore, they can be used to need Callable How to execute

Return value	Method	describe
static Callable<Object>	callable(PrivilegedAction<?> action)	Return to one Callable object , The object runs the given privileged operation and returns its result when called
static Callable<Object>	callable(PrivilegedExceptionAction<?> action)	Return to one Callable object , The object runs the given privileged exception operation and returns its result when called
static Callable<Object>	callable(Runnable task)	Return to one Callable object , This object runs the given task when called and returns null
static <T> Callable<T>	callable(Runnable task, T result)	Return to one Callable object , This object runs the given task and returns the given result when called

  Two 、 Not recommended Executors Why

        Thread pools are not allowed Executors To create , But through ThreadPoolExecutor The way , This way of processing makes the students who write more clear about the running rules of the thread pool , Avoid the risk of resource exhaustion .Executors The disadvantages of each method ：

        1. newSingleThreadExecutor and newFixedThreadPool： The main problem is that the docked request processing queue may consume a lot of memory , even to the extent that OOM

        2.newCachedThreadPool and newScheduledThreadPool： The main problem is that the maximum number of threads is Integer.MAX_VALUE, A very large number of threads may be created , Set up OOM  

3、 ... and 、Executor Interface

        Only one in the interface execute Method , This interface is the ancestor of all thread pools