`

Java 线程池原理和队列详解

阅读更多

Java 线程池原理和队列详解

 
来源:
参考:

一、Executor任务提交接口与Executors工具类

Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。Executor框架是一个根据一组执行策略调用,调度,执行和控制的异步任务的框架。Executor存在的目的是提供一种将“任务提交”与”任务如何运行”分离开来的机制。定义如下:

public interface Executor {  
    void execute(Runnable command);  
} 

虽然只有一个方法,但是却为灵活且强大的异步任务执行框架提供了基础。它提供了一种标准的方法将任务的提交过程与执行过程解耦开来,并用Runnable来表示任务。

那么我们怎么得到Executor对象呢?这就是接下来要介绍的Exectors类了。 Executors为Executor,ExecutorService,ScheduledExecutorService,ThreadFactory和Callable类提供了一些工具方法,类似于集合中的Collections类的功能。Executors方便的创建线程池。

- 1、newCachedThreadPool

该线程池比较适合没有固定大小并且比较快速就能完成的小任务,它将为每个任务创建一个线程。那这样子它与直接创建线程对象(new Thread())有什么区别呢?看到它的第三个参数60L和第四个参数TimeUnit.SECONDS了吗?好处就在于60秒内能够重用已创建的线程。

下面是Executors中的newCachedThreadPool()的源代码:

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

- 2、 newFixedThreadPool

使用的Thread对象的数量是有限的,如果提交的任务数量大于限制的最大线程数,那么这些任务将排队,然后当有一个线程的任务结束之后,将会根据调度策略继续等待执行下一个任务。

下面是Executors中的newFixedThreadPool()的源代码: 

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

- 3、newSingleThreadExecutor

线程数量为1的FixedThreadPool,如果提交了多个任务,那么这些任务将会排队,每个任务都会在下一个任务开始之前运行结束,所有的任务将会使用相同的线程。下面是Executors中的newSingleThreadExecutor()的源代码:  

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

- 4、newScheduledThreadPool

创建一个固定长度的线程池,而且以延迟或定时的方式来执行任务。 通过如上配置的线程池的创建方法源代码,我们可以发现:   1> 除了CachedThreadPool使用的是直接提交策略的缓冲队列以外,其余两个用的采用的都是无界缓冲队列,也就说,FixedThreadPool和SingleThreadExecutor创建的线程数量就不会超过 corePoolSize。   2> 三个线程池采用的ThreadPoolExecutor构造方法都是同一个,使用的都是默认的ThreadFactory和handler:

private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();  
 
 public ThreadPoolExecutor(int corePoolSize,  
                     int maximumPoolSize,  
                     long keepAliveTime,  
                     TimeUnit unit,  
                     BlockingQueue<Runnable> workQueue) {  
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,  
        Executors.defaultThreadFactory(), defaultHandler);  
} 

也就说三个线程池创建的线程对象都是同组,优先权等级为正常的Thread.NORM_PRIORITY(5)的非守护线程,使用的被拒绝任务处理方式是直接抛出异常的AbortPolicy策略(前面有介绍)。

二、ExecutorService任务周期管理接口

Executor的实现通常都会创建线程来执行任务,但是使用异步方式来执行任务时,由于之前提交任务的状态不是立即可见的,所以如果要关闭应用程序时,就需要将受影响的任务状态反馈给应用程序。

为了解决执行服务的生命周期问题,Executor扩展了EecutorService接口,添加了一些用于生命周期管理的方法。如下:

public interface ExecutorService extends Executor {  
    void shutdown();  
    List<Runnable> shutdownNow();  
    boolean isShutdown();  
    boolean isTerminated();  
    boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;  
    // 省略部分方法  
}

三、ThreadPoolExecutor线程池实现类

先来看一下这个类中定义的重要变量,如下:

private final BlockingQueue<Runnable> workQueue;              // 阻塞队列  
private final ReentrantLock mainLock = new ReentrantLock();   // 互斥锁  
private final HashSet<Worker> workers = new HashSet<Worker>();// 线程集合.一个Worker对应一个线程  
private final Condition termination = mainLock.newCondition();// 终止条件  
private int largestPoolSize;           // 线程池中线程数量曾经达到过的最大值。  
private long completedTaskCount;       // 已完成任务数量  
private volatile ThreadFactory threadFactory;     // ThreadFactory对象,用于创建线程。  
private volatile RejectedExecutionHandler handler;// 拒绝策略的处理句柄  
private volatile long keepAliveTime;   // 线程池维护线程所允许的空闲时间  
private volatile boolean allowCoreThreadTimeOut;  
private volatile int corePoolSize;     // 线程池维护线程的最小数量,哪怕是空闲的  
private volatile int maximumPoolSize;  // 线程池维护的最大线程数量  

其中有几个重要的规则需要说明一下:

- 1、 corePoolSize与maximumPoolSize

由于ThreadPoolExecutor 将根据 corePoolSize和 maximumPoolSize设置的边界自动调整池大小,当新任务在方法 execute(java.lang.Runnable) 中提交时:

如果运行的线程少于 corePoolSize,则创建新线程来处理请求,即使其他辅助线程是空闲的;

如果运行的线程等于或多于 corePoolSize 而少于 maximumPoolSize,

队列已满:创建新的线程去处理请求 队列未满:将任务加入队列 如果运行的线程多于corePoolSize 并且等于maximumPoolSize,

队列已满:通过handler所指定的策略来处理新请求; 队列未满:将任务加入队列 如果将 maximumPoolSize 设置为基本的无界值(如 Integer.MAX_VALUE),则并发任务的数量没有限制。

处理任务的优先级为:

核心线程corePoolSize > 任务队列workQueue > 最大线程maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。 当池中的线程数大于corePoolSize的时候,多余的线程会等待keepAliveTime长的时间,如果无请求可处理就自行销毁。 - 2、workQueue 线程池所使用的缓冲队列

该缓冲队列的长度决定了能够缓冲的最大数量,缓冲队列有三种通用策略:

- 1、 直接提交。

     工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们。   在此,如果不存在可用于立即运行任务的线程,则试图把任务加入队列将失败,因此会构造一个新的线程。   此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性;   

- 2、 无界队列

  使用无界队列(例如,不具有预定义容量的 LinkedBlockingQueue)将导致在所有 corePoolSize 线程都忙时,新任务将在队列中等待。这样,创建的线程数量就不会超过 corePoolSize。(因此,maximumPoolSize 的值也就无效了。)

当每个任务完全独立于其他任务,即任务执行互不影响时,适合于使用无界队列;例如,在 Web 页服务器中。这种排队可用于处理瞬态突发请求,当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性;   

- 3、 有界队列

当使用有限的 maximumPoolSizes 时,有界队列(如 ArrayBlockingQueue)有助于防止资源耗尽,但是可能较难调整和控制。

队列大小和最大池大小可能需要相互折衷:使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销,但是可能导致人工降低吞吐量。如果任务频繁阻塞(例如,如果它们是 I/O 边界),则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小,CPU 使用率较高,但是可能遇到不可接受的调度开销,这样也会降低吞吐量.

举例:

例子一:使用直接提交策略,也即SynchronousQueue。

首先SynchronousQueue是无界的,也就是说他存储任务的能力是没有限制的,但是由于该Queue本身的特性,在某次添加元素后必须等待其他线程取走后才能继续添加。在这里不是核心线程便是新创建的线程,但是我们试想一样下,下面的场景。

我们使用一下参数构造ThreadPoolExecutor:

new ThreadPoolExecutor(   
                2, 3, 30, TimeUnit.SECONDS,    
                new  SynchronousQueue<Runnable>(),    
                new RecorderThreadFactory("CookieRecorderPool"),    
                new ThreadPoolExecutor.CallerRunsPolicy()); 

假设当前核心线程已经有2个正在运行.

此时来了一个任务(A),根据前面介绍的“如果运行的线程等于或多于 corePoolSize,则 Executor 始终首选将请求加入队列,而不添加新的线程。”,所以A被添加到queue中。

又来了一个任务(B),且核心2个线程还没有忙完。接下来首先尝试1中描述,但是由于使用的SynchronousQueue,所以一定无法加入进去。

此时便满足了上面提到的“如果无法将请求加入队列,则创建新的线程,除非创建此线程超出maximumPoolSize,在这种情况下,任务将被拒绝。”,所以必然会新建一个线程来运行这个任务。

但是如果这三个任务都还没完成,继续来了一个任务,queue中无法插入(任务A还在queue中),而线程数达到了maximumPoolSize,所以只好执行异常策略了。 为了避免这种情况:,所以在使用SynchronousQueue通常要求maximumPoolSize是无界的(如果希望限制就直接使用有界队列)。对于使用SynchronousQueue的作用jdk中写的很清楚:此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。

如果你的任务A1,A2有内部关联,A1需要先运行,那么先提交A1,再提交A2,当使用SynchronousQueue我们可以保证,A1必定先被执行,在A1么有被执行前,A2不可能添加入queue中

例子二:使用无界队列策略,即LinkedBlockingQueue

拿newFixedThreadPool来说,根据前文提到的规则:

如果运行的线程少于 corePoolSize,则 Executor 始终首选添加新的线程,而不进行排队。 那么当任务继续增加,会发生什么呢?

如果运行的线程等于或多于 corePoolSize,则 Executor 始终首选将请求加入队列,而不添加新的线程。 OK,此时任务变加入队列之中了,那什么时候才会添加新线程呢?

如果无法将请求加入队列,则创建新的线程,除非创建此线程超出 maximumPoolSize,在这种情况下,任务将被拒绝。 无界队列不会出现无法加入队列的情况。不像SynchronousQueue那样有其自身的特点,对于无界队列来说,总是可以加入的(资源耗尽,当然另当别论)。

换句说,永远也不会触发产生新的线程!线程数一直都是corePoolSize大小。忙完当前的线程,就从队列中拿任务开始运行。如果任务运行的时长比较长,而添加任务的速度远远超过处理任务的速度,任务队列就会疯长,任务内存很快就会爆掉

例子三:有界队列,使用ArrayBlockingQueue。

这个是最为复杂的使用,所以JDK不推荐使用也有些道理。与上面的相比,最大的特点便是可以防止资源耗尽的情况发生。

举例来说,请看如下构造方法:

new ThreadPoolExecutor(  
            2, 4, 30, TimeUnit.SECONDS,   
            new ArrayBlockingQueue<Runnable>(2),   
            new RecorderThreadFactory("CookieRecorderPool"),   
            new ThreadPoolExecutor.CallerRunsPolicy());  

假设,所有的任务都永远无法执行完。

对于首先来的A,B来说直接运行 如果来了C,D,他们会被放到queu中 如果接下来再来E,F,则增加线程运行E,F。 但是如果再来任务,队列无法再接受了,线程数也到达最大的限制了,所以就会使用拒绝策略来处理。 - 3、ThreadFactory

使用 ThreadFactory 创建新线程。如果没有另外说明,则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程,并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。

通过提供不同的 ThreadFactory,可以改变线程的名称、线程组、优先级、守护进程状态等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程,则执行程序将继续运行,但不能执行任何任务。

public interface ThreadFactory {  
    Thread newThread(Runnable r);  
}

而构造方法中的threadFactory对象,是通过 Executors.defaultThreadFactory()返回的。Executors.java中的defaultThreadFactory()源码如下:

public static ThreadFactory defaultThreadFactory() {  
     return new DefaultThreadFactory();  
 } 

在DefaultThreadFactory类中实现了ThreadFactory接口并对其中定义的方法进行了实现,如下:

static class DefaultThreadFactory implements ThreadFactory {  
    private static final AtomicInteger poolNumber = new AtomicInteger(1);  
    private final ThreadGroup group;  
    private final AtomicInteger threadNumber = new AtomicInteger(1);  
    private final String namePrefix;  
 
    DefaultThreadFactory() {  
        SecurityManager s = System.getSecurityManager();  
        group = (s != null) ? s.getThreadGroup() :  Thread.currentThread().getThreadGroup();  
        namePrefix = "pool-" +  poolNumber.getAndIncrement() +  "-thread-";  
    }  
    // 为线程池创建新的任务执行线程  
    public Thread newThread(Runnable r) {  
        // 线程对应的任务是Runnable对象r  
        Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);  
        // 设为非守护线程  
        if (t.isDaemon())  
            t.setDaemon(false);  
        // 将优先级设为Thread.NORM_PRIORITY  
        if (t.getPriority() != Thread.NORM_PRIORITY)  
            t.setPriority(Thread.NORM_PRIORITY);  
        return t;  
    }  
}  

- 4、RejectedExecutionHandler

当Executor已经关闭(即执行了executorService.shutdown()方法后),并且Executor将有限边界用于最大线程和工作队列容量,且已经饱和时,在方法execute()中提交的新任务将被拒绝.   在以上述情况下,execute 方法将调用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略:

在默认的 ThreadPoolExecutor.AbortPolicy 处理程序遭到拒绝将抛出运行时 RejectedExecutionException;

在 ThreadPoolExecutor.CallerRunsPolicy线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制,能够减缓新任务的提交速度

在 ThreadPoolExecutor.DiscardPolicy 不能执行的任务将被删除;

在 ThreadPoolExecutor.DiscardOldestPolicy 如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,然后重试执行程序(如果再次失败,则重复此过程)。 线程池默认会采用的是defaultHandler策略。首先看defaultHandler的定义:

private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); // 使用默认的拒绝策略  
 
public static class AbortPolicy implements RejectedExecutionHandler {  
    public AbortPolicy() { }  
    // 抛出异常  
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
        throw new RejectedExecutionException("Task " + r.toString() +  " rejected from " +  e.toString());  
    }  
} 

看一下其他拒绝策略的具体实现。

class MyRunnable implements Runnable {  
    private String name;  
    public MyRunnable(String name) {  
        this.name = name;  
    }  
    @Override  
    public void run() {  
        try {  
            System.out.println(this.name + " is running.");  
            Thread.sleep(100);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}

举例:

如上是一个测试任务的例子,下面编写4个测试用例来测试。

- 1. DiscardPolicy 示例

public class DiscardPolicyDemo {  
 
    private static final int THREADS_SIZE = 1;  
    private static final int CAPACITY = 1;  
 
    public static void main(String[] args) throws Exception {  
 
        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE),"线程池"的阻塞队列容量为1(CAPACITY)。  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY));  
        // 设置线程池的拒绝策略为"丢弃"  
        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());  
 
        // 新建10个任务,并将它们添加到线程池中。  
        for (int i = 0; i < 10; i++) {  
            Runnable myrun = new MyRunnable("task-"+i);  
            pool.execute(myrun);  
        }  
        // 关闭线程池  
        pool.shutdown();  
    }  
}  

线程池pool的”最大池大小”和”核心池大小”都为1(THREADS_SIZE),这意味着”线程池能同时运行的任务数量最大只能是1”。 线程池pool的阻塞队列是ArrayBlockingQueue,ArrayBlockingQueue是一个有界的阻塞队列,ArrayBlockingQueue的容量为1。这也意味着线程池的阻塞队列只能有一个线程池阻塞等待。 根据”“中分析的execute()代码可知:线程池中共运行了2个任务。第1个任务直接放到Worker中,通过线程去执行;第2个任务放到阻塞队列中等待。其他的任务都被丢弃了!

- 2. DiscardOldestPolicy 示例

public class DiscardOldestPolicyDemo {  
 
    private static final int THREADS_SIZE = 1;  
    private static final int CAPACITY = 1;  
 
    public static void main(String[] args) throws Exception {  
 
        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE),"线程池"的阻塞队列容量为1(CAPACITY)。  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  
                new ArrayBlockingQueue<Runnable>(CAPACITY));  
        // 设置线程池的拒绝策略为"DiscardOldestPolicy"  
        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());  
 
        // 新建10个任务,并将它们添加到线程池中。  
        for (int i = 0; i < 10; i++) {  
            Runnable myrun = new MyRunnable("task-"+i);  
            pool.execute(myrun);  
        }  
        // 关闭线程池  
        pool.shutdown();  
    }  
}  

运行结果:

task-0 is running.
task-9 is running.

将”线程池的拒绝策略”由DiscardPolicy修改为DiscardOldestPolicy之后,当有任务添加到线程池被拒绝时,线程池会丢弃阻塞队列中末尾的任务,然后将被拒绝的任务添加到末尾。

- 3. AbortPolicy 示例

public class AbortPolicyDemo {  
 
    private static final int THREADS_SIZE = 1;  
    private static final int CAPACITY = 1;  
 
    public static void main(String[] args) throws Exception {  
 
        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE),"线程池"的阻塞队列容量为1(CAPACITY)。  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  
                new ArrayBlockingQueue<Runnable>(CAPACITY));  
        // 设置线程池的拒绝策略为"抛出异常"  
        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());  
 
        try {  
 
            // 新建10个任务,并将它们添加到线程池中。  
            for (int i = 0; i < 10; i++) {  
                Runnable myrun = new MyRunnable("task-"+i);  
                pool.execute(myrun);  
            }  
        } catch (RejectedExecutionException e) {  
            e.printStackTrace();  
            // 关闭线程池  
            pool.shutdown();  
        }  
    }  
}  

(某一次)运行结果:

java.util.concurrent.RejectedExecutionException
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1774)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:768)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:656)
    at AbortPolicyDemo.main(AbortPolicyDemo.java:27)
task-0 is running.
task-1 is running.

将”线程池的拒绝策略”由DiscardPolicy修改为AbortPolicy之后,当有任务添加到线程池被拒绝时,会抛出RejectedExecutionException。

- 4. CallerRunsPolicy 示例

public class CallerRunsPolicyDemo {  
 
    private static final int THREADS_SIZE = 1;  
    private static final int CAPACITY = 1;  
 
    public static void main(String[] args) throws Exception {  
 
        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE),"线程池"的阻塞队列容量为1(CAPACITY)。  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  
                new ArrayBlockingQueue<Runnable>(CAPACITY));  
        // 设置线程池的拒绝策略为"CallerRunsPolicy"  
        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
 
        // 新建10个任务,并将它们添加到线程池中。  
        for (int i = 0; i < 10; i++) {  
            Runnable myrun = new MyRunnable("task-"+i);  
            pool.execute(myrun);  
        }  
 
        // 关闭线程池  
        pool.shutdown();  
    }  
}  

(某一次)运行结果:

task-2 is running.
task-3 is running.
task-4 is running.
task-5 is running.
task-6 is running.
task-7 is running.
task-8 is running.
task-9 is running.
task-0 is running.
task-1 is running.

将”线程池的拒绝策略”由DiscardPolicy修改为CallerRunsPolicy之后,当有任务添加到线程池被拒绝时,线程池会将被拒绝的任务添加到”线程池正在运行的线程”中取运行。

  • 大小: 322.3 KB
分享到:
评论

相关推荐

    JAVA线程池原理实例详解

    JAVA线程池原理实例详解 JAVA线程池是java中的一种高效的线程管理机制,它可以控制线程的创建、销毁和复用,从而提高系统的性能和可靠性。下面我们将详细介绍JAVA线程池的原理、创建、使用方法及相关注意事项。 一...

    Java线程池技术详解

    【Java线程池技术详解】 线程池是Java并发编程中的一个重要概念,它是一种线程使用模式,旨在优化线程的管理和使用,提高系统资源的利用率。线程池的引入是为了应对频繁创建和销毁线程所带来的性能开销,因为创建和...

    JAVA线程池例子

    Java线程池是一种高效管理线程资源的技术,它允许开发者创建一组可重用的工作线程,从而避免频繁地创建和销毁线程带来的性能开销。线程池在Java中主要通过`java.util.concurrent`包中的`ExecutorService`接口及其...

    Java线程池.pdf

    ### Java线程池详解 #### 引言 在现代计算机科学中,线程作为轻量级的进程,已经成为操作系统和应用程序提高并发性、优化资源利用的关键技术之一。线程池,作为线程管理的一种高级机制,更是现代软件工程中不可或...

    规范使用线程池与底层原理详解.docx

    5. **任务拒绝策略**:当线程池和任务队列都满载,无法再接收新任务时,线程池会根据预设的拒绝策略处理新任务。例如,可以丢弃新任务,抛出异常,或者让已存在的线程自己处理。 Java的`java.util.concurrent`包...

    详解Java线程池和Executor原理的分析

    Java线程池和Executor原理分析 Java线程池和Executor原理是Java并发编程中非常重要的一部分。线程池是一个或者多个线程的集合,用户可以把需要执行的任务简单地扔给线程池,而不用过多的纠结与执行的细节。Java...

    Java 线程池原理深入分析

    总结Java线程池是Java多线程编程的重要工具,通过合理的配置和使用,可以有效地管理和调度线程,提高系统性能。理解线程池的工作原理和参数配置,对于编写高效、稳定的多线程程序至关重要。在实际应用中,应根据任务...

    JAVA线程池应用.pptx

    ### JAVA线程池应用知识点详解 #### 一、Java线程池概述 线程池是Java多线程编程中的一个重要概念。它通过管理一组多线程的方式,为应用程序提供了一种更加灵活高效的线程管理机制。相比于直接创建线程,使用线程池...

    Java 线程池详解及创建简单实例

    Java线程池是一种高效管理并发任务的机制,它通过复用已存在的线程来减少线程创建和销毁的开销,从而提高系统的整体性能。本文将深入解析Java线程池的工作原理,并给出创建简单实例的步骤。 线程池的核心在于`java....

    线程池java

    ### 深入理解Java之线程池 #### 一、Java中的`ThreadPoolExecutor`类 在Java中,`ThreadPoolExecutor`是线程池的核心实现类之一,它提供了丰富的配置选项来...通过以上介绍,相信您对Java线程池有了更深入的理解。

    线程池详解:线程池七大核心参数、线程池工作原理、线程池的创建方式、线程池的拒绝策略、如何合理分配线程池大小

    线程池是Java多线程编程中的重要概念,它是一种管理线程的机制,通过池化技术有效地管理和控制线程的生命周期,以提高系统资源的利用率和系统性能。本篇文章将深入探讨线程池的七大核心参数、工作原理、创建方式、...

    Java 线程池ExecutorService详解及实例代码

    Java线程池ExecutorService是Java并发编程中非常重要的一个组件,它通过管理和复用线程资源,有效地控制并发任务的执行,从而提高系统的性能和稳定性。本文将详细讲解ExecutorService的原理、使用场景以及如何通过...

    java自定义线程池的原理简介

    java自定义线程池的原理简介是Java开发中非常重要的一种技术,它可以帮助我们更好地管理线程池,提高系统的性能和可靠性。在这篇文章中,我们将详细介绍java自定义线程池的原理详解,通过示例代码来演示如何实现一个...

    ThreadPoolExecutor线程池原理及其execute方法(详解)

    ThreadPoolExecutor线程池原理及其execute方法详解 ThreadPoolExecutor是Java并发包中提供的线程池类,用于管理和执行异步任务。ThreadPoolExecutor的执行原理可以分为四个步骤: 1.核心线程池:...

    java内置线程池 !!!

    ### Java内置线程池详解 #### 一、线程池基本概念 在深入探讨Java内置线程池之前,我们首先需要了解线程池的基本概念及其重要性。 **线程池**是一种多线程处理形式,它通过重用预创建的线程来执行任务,而不是为...

    JavaThreaddemo_DEMO_tidecme_线程池Java_源码.zip

    Java线程池是Java并发编程中的重要组成部分,它在多线程编程中扮演着至关重要的角色,有效地管理和调度线程资源,提高系统性能并降低资源消耗。本资料"JavaThreaddemo_DEMO_tidecme_线程池Java_源码.zip"包含了关于...

    JAVA后端架构师.pdf

    6. 线程池基础知识:CachedThreadPool、FixThreadPool、SingleThreadPool、ScheduledThreadPool、ThreadPoolExecutor详解、自定义线程池七大参数详解、线程池任务提交、线程池任务执行、线程池参数调节、线程池监控...

    JAVA服务器端Socket线程池

    ### JAVA服务器端Socket线程池知识点详解 #### 一、概览 在Java服务器开发中,线程池技术被广泛应用于提升系统性能和资源利用效率。本文将详细解析标题为“JAVA服务器端Socket线程池”的知识点,涵盖其基本概念、...

    java多线程设计模式详解(PDF及源码)

    通过阅读提供的“java多线程设计模式详解”PDF文档,开发者可以深入了解各种模式的原理和应用场景,结合源码进行实践,有助于提升多线程编程能力。同时,“ajava注释.txt”可能包含了对源码的详细解释,而“ajava....

    多线程与线程池技术详解

    3. **工作原理**:线程池接收任务(Runnable或Callable),将其放入队列,由线程池中的工作线程处理。通过调整线程池参数,可以优化系统资源的使用。 4. **优势**:线程池能有效控制运行的线程数量,避免过多线程...

Global site tag (gtag.js) - Google Analytics