Exector线程池原理

最新推荐文章于 2023-06-26 16:01:49 发布
最新推荐文章于 2023-06-26 16:01:49 发布
阅读量260 收藏
点赞数
分类专栏： 基础知识 并发编程 文章标签： java 多线程 并发编程 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41843246/article/details/108334337
版权

线程池来源

“线程池”顾名思义就是一个线程的缓存，线程是稀缺资源，如果被无限制的创建线程，不仅会消耗系统资源，还会降低系统的稳定性，所以java中提供对线程池对线程进行统一分配，调优和监控。

线程的实现方式

// 实现Runnable接口的类将被Thread执行，表示一个基本的任务
public interface Runnable {
    // run方法就是它所有的内容，就是实际执行的任务
    public abstract void run();
}
//Callable同样是任务，与Runnable接口的区别在于它接收泛型，同时它执行任务后带有返回内容
public interface Callable<V> {
    // 相对于run方法的带有返回值的call方法
    V call() throws Exception;
}

线程池流程原理

在这里插入图片描述

线程池存在5种状态

在这里插入图片描述

RUNNING    = -1 << COUNT_BITS; //高3位为111
SHUTDOWN   =  0 << COUNT_BITS; //高3位为000
STOP       =  1 << COUNT_BITS; //高3位为001
TIDYING    =  2 << COUNT_BITS; //高3位为010
TERMINATED =  3 << COUNT_BITS; //高3位为011

  1. RUNNING(可接收，可处理)
    (1)状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。
    (2) 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！

  2. SHUTDOWN（不接受，可处理）
    (1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
    (2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。

  3. STOP（不接收，不处理）
    (1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
    (2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

  4. TIDYING（任务已终止）
    (1) 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
    (2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。 当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

  5. TERMINATED（线程池终止）
    (1) 状态说明：线程池彻底终止，就变成TERMINATED状态。
    (2) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING ->

关键源码方法解析

execute方法

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
/*
 * clt记录着runState和workerCount
 */
    int c = ctl.get();
/*
 * workerCountOf方法取出低29位的值，表示当前活动的线程数；
 * 如果当前活动线程数小于corePoolSize，则新建一个线程放入线程池中；
 * 并把任务添加到该线程中。
 */
    if (workerCountOf(c) < corePoolSize) {
/*
 * addWorker中的第二个参数表示限制添加线程的数量是根据corePoolSize来判断还是maximumPoolSize来判断；
 * 如果为true，根据corePoolSize来判断；
 * 如果为false，则根据maximumPoolSize来判断
 */
        if (addWorker(command, true))
            return;
/*
 * 如果添加失败，则重新获取ctl值
 */
        c = ctl.get();
    }
/*
 * 如果当前线程池是运行状态并且任务添加到队列成功
 */
    if (isRunning(c) && workQueue.offer(command)) {
// 重新获取ctl值
        int recheck = ctl.get();
 // 再次判断线程池的运行状态，如果不是运行状态，由于之前已经把command添加到workQueue中了，
// 这时需要移除该command
// 执行过后通过handler使用拒绝策略对该任务进行处理，整个方法返回
        if (! isRunning(recheck) && remove(command))
            reject(command);
/*
 * 获取线程池中的有效线程数，如果数量是0，则执行addWorker方法
 * 这里传入的参数表示：
 * 1. 第一个参数为null，表示在线程池中创建一个线程，但不去启动；
 * 2. 第二个参数为false，将线程池的有限线程数量的上限设置为maximumPoolSize，添加线程时根据maximumPoolSize来判断；
 * 如果判断workerCount大于0，则直接返回，在workQueue中新增的command会在将来的某个时刻被执行。
 */
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
/*
 * 如果执行到这里，有两种情况：
 * 1. 线程池已经不是RUNNING状态；
 * 2. 线程池是RUNNING状态，但workerCount >= corePoolSize并且workQueue已满。
 * 这时，再次调用addWorker方法，但第二个参数传入为false，将线程池的有限线程数量的上限设置为maximumPoolSize；
 * 如果失败则拒绝该任务
 */
    else if (!addWorker(command, false))
        reject(command);
}

简单来说，在执行execute()方法时如果状态一直是RUNNING时，的执行过程如下：

  • 如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务；
  • 如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中；
  • 如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务；
  • 如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

注意一下：addWorker(null, false);，也就是创建一个线程，但并没有传入任务，因为任务已经被添加到workQueue中了，所以worker在执行的时候，会直接从workQueue中获取任务。所以，在workerCountOf(recheck) == 0时执行addWorker(null, false);也是为了保证线程池在RUNNING状态下必须要有一个线程来执行任务。

addWorker(Runnable firstTask, boolean core)方法：

创建一个新的线程并执行，firstTask参数 用于指定新增的线程执行的第一个任务，core参数为true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
    // 获取运行状态
        int rs = runStateOf(c);
    /*
     * 这个if判断
     * 如果rs >= SHUTDOWN，则表示此时不再接收新任务；
     * 接着判断以下3个条件，只要有1个不满足，则返回false：
     * 1. rs == SHUTDOWN，这时表示关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务
     * 2. firsTask为空
     * 3. 阻塞队列不为空
     * 
     * 首先考虑rs == SHUTDOWN的情况
     * 这种情况下不会接受新提交的任务，所以在firstTask不为空的时候会返回false；
     * 然后，如果firstTask为空，并且workQueue也为空，则返回false，
     * 因为队列中已经没有任务了，不需要再添加线程了
     */
     // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                        firstTask == null &&
                        ! workQueue.isEmpty()))
            return false;
        for (;;) {
            // 获取线程数
            int wc = workerCountOf(c);
            // 如果wc超过CAPACITY，也就是ctl的低29位的最大值（二进制是29个1），返回false；
            // 这里的core是addWorker方法的第二个参数，如果为true表示根据corePoolSize来比较，
            // 如果为false则根据maximumPoolSize来比较。
            // 
            if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 尝试增加workerCount，如果成功，则跳出第一个for循环
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // 如果增加workerCount失败，则重新获取ctl的值
            c = ctl.get();  // Re-read ctl
            // 如果当前的运行状态不等于rs，说明状态已被改变，返回第一个for循环继续执行
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
     // 根据firstTask来创建Worker对象
        w = new Worker(firstTask);
     // 每一个Worker对象都会创建一个线程
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                int rs = runStateOf(ctl.get());
                // rs < SHUTDOWN表示是RUNNING状态；
                // 如果rs是RUNNING状态或者rs是SHUTDOWN状态并且firstTask为null，向线程池中添加线程。
                // 因为在SHUTDOWN时不会在添加新的任务，但还是会执行workQueue中的任务
                if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // workers是一个HashSet
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize记录着线程池中出现过的最大线程数量
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                // 启动线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

Worker类

线程池中的每一个线程被封装成一个Worker对象，ThreadPool维护的其实就是一组Worker对象

protected boolean tryAcquire(int unused) {
//cas修改state，不可重入
    if (compareAndSetState(0, 1)) { 
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}

Worker继承了AQS，使用AQS来实现独占锁的功能。为什么不使用ReentrantLock来实现呢？可以看到tryAcquire方法，它是不允许重入的，而ReentrantLock是允许重入的：

  1. lock方法一旦获取了独占锁，表示当前线程正在执行任务中；
  2. 如果正在执行任务，则不应该中断线程；
  3. 如果该线程现在不是独占锁的状态，也就是空闲的状态，说明它没有在处理任务，这时可以对该线程进行中断；
  4. 线程池在执行shutdown方法或tryTerminate方法时会调用interruptIdleWorkers方法来中断空闲的线程，interruptIdleWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态；
  5. 之所以设置为不可重入，是因为我们不希望任务在调用像setCorePoolSize这样的线程池控制方法时重新获取锁。如果使用ReentrantLock，它是可重入的，这样如果在任务中调用了如setCorePoolSize这类线程池控制的方法，会中断正在运行的线程。

runWorker方法

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    // 获取第一个任务
    Runnable task = w.firstTask;
    w.firstTask = null;
    // 允许中断
    w.unlock(); // allow interrupts
    // 是否因为异常退出循环
    boolean completedAbruptly = true;
    try {
        // 如果task为空，则通过getTask来获取任务
        while (task != null || (task = getTask()) != null) {
            w.lock();
            if ((runStateAtLeast(ctl.get(), STOP) ||
                    (Thread.interrupted() &&
                            runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                wt.interrupt();
            try {
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

runWorker方法的执行过程

  1. while循环不断地通过getTask()方法获取任务；
  2. getTask()方法从阻塞队列中取任务；
  3. 如果线程池正在停止，那么要保证当前线程是中断状态，否则要保证当前线程不是中断状态；
  4. 调用task.run()执行任务；
  5. 如果task为null则跳出循环，执行processWorkerExit()方法；
  6. runWorker方法执行完毕，也代表着Worker中的run方法执行完毕，销毁线程。

getTask方法

getTask方法用来从阻塞队列中取任务

private Runnable getTask() {
    // timeOut变量的值表示上次从阻塞队列中取任务时是否超时
    boolean timedOut = false; // Did the last poll() time out?
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // Check if queue empty only if necessary.
    /*
     * 如果线程池状态rs >= SHUTDOWN，也就是非RUNNING状态，再进行以下判断：
     * 1. rs >= STOP，线程池是否正在stop；
     * 2. 阻塞队列是否为空。
     * 如果以上条件满足，则将workerCount减1并返回null。
     * 因为如果当前线程池状态的值是SHUTDOWN或以上时，不允许再向阻塞队列中添加任务。
     */
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        int wc = workerCountOf(c);
        // Are workers subject to culling?
        // timed变量用于判断是否需要进行超时控制。
        // allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；
        // wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
        // 对于超过核心线程数量的这些线程，需要进行超时控制
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

    /*
     * wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
     * timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时
     * 接下来判断，如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
     * 如果减1失败，则返回重试。
     * 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
     */
        if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        try {
        /*
         * 根据timed来判断，如果为true，则通过阻塞队列的poll方法进行超时控制，如果在keepAliveTime时间内没有获取到任务，则返回null；
         * 否则通过take方法，如果这时队列为空，则take方法会阻塞直到队列不为空。
         *
         */
            Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
            if (r != null)
                return r;
            // 如果 r == null，说明已经超时，timedOut设置为true
            timedOut = true;
        } catch (InterruptedException retry) {
            // 如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循环重试
            timedOut = false;
        }
    }
}

这里重要的地方是第二个if判断，目的是控制线程池的有效线程数量。由上文中的分析可以知道，在执行execute方法时，如果当前线程池的线程数量超过了corePoolSize且小于maximumPoolSize，并且workQueue已满时，则可以增加工作线程，但这时如果超时没有获取到任务，也就是timedOut为true的情况，说明workQueue已经为空了，也就说明了当前线程池中不需要那么多线程来执行任务了，可以把多于corePoolSize数量的线程销毁掉，保持线程数量在corePoolSize即可。
什么时候会销毁？当然是runWorker方法执行完之后，也就是Worker中的run方法执行完，由JVM自动回收。
getTask方法返回null时，在runWorker方法中会跳出while循环，然后会执行processWorkerExit方法。

processWorkerExit方法

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // 如果completedAbruptly值为true，则说明线程执行时出现了异常，需要将workerCount减1；
    // 如果线程执行时没有出现异常，说明在getTask()方法中已经已经对workerCount进行了减1操作，这里就不必再减了。  
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //统计完成的任务数
        completedTaskCount += w.completedTasks;
        // 从workers中移除，也就表示着从线程池中移除了一个工作线程
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
    // 根据线程池状态进行判断是否结束线程池
    tryTerminate();
    int c = ctl.get();
/*
 * 当线程池是RUNNING或SHUTDOWN状态时，如果worker是异常结束，那么会直接addWorker；
 * 如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一个worker；
 * 如果allowCoreThreadTimeOut=false，workerCount不少于corePoolSize。
 */
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

至此，processWorkerExit执行完之后，工作线程被销毁，以上就是整个工作线程的生命周期，从execute方法开始，Worker使用ThreadFactory创建新的工作线程，runWorker通过getTask获取任务，然后执行任务，如果getTask返回null，进入processWorkerExit方法，整个线程结束，如图所示：
在这里插入图片描述

弑※焱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程池详解2--任务提交及执行
打酱油的葫芦娃
07-29 6576
ThreadPoolExecutor如何实现任务的提交和执行的呢? 首先，看一下ThreadPoolExecutor的Worker内部类。 Worker ThreadPoolExecutor定义了内部类Worker来表征线程池中的工作线程： // 继承了AQS，并实现了Runnable接口 private final class Worker extends AbstractQueuedSynchronizer implements Runnable { // 工作线程 final Thread
xxl-job整合mybatis&&mysql&&stringboot
08-06
【xxl-job整合mybatis、mysql与springboot详解】 XXL-JOB是一个分布式任务调度平台，设计目标是轻量级、易用性好且扩展性强。它提供了Web控制台进行任务管理和执行，支持多种调度触发策略，如定时、依赖、手动触发...
SpringBoot默认的线程池ThreadPoolTaskExecutor默认配置参数是否是单线程
weixin_42583683的博客
01-09 2262
SpringBoot默认的线程池ThreadPoolTaskExecutor的默认配置参数是多线程的。 ThreadPoolTaskExecutor的默认参数配置如下： 核心线程数：默认为1 最大线程数：默认为Integer.MAX_VALUE 线程存活时间：默认为60s 如果要使用单线程，可以通过设置核心线程数和最大线程数都为1来实现。 比如，使用如下配置： @Bean public Thr...
【java学习】ThreadPoolExecutor 线程池
午后阳光
09-28 2017
1，概念 一个线程池管理了一组工作线程，同时它还包括了一个用于放置等待执行任务的任务队列（阻塞队列）。 默认情况下，在创建了线程池后，线程池中的线程数为0。 Android中的线程池来自Java，主要通过Executor来派生特定类型的线程池。 创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer 类。 1.1 Executor接口 Executor 是一个顶层接口，在它里面...
ThreadPoolExecutor常用的五个参数介绍
qiangqiang_ya的博客
04-15 652
（2）核心线程数(CorePoolSize)：线程池中保持最小活动数的线程数量，并且不允许超时，除非调用allowCoreThreadTimeOut方法，这个时候最小值是0。（1）最大线程数(MaximumPoolSize)：线程池运行的最大线程数量，受属性CAPACITY的限制，最大为(2^29)-1(约5亿)当线程池线程数量小于核心线程数时，一个新的任务请求被提交上来时，不管其他线程是否处于空闲状态，都会新建一个线程来处理这个请求。
Java默认线程池及线程池参数
Shenkh的Java壁橱
07-19 4791
一、Executors默认创建的线程池   jdk中Executors提供了几种默认的线程池： FixedThreadPool 创建一个固定线程数的线程池，核心线程数和最大线程数固定相等。 keepAliveTime为0，意味着一旦有多余的空闲线程，就会被立即停止掉，不过因为最多只有nThreads个线程，且corePoolSize和maximunPoolSize值一致，所以这个值无法发挥作用。 阻塞队列采用了LinkedBlockingQueue，它是一个无界队列，由于阻塞队列是一个无界队列，因此永
Python库 | os-brick-2.2.0.tar.gz
05-20
资源分类：Python库 所属语言：Python 资源全名：os-brick-2.2.0.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
pi3151524witsplayerdemo：companydemo
02-10
此外，这也是在每个新连接上生成新线程的更好方法，线程池或exector是两个可能的替代方案。 最后，为简单起见，我没有进行任何错误处理。 该程序有3个参数python Witsplayer.py 7080 1 a.wits 第一个参数是绑定端口...
操作系统调度算法C#实现[参照].pdf
10-12
Exector exector = (Exector)obj; if (this.ratiopriority > exector.ratiopriority) { return 1; } else if (this.ratiopriority < exector.ratiopriority) { return -1; } else { return 0; } } 三...
Java并发编程（学习笔记）.xmind
06-19
使用Exector框架 线程池 newFixedThreadPool（固定长度的线程池） newCachedThreadPool（不限规模的线程池） newSingleThreadPool（单线程线程池） newScheduledThreadPool（带延迟/定时...
ThreadPoolExecutor任务提交与停止流程及底层实现
如何心安理得的在老板眼皮下摸鱼
03-09 1万+
ThreadPoolExecutor底层源码剖析，执行过程、停止过程中所涉及的函数执行过程，如excutor、线程池、Worker、task、shutdown等
线程池ThreadPoolExecutor详解（整理详细）
trusause的博客
07-12 2万+
线程池
Java并发——Executor框架详解（Executor框架结构与框架成员）
热门推荐
tongdanping的博客
03-20 8万+
一、什么是Executor框架？我们知道线程池就是线程的集合，线程池集中管理线程，以实现线程的重用，降低资源消耗，提高响应速度等。线程用于执行异步任务，单个的线程既是工作单元也是执行机制，从JDK1.5开始，为了把工作单元与执行机制分离开，Executor框架诞生了，他是一个用于统一创建与运行的接口。Executor框架实现的就是线程池的功能。二、Executor框架结构图解1、Executor框...
ThreadPoolExecutor执行流程和拒绝策略
qq_36935038的博客
03-01 278
首先通过文档我们看看ThreadPoolExcutor提供给我们的构造方法它提供了很多种构造方法，可以支持很多参数，支持很多选项，让我们创建出不同风格的线程池。corePoolSize：核心线程数 （类似于正式员工）maximumPoolSize 最大线程数 （类似于正式员工+实习员工）需要注意的是：核心线程数即使线程空闲也不会被销毁，但是最大线程数中除去核心线程数部分如果空闲太长时间则会被销毁，防止占用系统资源。
线程线程池并行开发JAVA_使用ThreadPoolExecutor 创建线程池，完成并行操作
weixin_32532029的博客
02-23 185
packagecom.hao.service;importjava.util.ArrayList;importjava.util.Arrays;importjava.util.LinkedList;importjava.util.List;importjava.util.concurrent.Callable;importjava.util.concurrent.CountDownLatch;im...
ThreadPoolExecutor并行编程Demo
bruce128的专栏
11-05 2709
    今天要把线上600M的日志进行信息抽取，提取出被多次编码的中文账号。日志文件有200W行，用单线程的程序跑，花了20分钟。感觉速度不够快，而且CPU的使用率一直是25%， 根本没有有效的利用硬件资源。于是尝试用多线程的程序进行提速，CPU耗到了接近100%， 程序内存耗到了200M，最终花了14分钟把数据跑完，提速了6分钟，感觉还不错。因为对JDK的多线程框架还不熟悉，多线程的代码改写了好...
java多线程并发执行中保证关键代码线程安全
最新发布
m0_69733784的博客
06-26 336
使用多线程和锁的矛盾在于，多线程可以提高程序的处理效率，而锁的加入会对程序产生一定的性能影响。锁是一种同步工具，用于保护临界区，避免多个线程同时访问临界区产生的问题。需要注意的是，尽管多线程可以大大提升程序的处理效率，但在多线程编程时还需要注意线程安全问题，如避免竞态条件和死锁问题等。ThreadPoolExecutor是Java多线程中提供的线程池，它可以很方便地创建一个固定大小的线程池，将多个Runnable任务或Callable任务分配给线程池中的多个线程来并发执行，从而提高程序的处理效率。
ThreadPoolExecutor线程池参数解析,以及设置参数的算法
weixin_42146026的博客
12-08 350
线程池设置
C#实现操作系统调度算法详解与进程管理
阅读者可以通过这个例子学习如何在C#中模拟和管理多任务处理，理解不同调度算法的工作原理，并能将其应用于实际项目中。同时，由于有.NET Framework和Windows Forms的引用，它更倾向于GUI应用程序的后台调度管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值