java线程池

最新推荐文章于 2025-08-13 18:07:46 发布

zhhpjl

最新推荐文章于 2025-08-13 18:07:46 发布

阅读量457

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/zhhpjl/article/details/42494621

java 专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了Java中线程池的多种类型及其使用方法，包括固定大小、单任务、可变大小、延迟和周期线程池等，并提供了自定义线程池的示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法。

一、实现Runnable接口的类

package threadpool;

import java.util.Date;

public class WorkThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" Start Time = "+new Date());  
        doProcess();  
        System.out.println(Thread.currentThread().getName()+" End Time = "+new Date());  
    }
    
    private void doProcess(){
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二、固定大小的线程池

public class FixedThreadPool {
        public void doTest() {
            // 创建一个可重用固定线程数的线程池
            ExecutorService pool = Executors.newFixedThreadPool(2);
            // 创建实现了Runnable接口对象
            WorkThread t1 = new WorkThread();
            WorkThread t2 = new WorkThread();
            WorkThread t3 = new WorkThread();
            WorkThread t4 = new WorkThread();
            WorkThread t5 = new WorkThread();
            // 将线程放入池中进行执行,submit同样可执行相同的操作，它返回ScheduledFuture<V>对象，可获得线程运行的相应信息
            pool.execute(t1);
            pool.execute(t2);
            pool.execute(t3);
            pool.execute(t4);
            pool.execute(t5);
            // 关闭线程池
            pool.shutdown();
        }
    }

三、单任务线程池

public class SingleThreadPool {
        public void doTest() {
            // 创建一个可重用固定线程数的线程池
            ExecutorService pool = Executors.newSingleThreadExecutor(); 这里是与固定大小线程池的区别
            // 创建实现了Runnable接口对象
            WorkThread t1 = new WorkThread();
            WorkThread t2 = new WorkThread();
            WorkThread t3 = new WorkThread();
            WorkThread t4 = new WorkThread();
            WorkThread t5 = new WorkThread();
            // 将线程放入池中进行执行
            pool.execute(t1);
            pool.execute(t2);
            pool.execute(t3);
            pool.execute(t4);
            pool.execute(t5);
            // 关闭线程池
            pool.shutdown();
        }
    }

四、可变大小线程池


<pre name="code" class="java">public class SingleThreadPool {
        public void doTest() {
            // 创建一个可重用固定线程数的线程池
           ExecutorService pool = Executors.newCachedThreadPool(); 这里是与固定大小线程池的区别
            // 创建实现了Runnable接口对象
            ....
            // 将线程放入池中进行执行
<pre name="code" class="java"><pre name="code" class="java">            ....
            // 关闭线程池      <pre name="code" class="java"><pre name="code" class="java">            ....
        }
    }

五、延迟线程池

public class ScheduledThreadPool {
        public void doTest() {
            // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
            ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
            // 创建实现了Runnable接口对象
            WorkThread t1 = new WorkThread();
            WorkThread t2 = new WorkThread();
            WorkThread t3 = new WorkThread();
            WorkThread t4 = new WorkThread();
            WorkThread t5 = new WorkThread();
            // 将线程放入池中进行执行
            pool.execute(t1);
            pool.execute(t2);
            pool.execute(t3);
            // 使用延迟执行风格的方法
            pool.schedule(t4, 10, TimeUnit.SECONDS);
            pool.schedule(t5, 10, TimeUnit.SECONDS);
            // 关闭线程池
            pool.shutdown();
        }
    }

六、单任务延迟线程池

public class SingleScheduledThreadPool {
        public void doTest() {
            // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
            ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
            // 创建实现了Runnable接口对象
            ....
            // 将线程放入池中进行执行
            ....
            // 使用延迟执行风格的方法
            ....
            // 关闭线程池
            ....
        }
    }

七、周期线程池

public class ScheduledThreadPool4FixedRate {
        public void doTest() {
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

            // 添加三个任务，周期执行
            System.out.println("Current Time = " + new Date());
            for (int i = 0; i < 3; i++) {
                WorkThread worker = new WorkThread();
                scheduledThreadPool.scheduleAtFixedRate(worker, 0, 10, TimeUnit.SECONDS);// 另外一个方法scheduleAtFixedRate
            }
            // 关闭线程池
            // scheduledThreadPool.shutdown();
            // while (!scheduledThreadPool.isTerminated()) {
            // // wait for all tasks to finish
            // }
            System.out.println("Finished all threads");
        }
    }

线程延迟0s执行，周期为10s。如何停止指定线程目前还在学习中。

八、自定义线程池

public class MyselfThreadPool {
        public void doTest() {
            // 创建等待队列
            BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
            // 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
            ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 2, TimeUnit.MILLISECONDS, bqueue);
            // 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
            WorkThread t1 = new WorkThread();
            WorkThread t2 = new WorkThread();
            WorkThread t3 = new WorkThread();
            WorkThread t4 = new WorkThread();
            WorkThread t5 = new WorkThread();
            WorkThread t6 = new WorkThread();
            WorkThread t7 = new WorkThread();
            // 将线程放入池中进行执行
            pool.execute(t1);
            pool.execute(t2);
            pool.execute(t3);
            pool.execute(t4);
            pool.execute(t5);
            pool.execute(t6);
            pool.execute(t7);
            // 关闭线程池
            pool.shutdown();
        }
    }

ThreadPoolExecutor
    public ThreadPoolExecutor(int corePoolSize,
                            int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)
   用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。使用 Executors 工厂方法之一比使用此通用构造方法方便得多。
参数：
   corePoolSize - 池中所保存的线程数，包括空闲线程。
   maximumPoolSize - 池中允许的最大线程数。
   keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
   unit - keepAliveTime 参数的时间单位。
   workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。
抛出：
   IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小于零，或者 maximumPoolSize 小于或等于零，或者 corePoolSize 大于 maximumPoolSize。
   NullPointerException - 如果 workQueue 为 null

测试

public static void main(String[] args) {
        // 测试固定线程池
         FixedThreadPool fixedThreadPool = new FixedThreadPool();
         fixedThreadPool.doTest();

        // 测试单线程池
         SingleThreadPool singleThreadPool = new SingleThreadPool();
         singleThreadPool.doTest();

        // 测试延迟线程池
         ScheduledThreadPool scheduledThreadPool = new ScheduledThreadPool();
         scheduledThreadPool.doTest();

        // 测试单延迟线程池
         SingleScheduledThreadPool singleScheduledThreadPool = new SingleScheduledThreadPool();
         singleScheduledThreadPool.doTest();

        // 测试周期线程池
        ScheduledThreadPool4FixedRate scheduledThreadPool4FixedRate = new ScheduledThreadPool4FixedRate();
        scheduledThreadPool4FixedRate.doTest();
        // 测试自定义线程池
        MyselfThreadPool myselfThreadPool = new MyselfThreadPool();
        myselfThreadPool.doTest();
    }