Java线程池的使用

最新推荐文章于 2025-02-18 21:10:37 发布

Swuagg

最新推荐文章于 2025-02-18 21:10:37 发布

阅读量466

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： Executors 线程池 Thread

本文链接：https://blog.youkuaiyun.com/Agg_bin/article/details/93889210

Java 专栏收录该内容

6 篇文章

订阅专栏

线程池的产生

（1）线程池的产生来源于new Thread的弊端

在程序中创建一个线程，通常如下形式：

new Thread(new Runnable() {
    @Override
    public void run() {}
}).start();

但这种方式的弊端很明显：

每次都new Thread新建对象，性能差。
线程缺乏统一管理，可能无限制新建线程，相互之间竞争，占用过多系统资源，最终导致ANR或OOM。
缺乏更多功能，如定时执行、定期执行、线程中断等。

（2）使用线程池的好处

减少了创建和销毁线程的次数，重用存在的线程，在执行大量异步任务时增强了程序性能。
可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
提供定时执行、定期执行和线程控制等功能。

（3）线程池的作用

线程池作用就是限制系统中执行线程的数量。
要配置一个线程池是比较复杂的，而且很有可能配置的线程池不是较优的，于是Executors类里面提供了一些静态工厂，生成一些常用的线程池。

（4）线程池的类图

（5）线程池的工作原理

Java中线程池共由四个部分组成（和Android中的Handler机制有相似之处）：线程池管理器（ThreadPool）、工作线程（PoolWorker）、任务接口（Task）、任务队列（taskQueue）。本文不对此做详细探讨。

Executors提供四种线程池

Java通过Executors提供四种线程池，分别为：newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool、newSingleThreadExecutor。

（1）newCachedThreadPool

创建一个可缓存且无限大的线程池。
调用 execute 将重用以前构造的线程（如果线程可用），如果现有线程没有可用的，则创建一个新线程并添加到池中。
终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。

源码：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
            60L, TimeUnit.SECONDS,
            new SynchronousQueue<Runnable>());
}

例子：

private void myThreadPoolExecutor() {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 20; i++) {
        int finalI = i;
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000 + 100 * finalI);
                    Log.i(TAG, Thread.currentThread().getName() + "_run: " + finalI);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

Log：

pool-2-thread-1_run: 0
pool-2-thread-2_run: 1
pool-2-thread-3_run: 2
pool-2-thread-4_run: 3
pool-2-thread-1_run: 4
pool-2-thread-5_run: 5
pool-2-thread-6_run: 6
pool-2-thread-7_run: 7
pool-2-thread-8_run: 8
pool-2-thread-9_run: 9
pool-2-thread-10_run: 10
pool-2-thread-11_run: 11
pool-2-thread-12_run: 12
pool-2-thread-13_run: 13
pool-2-thread-14_run: 14
pool-2-thread-15_run: 15
pool-2-thread-16_run: 16
pool-2-thread-17_run: 17
pool-2-thread-18_run: 18
pool-2-thread-19_run: 19

（2）newFixedThreadPool

创建固定大小的线程池。
可控制线程最大并发数，超出的线程会在队列中等待。
在某个线程被显式地关闭之前，池中的线程将一直存在。如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

源码：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>());
}

（3）newScheduledThreadPool

创建一个线程池，支持定时和周期性地执行任务。

源码：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
            DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
            new DelayedWorkQueue());
}

方法：

schedule()：创建并执行在给定延迟后的操作。
scheduleAtFixedRate()：创建并执行一个在给定初始延迟后，首次启用的定期操作，后续操作具有给定的周期。
scheduleWithFixedDelay()：创建并执行一个在给定初始延迟后，首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

scheduleAtFixedRate与scheduleWithFixedDelay的区别：

