java线程池有几种?java四种线程池详解

TheDisguiser 2020-07-31 16:54:31 java常见问答 4105

java里常见线程池一般有几种小伙伴们知道吗?这几种线程池囊括了大部分线程的管理,下面一起来了解一下它们吧。

常用线程池一般有如下几种:

1、CachedThreadPool

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**    官方释义:
 * Creates a thread pool that creates new threads as needed, but
 * will reuse previously constructed threads when they are
 * available.  These pools will typically improve the performance
 * of programs that execute many short-lived asynchronous tasks.
 * Calls to <tt>execute</tt> will reuse previously constructed
 * threads if available. If no existing thread is available, a new
 * thread will be created and added to the pool. Threads that have
 * not been used for sixty seconds are terminated and removed from
 * the cache. Thus, a pool that remains idle for long enough will
 * not consume any resources. Note that pools with similar
 * properties but different details (for example, timeout parameters)
 * may be created using {@link ThreadPoolExecutor} constructors.
 *
 * @return the newly created thread pool
 * 
 * 翻译(大致意思):创建一个应用程序需要多个线程的线程池,但是应用程序会重用之前构造的可用的
 * 空闲线程,它会显著的提升应用程序执行短耗时异步类型的任务。如果线程池中没有可用的线程,那
 * 么将会创建一个新线程并将其加入到线程池中。如果线程在60s内没有被使用,那么该线程将会被回收
 * 并且从缓存中移出,因此,该类型线程池会留存足够长的时间且不会消耗任何资源。
 * 
 * 
 */
public class CachedThreadPoolTest
{
    public static void main(String[] args) throws InterruptedException
    {
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++)
        {
            Thread.sleep(1000);
            executor.execute(new Runnable()
            {
                public void run()
                {
                    String name = Thread.currentThread()
                        .getName();
                    System.out.println("name" + name);
                }
            });
        }
        executor.shutdown();
    }
}

2、FixedThreadPool

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 官方释义:
 * Creates a thread pool that reuses a fixed number of threads
 * operating off a shared unbounded queue.  At any point, at most
 * <tt>nThreads</tt> threads will be active processing tasks.
 * If additional tasks are submitted when all threads are active,
 * they will wait in the queue until a thread is available.
 * If any thread terminates due to a failure during execution
 * prior to shutdown, a new one will take its place if needed to
 * execute subsequent tasks.  The threads in the pool will exist
 * until it is explicitly {@link ExecutorService#shutdown shutdown}.
 *
 * @param nThreads the number of threads in the pool
 * @return the newly created thread pool
 * @throws IllegalArgumentException if {@code nThreads <= 0}
 * 
 * 创建一个固定数量的线程池,操作一个共享无边界的队列。任何时刻,最多只有
 * 指定数量的线程处理任务,如果当有额外的任务被提交到线程池但没有空闲线程可供使用时,则该
 * 任务会被放到队列中直到出现空闲线程,一旦有任一线程在执行完成前因失败而被终止,那么一个
 * 新的任务将会取代它进而执行后续的任务。
 * 
 */
public class FixedThreadPoolTest
{
    private static int nThreads = 5;
    public static void main(String[] args)
    {
        ExecutorService executor = Executors.newFixedThreadPool(nThreads);
        for (int i = 1; i <= 10; i++)
        {
            executor.submit(new Runnable()
            {
                @Override
                public void run()
                {
                    // TODO Auto-generated method stub
                    System.out.println("当前线程:" + Thread.currentThread()
                        .getName());
                    try
                    {
                        Thread.sleep(5000);
                    }
                    catch (InterruptedException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        }
        executor.shutdown();
    }
}

3、ScheduledThreadPool

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * 
 * 周期性或定时执行任务
 *
 */
public class ScheduledThreadPoolTest
{
    public static void main(String[] args)
    {
        //5表示线程池中保持5个线程,即使是空闲的。
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
        ses.scheduleWithFixedDelay(new Runnable()
        {
            @Override
            public void run()
            {
                // TODO Auto-generated method stub
                System.out.println("hello world!!!");
            }
        }, 2, 3, TimeUnit.SECONDS); //2秒后执行,每隔3秒执行一次
        //ses.scheduleAtFixedRate(command, initialDelay, period, unit)
        //ses.schedule(callable, delay, unit)
        //ses.shutdown();
    }
}

4、SingleThreadExecutorPool

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * Creates an Executor that uses a single worker thread operating
 * off an unbounded queue. (Note however that if this single
 * thread terminates due to a failure during execution prior to
 * shutdown, a new one will take its place if needed to execute
 * subsequent tasks.)  Tasks are guaranteed to execute
 * sequentially, and no more than one task will be active at any
 * given time. Unlike the otherwise equivalent
 * <tt>newFixedThreadPool(1)</tt> the returned executor is
 * guaranteed not to be reconfigurable to use additional threads.
 *
 * @return the newly created single-threaded Executor
 * 
 * 创建一个单线程池操作共享队列,保证各个线程的执行顺序,和newFixedThreadPool(1)不同的
 * 是SingleThreadExecutorPool不会开启额外的线程。即线程的执行是有序的,
 */
public class SingleThreadExecutorPoolTest
{
    public static void main(String[] args)
    {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++)
        {
            final int n = i;
            executor.submit(new Runnable()
            {
                @Override
                public void run()
                {
                    // TODO Auto-generated method stub
                    System.out.println("n====:" + n + ",threadname:" + Thread.currentThread()
                        .getName());
                }
            });
        }
        executor.shutdown();
    }
}

以上就是今天文章的全部内容了,有关java常见问题及解决方法小伙伴们还有哪些不理解的吗?有的话可以来我们网站了解详情及答案噢。

推荐阅读:

java线程池拒绝策略有哪些?

java线程池参数设置原则,如何设置线程池参数比较合理?

java线程池的作用是什么?线程池介绍