Java 线程池

2025 年 3 月 28 日 | 阅读 8 分钟

Java 线程池代表了一组等待任务并可重复使用的工作线程。

在线程池的情况下，会创建一个固定大小的线程组。服务提供商会从线程池中拉出一个线程并为其分配任务。任务完成后，线程会再次放入线程池中。

Executer 线程池方法

newFixedThreadPool(int s)： 此方法创建一个固定大小为 s 的线程池。

newCachedThreadPool()： 此方法创建一个新的线程池，该线程池在需要时创建新线程，但仍会尽可能使用先前创建的可用线程。

newSingleThreadExecutor()： 此方法创建一个新线程。

Java 线程池的优点

更好的性能 它节省了时间，因为无需创建新线程。

实际应用

它用于 Servlet 和 JSP，其中容器创建线程池来处理请求。

Java 线程池示例

让我们通过 ExecutorService 和 Executors 看一个简单的 Java 线程池示例。

文件：WorkerThread.java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class WorkerThread implements Runnable {
    private String message;
    public WorkerThread(String s){
        this.message=s;
    }
     public void run() {
        System.out.println(Thread.currentThread().getName()+" (Start) message = "+message);
        processmessage();//call processmessage method that sleeps the thread for 2 seconds
        System.out.println(Thread.currentThread().getName()+" (End)");//prints thread name
    }
    private void processmessage() {
        try {  Thread.sleep(2000);  } catch (InterruptedException e) { e.printStackTrace(); }
    }
}

文件：TestThreadPool.java

public class TestThreadPool {
     public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);//creating a pool of 5 threads
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);//calling execute method of ExecutorService
          }
        executor.shutdown();
        while (!executor.isTerminated()) {   }

        System.out.println("Finished all threads");
    }
 }

输出

pool-1-thread-1 (Start) message = 0
pool-1-thread-2 (Start) message = 1
pool-1-thread-3 (Start) message = 2
pool-1-thread-5 (Start) message = 4
pool-1-thread-4 (Start) message = 3
pool-1-thread-2 (End)
pool-1-thread-2 (Start) message = 5
pool-1-thread-1 (End)
pool-1-thread-1 (Start) message = 6
pool-1-thread-3 (End)
pool-1-thread-3 (Start) message = 7
pool-1-thread-4 (End)
pool-1-thread-4 (Start) message = 8
pool-1-thread-5 (End)
pool-1-thread-5 (Start) message = 9
pool-1-thread-2 (End)
pool-1-thread-1 (End)
pool-1-thread-4 (End)
pool-1-thread-3 (End)
pool-1-thread-5 (End)
Finished all threads

下载此示例

线程池示例：2

让我们看另一个线程池的例子。

文件名： ThreadPoolExample.java

// important import statements
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.text.SimpleDateFormat;


class Tasks implements Runnable
{
private String taskName;

// constructor of the class Tasks
public Tasks(String str)
{
// initializing the field taskName 
taskName = str;
}

// Printing the task name and then sleeps for 1 sec
// The complete process is getting repeated five times
public void run()
{
try
{
for (int j = 0; j <= 5; j++)
{
if (j == 0)
{
Date dt = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("hh : mm : ss");

//prints the initialization time for every task
System.out.println("Initialization time for the task name: "+ taskName + " = " + sdf.format(dt));

}
else
{
Date dt = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("hh : mm : ss");

// prints the execution time for every task
System.out.println("Time of execution for the task name: " + taskName + " = " +sdf.format(dt));

}

// 1000ms = 1 sec
Thread.sleep(1000);
}

System.out.println(taskName + " is complete.");
}

catch(InterruptedException ie)
{
ie.printStackTrace();
}
}
}

public class ThreadPoolExample
{
// Maximum number of threads in the thread pool
static final int MAX_TH = 3;			

// main method
public static void main(String argvs[])
{
// Creating five new tasks
Runnable rb1 = new Tasks("task 1");
Runnable rb2 = new Tasks("task 2");
Runnable rb3 = new Tasks("task 3");
Runnable rb4 = new Tasks("task 4");
Runnable rb5 = new Tasks("task 5");	

// creating a thread pool with MAX_TH number of
// threads size the pool size is fixed
ExecutorService pl = Executors.newFixedThreadPool(MAX_TH);

// passes the Task objects to the pool to execute (Step 3)
pl.execute(rb1);
pl.execute(rb2);
pl.execute(rb3);
pl.execute(rb4);
pl.execute(rb5);

// pool is shutdown
pl.shutdown();	
}
}

输出