scheduleAtFixedRate不管任务是否完成，只要间隔的时间到了，就会执行下一次，它不受计划执行时间的影响。另外，如果程序的执行时间大于间隔时间的话就会按照程序的执行时间当作间隔，如果程序的执行时间小于间隔时间的话就会按照间隔时间来执行。
scheduleWithFixedDelay要等到任务执行完成之后才会执行间隔，它受计划执行时间的影响。

例子：

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
Log.i(TAG, "myThreadPoolExecutor: ");
scheduledExecutorService.schedule(new Runnable() {
    @Override
    public void run() {
        Log.i(TAG, "run: ");
    }
},2, TimeUnit.SECONDS); // 延迟两秒执行

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
Log.i(TAG, "myThreadPoolExecutor: ");
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        Log.i(TAG, "run: ");
    }
},2,1,TimeUnit.SECONDS); // 延迟两秒执行，以后每隔1秒执行一次。

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
Log.i(TAG, "myThreadPoolExecutor: ");
scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
    @Override
    public void run() {
        Log.i(TAG, "run: ");
    }
},2,1, TimeUnit.SECONDS); // 延迟两秒执行，以后在任务执行完成之后，每隔1秒执行一次。

（4）newSingleThreadExecutor

创建一个单线程的线程池，永远会维护存在一条线程。
它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行，相当于单线程串行执行所有任务。
如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。
和newFixedThreadPool一样，在线程池中没有任务执行时，也不会释放系统资源的，所以需要shudown()方法。

源码：

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>()));
}

例子：

ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 20; i++) {
    int finalI = i;
    executorService.execute(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                Log.i(TAG, Thread.currentThread().getName() + "_run: " + finalI);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
} // 结果依次输出，相当于顺序执行各个任务。

5）核心和最大池大小

ThreadPoolExecutor将根据corePoolSize和maximumPoolSize设置的边界自动调整池大小。
当新任务在方法execute(java.lang.Runnable)中提交时，如果运行的线程少于corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的。如果运行的线程多于corePoolSize而少于maximumPoolSize，则仅当队列满时才创建新线程。e.g. newScheduledThreadPool
如果设置的corePoolSize和maximumPoolSize相同，则创建了固定大小的线程池。e.g. newFixedThreadPool
如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务。e.g. newCachedThreadPool
在大多数情况下，核心和最大池大小仅基于构造来设置，不过也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 进行动态更改。

（6）合理使用线程池

一般推荐使用newCachedThreadPool，对于执行很多短期异步任务的程序而言，可提高程序性能，而且会终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
当需要固定线程数时可使用newFixedThreadPool。
newScheduledThreadPool支持定时和周期性地执行任务。
Android的UI线程就是一种单线程。

一道面试题

现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？

（1）可以通过join方法来确保t1、t2、t3的执行顺序。

private void myJoin() {
    Log.i(TAG, Thread.currentThread().getName() + "正在执行");
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            Log.i(TAG, Thread.currentThread().getName() + "执行完成");
        }
    };
    Thread thread1 = new Thread(runnable, "thread1");
    Thread thread2 = new Thread(runnable, "thread2");
    Thread thread3 = new Thread(runnable, "thread3");
    try {
        thread1.start();
        thread1.join(); // thread1线程插入正在执行的main线程，直到thread1线程执行完毕后，继续执行main线程。
        thread2.start();
        thread2.join();
        thread3.start();
        thread3.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Log.i(TAG, Thread.currentThread().getName() + "正在执行");
}

（2）Log：

main正在执行
thread1执行完成
thread2执行完成
thread3执行完成
main正在执行

（3）Thread中的join方法：共重载了三个

主要作用：就是同步，它可以使得线程之间的并行执行变为串行执行。
join(long millis)：等待该线程终止的时间最长为 millis 毫秒。millis为 0 意味着要一直等下去，直到该线程运行结束。
join(long millis, int nanos)：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
join()：等待该线程运行结束。内部调用join(0);
join方法必须在线程start方法调用之后调用才有意义。如果一个线程都没有start，那么线程都还没创建，那它也就无法同步了。