Java中线程池创建与使用

线程池是Java5以后添加的内容，使用Executors工具类可以创建4种线程池

一、线程数量固定的线程池

public class ThreadPoolTest
{
    public static void main(String[] args)
    {
        /*
         * 创建固定的线程池
         * 1、线程池中始终存在3条线程
         */
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        //共有10个任务需要执行
        for(int i = 0; i < 10; i++)
        {
            final int task = i;
            threadPool.execute(new Runnable()
            {
                @Override
                public void run()
                {
                    for(int i = 0; i < 10; i++)
                    {
                        try
                        {
                            Thread.sleep(30);
                        }
                        catch (Exception e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        /*
                         * 根据控制台的输出结果可以知道，不管有多少任务需要执行，
                         * 线程池都是使用已经存在的3条线程，完成当前的任务后，再去执行在线程池中等待的其他任务
                         */
                        System.out.println(Thread.currentThread().getName() 
                                + "-time:" + i + "#task:" + task);
                    }
                }
            });
        }
        
        /*
         * 任务完成后 别忘了关闭线程池。。。
         * 等待提交的任务完成后，关闭线程池
         */
        threadPool.shutdown();
        
        /*
         * 根据JDK文档描述，线程池会调用Thread.interrupt()来实现中断线程，
         * 但是interrupt()作用有限，如果线程没有处于sleep 、wait等状态的，
         * 则无法终止当前线程。
         * 所以shutdownNow()不代表线程池立即能关闭
         * 
         */
        //threadPool.shutdownNow();
    }
}

二、线程数量不定的缓存线程池

public class ThreadPoolTest
{
    public static void main(String[] args)
    {
        /*
         * 创建缓存线程池
         * 1、线程池中的线程数不一定
         * 根据JDK文档的描述  线程池会根据需要创建新的线程，
         * 但是也会重用以前创建的处于空闲状态的线程，如果一个
         * 线程60秒没有被使用，将会被终止 并被从缓存区移除
         */
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //共有10个任务需要执行
        for(int i = 0; i < 10; i++)
        {
            final int task = i;
            threadPool.execute(new Runnable()
            {
                @Override
                public void run()
                {
                    for(int i = 0; i < 10; i++)
                    {
                        try
                        {
                            Thread.sleep(30);
                        }
                        catch (Exception e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        
                        /*
                         * 根据控制台的输出结果可以知道，确实是根据需要创建了10条线程
                         */
                        System.out.println(Thread.currentThread().getName() 
                                + "-time:" + i + "#task:" + task);
                    }
                }
            });
        }
        
        /*
         * 任务完成后 别忘了关闭线程池。。。
         * 等待提交的任务完成后，关闭线程池
         */
        threadPool.shutdown();
        
        /*
         * 根据JDK文档描述，线程池会调用Thread.interrupt()来实现中断线程，
         * 但是interrupt()作用有限，如果线程没有处于sleep 、wait等状态的，
         * 则无法终止当前线程。
         * 所以shutdownNow()不代表线程池立即能关闭
         * 
         */
        //threadPool.shutdownNow();
    }
}

三、创建只有一条线程的单一线程池

public class ThreadPoolTest
{
    public static void main(String[] args)
    {
        /*
         * 创建单一线程的线程池
         * 1、线程池中的线程数只有一条
         * 根据JDK文档的描述  线程池一直存在一条单一的
         * 线程用来执行任务，如果这条线程结束后，
         * 会根据需要重新创建一条新的线程来执行任务
         */
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        //共有10个任务需要执行
        for(int i = 0; i < 10; i++)
        {
            final int task = i;
            threadPool.execute(new Runnable()
            {
                @Override
                public void run()
                {
                    for(int i = 0; i < 10; i++)
                    {
                        try
                        {
                            Thread.sleep(30);
                        }
                        catch (Exception e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        
                        /*
                         * 根据控制台的输出结果可以知道，线程池中始终只有一条线程
                         */
                        System.out.println(Thread.currentThread().getName() 
                                + "-time:" + i + "#task:" + task);
                    }
                }
            });
        }
        
        /*
         * 任务完成后 别忘了关闭线程池。。。
         * 等待提交的任务完成后，关闭线程池
         */
        threadPool.shutdown();
        
        /*
         * 根据JDK文档描述，线程池会调用Thread.interrupt()来实现中断线程，
         * 但是interrupt()作用有限，如果线程没有处于sleep 、wait等状态的，
         * 则无法终止当前线程。
         * 所以shutdownNow()不代表线程池立即能关闭
         * 
         */
        //threadPool.shutdownNow();
    }
}

四、创建调度任务的线程池

public class ThreadPoolTest
{
    public static void main(String[] args)
    {
        /*
         * 创建调度任务的线程池  确定了延迟时间后执行
         */
        Executors.newScheduledThreadPool(1).schedule(new Runnable()
        {
            
            @Override
            public void run()
            {
                System.out.println("boom!");
                
            }
        }, 2, TimeUnit.SECONDS);
        
        
        /*
         * 创建调度任务的线程池  含固定频率
         */
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable()
        {
            
            @Override
            public void run()
            {
                System.out.println("boom-2!");
                
            }
        }, 2, 1, TimeUnit.SECONDS);

    }
}