Initialization time for the task name: task 1 = 06 : 13 : 02
Initialization time for the task name: task 2 = 06 : 13 : 02
Initialization time for the task name: task 3 = 06 : 13 : 02
Time of execution for the task name: task 1 = 06 : 13 : 04
Time of execution for the task name: task 2 = 06 : 13 : 04
Time of execution for the task name: task 3 = 06 : 13 : 04
Time of execution for the task name: task 1 = 06 : 13 : 05
Time of execution for the task name: task 2 = 06 : 13 : 05
Time of execution for the task name: task 3 = 06 : 13 : 05
Time of execution for the task name: task 1 = 06 : 13 : 06
Time of execution for the task name: task 2 = 06 : 13 : 06
Time of execution for the task name: task 3 = 06 : 13 : 06
Time of execution for the task name: task 1 = 06 : 13 : 07
Time of execution for the task name: task 2 = 06 : 13 : 07
Time of execution for the task name: task 3 = 06 : 13 : 07
Time of execution for the task name: task 1 = 06 : 13 : 08
Time of execution for the task name: task 2 = 06 : 13 : 08
Time of execution for the task name: task 3 = 06 : 13 : 08
task 2 is complete.
Initialization time for the task name: task 4 = 06 : 13 : 09
task 1 is complete.
Initialization time for the task name: task 5 = 06 : 13 : 09
task 3 is complete.
Time of execution for the task name: task 4 = 06 : 13 : 10
Time of execution for the task name: task 5 = 06 : 13 : 10
Time of execution for the task name: task 4 = 06 : 13 : 11
Time of execution for the task name: task 5 = 06 : 13 : 11
Time of execution for the task name: task 4 = 06 : 13 : 12
Time of execution for the task name: task 5 = 06 : 13 : 12
Time of execution for the task name: task 4 = 06 : 13 : 13
Time of execution for the task name: task 5 = 06 : 13 : 13
Time of execution for the task name: task 4 = 06 : 13 : 14
Time of execution for the task name: task 5 = 06 : 13 : 14
task 4 is complete.
task 5 is complete.

解释： 从程序的输出可以看出，任务 4 和 5 仅在线程空闲时执行。在那之前，额外的任务会被放入队列。

以上示例的启示是，当一个人想执行 50 个任务但不愿创建 50 个线程时。在这种情况下，可以创建一个包含 10 个线程的池。因此，分配了 10 个任务中的 10 个，其余的放入队列。每当 10 个线程中的任何一个空闲时，它就会拾取第 11 个任务。其他待处理任务的处理方式相同。

线程池中涉及的风险

线程池中涉及的风险如下：

死锁： 众所周知，死锁会出现在任何涉及多线程的程序中，而线程池会引入另一种死锁场景。考虑一种情况，所有正在执行的线程都在等待被阻塞并因线程不可用而等待在队列中的线程的结果。执行。

线程泄漏： 当一个线程被从池中移除以执行任务，但在任务完成后没有返回到池中时，就会发生线程泄漏。例如，当线程抛出异常并且池类无法捕获此异常时，线程将退出，并且线程池的大小将减少 1。如果相同的情况重复多次，那么池很可能会变空，因此，池中没有线程可用于执行其他请求。

资源颠簸： 当线程池的大小非常大时，在线程之间进行上下文切换会浪费大量时间。当线程数超过最佳数量时，可能会导致饿死问题，并导致资源颠簸。

注意事项

不要将正在并发等待其他任务结果的任务排队。这可能导致死锁情况，如上所述。

使用长时间运行的操作的线程时必须小心。这可能导致线程永远等待，最终导致资源泄漏。

最后，必须显式终止线程池。如果这样做，程序将继续执行，永远不会结束。调用执行器上的 shutdown() 方法来终止执行器。请注意，如果有人在 shutdown 后尝试向执行器发送另一个任务，它将抛出 RejectedExecutionException。

为了有效地调整线程池，需要了解任务。如果给定的任务是对比的，那么应该寻找执行不同类型任务的池，以便可以适当地调整它们。

为了减少 JVM 内存不足的可能性，可以控制 JVM 中可以运行的最大线程数。线程池达到最大限制后将无法创建新线程。

如果线程已完成执行，线程池可以使用同一个已使用的线程。因此，节省了创建新线程的时间和资源。

调整线程池

线程池的准确大小由可用处理器数量和线程需要执行的任务类型决定。如果一个系统有 P 个处理器，并且只有计算类型的进程，那么 P 或 P + 1 的线程池的最大大小可以达到最大效率。但是，任务可能需要等待 I/O，在这种情况下，需要考虑请求的等待时间 (W) 和服务时间 (S) 的比率；因此，最大池大小为 P * (1 + W / S) 可实现最大效率。

结论

线程池是组织应用程序（尤其是在服务器端）的一个非常方便的工具。从概念上讲，线程池很容易理解。但是，在处理线程池时，可能需要考虑很多问题。这是因为线程池本身存在一些风险（风险如上所述）。

下一主题Java 线程组

Java 线程池

Executer 线程池方法

Java 线程池的优点

实际应用

Java 线程池示例

线程池示例：2

线程池中涉及的风险

注意事项

调整线程池

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java 教程

控制语句

Java Object 类

Java 继承

Java 多态

Java 抽象

Java 封装

Java 数组

Java OOPs 杂项

Java 字符串

Java 正则表达式

异常处理

Java 内部类

Java 多线程

Java 同步

Java I/O

Java 文件处理

Java 序列化

Java 网络

Java 反射

Java 集合

Java 5 特性

Java 8 特性

Java JDBC

RMI

国际化

Java 项目

Java 线程池

Executer 线程池方法

Java 线程池的优点

实际应用

Java 线程池示例

线程池示例：2

线程池中涉及的风险

注意事项

调整线程池

结论

相关帖子

ShutdownHook

Java 中的多线程

执行多个任务

Java 线程生命周期

Runtime 类

Java 线程调度器

Java ThreadGroup

Java 命名线程和当前线程

Java 中线程的 join

Java 中的守护线程

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器