线程池ThreadPoolExecutor源码分析

一、线程池基本概念和线程池前置知识

1.1 Java中创建线程的方式有哪些

传统答案：

  • 继承Thread类

        通过继承Thread类并重写其run方法来创建线程。具体步骤包括定义Thread类的子类，在子类中重写run方法以实现线程的具体逻辑，然后创建子类的实例并调用其start方法来启动线程。

  • 实现Runnable接口

        通过实现Runnable接口并重写其run方法来创建线程。这种方式相较于继承Thread类更为灵活，因为Java不支持多重继承，而实现接口则没有这个问题。实现Runnable接口后，需要将其实现类的实例作为参数传递给Thread类的构造函数，然后调用Thread对象的start方法来启动线程。

  • 实现Callable接口

        Callable接口与Runnable接口类似，但其call方法可以返回值，并且可以抛出异常。创建Callable实现类的实例后，通常使用FutureTask类来包装它，并将FutureTask对象作为Thread对象的target来创建并启动新线程。调用FutureTask对象的get方法可以获取子线程执行结束后的返回值。

  • 创建线程池

        Executor框架提供了多种线程池的实现，如单线程池（newSingleThreadExecutor）、固定大小的线程池（newFixedThreadPool）、可缓存的线程池（newCachedThreadPool）以及定时线程池（newScheduledThreadPool）等。使用线程池可以更有效地管理线程的创建、销毁和调度，从而提高系统的性能和稳定性。

1.2 为什么要使用线程池

  1. 降低资源消耗：在创建和销毁线程时，会消耗一定的系统资源，包括CPU和内存。通过线程池，可以重复利用已创建的线程，从而降低这种消耗。
  2. 提高响应速度：当新任务到达时，如果线程池中已有空闲线程，则任务可以立即执行，无需等待线程的创建。
  3. 提高线程的可管理性：线程是稀缺资源，如果无限制地创建线程，不仅会消耗大量系统资源，还可能降低系统的稳定性和性能。线程池提供了统一的线程管理和调优机制，可以方便地对线程进行监控和管理。

1.3 线程池的核心参数

在源码中找到ThreadPoolExecutor类中参数最多的一个构造方法

这七个就是线程池的核心参数：

  • int corePoolSize, 
  • int maximumPoolSize,
  • long keepAliveTime,
  • TimeUnit unit,
  • BlockingQueue<Runnable> workQueue,
  • ThreadFactory threadFactory,
  • RejectedExecutionHandler handler
  1. corePoolSize（核心线程数）：
    • 含义：线程池中始终保持活动的线程数量，即使这些线程处于空闲状态，也不会被销毁(默认情况下)。
    • 作用：当任务提交到线程池时，如果当前线程数未达到corePoolSize，则会创建新线程来执行任务。
  2. maximumPoolSize（最大线程数）：
    • 含义：线程池中允许的最大线程数量。
    • 作用：当任务队列已满，且当前线程数小于maximumPoolSize时，线程池会创建新的线程来处理任务。但线程池不会无限制地创建线程，最大线程数由maximumPoolSize指定。
  3. keepAliveTime（空闲线程存活时间）：
    • 含义：当线程池中的线程数量超过corePoolSize时，空闲线程在指定的时间内没有被使用时，将被销毁，直到线程池中的线程数量减少到corePoolSize为止。
    • 计量单位：由unit参数指定。
  4. unit（时间单位）：
    • 含义：keepAliveTime的时间单位。
    • 可选值：TimeUnit.DAYS（天）、TimeUnit.HOURS（小时）、TimeUnit.MINUTES（分）、TimeUnit.SECONDS（秒）、TimeUnit.MILLISECONDS（毫秒）、TimeUnit.MICROSECONDS（微秒）、TimeUnit.NANOSECONDS（纳秒）。
  5. workQueue（工作队列）：
    • 含义：用于保存等待执行的任务的队列。
    • 类型：线程池提供了多种工作队列的实现，如ArrayBlockingQueue（基于数组的有界阻塞队列）、LinkedBlockingQueue（基于链表的无界阻塞队列）、SynchronousQueue（一个不缓存任务的阻塞队列）等。
    • 作用：当新任务提交到线程池时，如果线程数未达到corePoolSize，则创建新线程处理；如果线程数已达到corePoolSize但小于maximumPoolSize，且工作队列未满，则将任务放入工作队列；如果工作队列已满且线程数小于maximumPoolSize，则创建新线程处理；如果工作队列已满且线程数已达到maximumPoolSize，则执行拒绝策略。
  6. threadFactory（线程工厂）：
    • 含义：用于创建新线程的工厂。
    • 作用：可以自定义线程的名称、优先级等属性。
  7. handler（拒绝策略）：
    • 含义：当任务无法加入工作队列且线程池已达到最大线程数时，用于处理新提交的任务的策略。
    • 类型：常见的拒绝策略包括抛出异常、丢弃任务、丢弃队列中最老的任务、将任务分给调用线程来执行等。

二、线程池任务处理策略

线程池执行任务的方法是execute方法。

想要查看执行流程的话，需要查看的就是execute方法的源码。

将源码文本粘贴出来，逐步分析：

    // 任务交给线程池处理时，一般会执行execute方法，并传递任务// command 就是传递过来的任务public void execute(Runnable command) {// 非空校验if (command == null)throw new NullPointerException();// 以下是核心业务流程// ctl 是什么？ctl是线程池的一个核心属性。// 想要了解线程池的执行流程需要先知道线程池的核心属性int c = ctl.get();if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))return;c = ctl.get();}if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();if (! isRunning(recheck) && remove(command))reject(command);else if (workerCountOf(recheck) == 0)addWorker(null, false);}else if (!addWorker(command, false))reject(command);}

 由于在execute方法中使用到了线程池的核心属性 ctl，所以我们先看一下ctl

粘贴出来分析：

    // 线程池的核心属性// AtomicInteger是系统底层保护的int类型，通过对int类型的数据进行封装，提供执行方法的控制进行值的原子操作。// 可以理解为private final int ctl = 0;// ctl 存储了线程池的两个核心属性：线程池状态和工作线程个数// int类型占32个比特位// 线程池状态：基于ctl的高三位存储线程池状态// 工作线程个数：基于ctl的低29位存储工作线程个数// 那么线程池中最多可以有多少个工作线程呢？答案是2^29个private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));// Integer.SIZE=32  所以COUNT_BITS =29private static final int COUNT_BITS = Integer.SIZE - 3;// CAPACITY 就是2^29 也就是线程池中工作线程数的最大值private static final int CAPACITY   = (1 << COUNT_BITS) - 1;// 下面5个属性是线程池的状态private static final int RUNNING    = -1 << COUNT_BITS;private static final int SHUTDOWN   =  0 << COUNT_BITS;private static final int STOP       =  1 << COUNT_BITS;private static final int TIDYING    =  2 << COUNT_BITS;private static final int TERMINATED =  3 << COUNT_BITS;

线程池的生命周期（五个状态）：

整明白了线程池的核心属性，下面可以继续看ThreadPoolExecutor的execute方法了

    // 任务交给线程池处理时，一般会执行execute方法，并传递任务// command 就是传递过来的任务public void execute(Runnable command) {// 非空校验if (command == null)throw new NullPointerException();// 以下是核心业务流程// ctl.get()：拿到存储线程池状态和工作线程个数的核心属性int c = ctl.get();// workerCountOf（） 获取工作线程个数 corePoolSize：核心线程数// 判断当前工作线程数是否小于核心线程数（构建线程池时指定的）if (workerCountOf(c) < corePoolSize) {// 创建工作线程//第一个参数 command ：传递的任务//第二个参数 是否是核心线程，true：创建核心线程；false：创建非核心线程// addWorker方法 返回值是布尔类型  代表创建是否成功           if (addWorker(command, true))// 创建成功，结束，任务给核心线程处理return;//创建失败 重新获取核心属性ctlc = ctl.get();}// 如果当前工作线程数已经达到核心线程数 执行下面的语句// isRunning(c) 判断当前线程池是不是running状态 如果是直接将任务扔进工作队列// offer方法：扔到工作队列，成功返回true，失败返回falseif (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();if (! isRunning(recheck) && remove(command))reject(command);else if (workerCountOf(recheck) == 0)addWorker(null, false);}// 尝试构建非核心线程去处理当前任务else if (!addWorker(command, false))// 如果非核心线程创建失败 执行拒绝策略reject(command);}

从上面源码可以看出，执行流程为：核心线程-工作队列-非核心线程-拒绝策略

如果想要修改默认的顺序可以重写execute方法来实现。

问题1：

下面代码块，是在工作线程数量小于核心线程数量时执行的代码，作用是，工作线程数量小于核心线程数量时，创建一个核心线程，并把任务给这个核心线程。

  if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))// 创建成功，结束，任务给核心线程处理return;//创建失败 重新获取核心属性ctlc = ctl.get();}

那么问题是为什么创建核心线程失败后要使用 c = ctl.get();来重新获取核心属性呢？

举个例子来回答这个问题，假如核心线程数是5，当前工作线程数是4，在并发情况下，有两个线程同时进入到if代码块里面，都去执行addWorker(command, true)方法，创建核心工作线程，由于addWorker方法内部通过一定的方式保证了原子性，所以只能创建成功1个核心工作线程，另一个不会创建成功（返回false），这种情况，不会直接return，会去继续执行方法下面的代码，下面的代码会使用到核心线程属性ctl，而此时显然ctl核心线程属性已经发生了变化（另外一个线程创建成功了一个工作线程，工作线程数量发生了变化），需要重新获取最新的。

问题2：

     if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();if (! isRunning(recheck) && remove(command))reject(command);else if (workerCountOf(recheck) == 0)addWorker(null, false);}

这段代码中，主要实现的是如果线程池是Running状态，将任务放入工作队列的功能。

那么isRunning(c) 和workQueue.offer(command)两句代码不是就能实现这个功能了吗，为什么还要写上述代码？

因为在多线程环境中，当执行完isRunning(c) 和执行workQueue.offer(command)之间的间隙，线程池的状态可以就发生了变化。

比如一开始线程池是Running状态，执行isRunning(c)得到返回值true，然后在执行workQueue.offer(command)代码前线程池状态改变，不再是Running状态了，不过由于之前获取到的isRunning(c)的返回值是true，所以还是会执行workQueue.offer(command)方法。

这样显然是有问题的，所以为了应对这种情况，在下面添加了以下代码：

// ctl.get();重新获取线程池核心属性
int recheck = ctl.get();
// 根据核心属性 重新校验线程池是否是Running状态，如果不是Running状态，移除前边添加的任务并执行拒绝策略
if (! isRunning(recheck) && remove(command))reject(command);
// 如果线程池状态还是为Running状态 则执行下面语句
// 如果线程池仍然在运行，但此时工作线程的数量为0（workerCountOf(recheck)返回0），则调用addWorker(null, false)方法来添加一个新的核心线程。
//null 作为第一个参数，表示这个新线程在启动时不带有任何初始任务 ，false代表创建非核心线程
else if (workerCountOf(recheck) == 0)addWorker(null, false);

关于   addWorker(null, false)：

  1. firstTask 参数允许你指定一个新创建的线程应该首先运行的任务。如果 firstTask 是 null，那么新线程将不会立即执行任何任务，而是会等待从工作队列中取出一个任务来执行。

  2. 在线程池的工作机制中，如果当前线程数少于 corePoolSize（核心线程数），并且有新任务提交，那么线程池会尝试启动一个新线程来执行这个任务，而不是将任务放入工作队列。

三、创建工作线程的流程

查看创建工作线程的流程主要是查看addWorker方法的源码

对源码逐步解析:

// 创建工作线程（核心线程和非核心线程都是基于addWorker创建的）
// 第一个参数：任务，第二个参数：指定是核心还是非核心
private boolean addWorker(Runnable firstTask, boolean core) {// 第一部分代码// 做两件事情：// 1.判断线程池状态（外层for循环）// 2.判断线程个数（内层for循环），然后基于cas修改ctl属性，给工作线程个数+1retry:  // 给外层for循环取一个名称retryfor (;;) { // 死循环 相当于while（true）int c = ctl.get(); // 拿到核心属性ctlint rs = runStateOf(c); // rs:高三位的线程池状态// rs >=SHUTDOWN 即rs为SHUTDOWN/STOP/TIDYING/TERMINATED 即不是Running状态// 根据前面线程池五个属性的那张图可知线程池不能接收新任务if (rs >= SHUTDOWN &&// 第二个判断 解决在SHUTDOWN 状态下，没有工作线程，但是工作队列有任务// 要构建一个线程处理阻塞队列（工作队列）任务的情况// rs == SHUTDOWN &&firstTask == null &&! workQueue.isEmpty())的情况不能走return语句! (rs == SHUTDOWN &&firstTask == null &&! workQueue.isEmpty()))return false;for (;;) {int wc = workerCountOf(c); // 工作线程个数// CAPACITY :工作线程最大值if (wc >= CAPACITY ||// 核心线程：判断corePoolSize // 非核心线程：判断maximumPoolSize// core 是addWorker的第二个参数 true代表核心线程，false代表创建非核心线程wc >= (core ? corePoolSize : maximumPoolSize))return false;// 为什么要用CAS的方式修改？// 为了避免多线程并发创建工作线程，导致破坏设置的核心参数（比如设置核心参数是5，创建了6个）if (compareAndIncrementWorkerCount(c))// 如果成功 跳出外层循环break retry;c = ctl.get();  // Re-read ctlif (runStateOf(c) != rs)continue retry;// else CAS failed due to workerCount change; retry inner loop}}// 第二部分代码// 做两件事情：1.创建工作线程 2.启动工作线程boolean workerStarted = false; boolean workerAdded = false;Worker w = null;// Worker 对象就是工作线程try {// 创建工作线程，并把任务交给Worker 对象w = new Worker(firstTask);// 将new Worker时创建的thread拿到final Thread t = w.thread;// 判断使用线程池的用户，指定的线程工厂构建的thread不是nullif (t != null) {// 同步锁   为什么要加锁？// 下面workers.add(w); 按住Ctrl+单击 查看可知 workers是HashSet类型// HashSet不是线程安全的 为了保证线程安全，所以加锁了，不加锁不安全final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {int rs = runStateOf(ctl.get());if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {if (t.isAlive()) // precheck that t is startablethrow new IllegalThreadStateException();workers.add(w);int s = workers.size();if (s > largestPoolSize)largestPoolSize = s;workerAdded = true;}} finally {mainLock.unlock();}// 如果工作线程添加成功 则启动该线程if (workerAdded) {t.start();// 启动一个线程，执行run方法workerStarted = true;}}} finally {if (! workerStarted)addWorkerFailed(w);}return workerStarted;}

根据源码总结：

线程池在创建工作线程时：

  • 判断线程池是否符合要求。
  • 判断工作线程个数是否符合要求，并且基于CAS保证原子性。
  • new Worker创建工作线程，并添加HashSet中，基于ReentrantLock保证原子性。
  • 拿到Worker对象中的thread，执行start方法，启动线程。

四、工作线程Worker

线程池中的工作线程就是Worker对象，查看一下Worker里面做了什么事情。

  // Worker是工作线程，Worker也会存储一个任务（只存储第一个任务）
private final class Workerextends AbstractQueuedSynchronizerimplements Runnable{      final Thread thread; // 工作线程Runnable firstTask; // 任务volatile long completedTasks;Worker(Runnable firstTask) {setState(-1); // inhibit interrupts until runWorker// 任务存放this.firstTask = firstTask;// 线程构建 传入this 当前对象// 创建的线程调用start启动时，执行的是谁的run方法？// 执行的是Worker对象里面的run方法this.thread = getThreadFactory().newThread(this);}// addWorker方法中执行thread.start()方法后，执行的是Worker对象中的run方法public void run() {runWorker(this);}
}

AQS是什么?

AQS是AbstractQueuedSynchronizer，是JUC包下的并发基础类，很多同步内容都是基于AQS实现的，比如：

  • ReentrantLock
  • ReentrantReadWriteLock
  • CountDownLatch
  • Semaphore
  • 线程池中的Worker对象也是基于AQS做了一个实现

Worker继承AQS干嘛？

Worker线程继承了AQS后，可以使用基于CAS修改的属性state

在shutdown状态下空闲线程要执行interrupt中断，工作中的线程，不能执行interrupt

工作线程在处理任务前，会先执行lock方法（将state从0改为1），也就是正在干活的线程state==1

在终端线程前，判断每一个线程的state，如果为0直接interrupt，如果为1什么也不做。

五、执行/拉取任务流程

5.1 执行任务

执行任务，就是启动工作线程后，执行了Worker对象中的run方法，run方法中执行了runWorker方法。 

工作线程直接通过task.run执行任务，并且线程池预留了beforeExecute和afterExecute方法，可以在任务执行前后做一些额外处理。

// runWorker传递的参数就是Worker对象本身
final void runWorker(Worker w) {// 拿到工作线程中的threadThread wt = Thread.currentThread();// 拿到Worker对象中存储的第一个任务Runnable task = w.firstTask;w.firstTask = null;w.unlock(); // allow interruptsboolean completedAbruptly = true;try {// 如果Worker对象在启动时携带了任务，那就优先执行携带的任务while (task != null || (task = getTask()) != null) {w.lock();// 判断线程池状态是不是stop 如果时stop强制中断当前线程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);}}

5.2 拉取任务

工作线程在处理完自带的任务后会直接基于getTask方法，从阻塞队列中拉取任务。

如果是核心线程，默认情况下，会基于take方法在工作队列中拉取任务。

如果是非核心线程，会基于poll方法，拉取指定时间任务。（时间到了直接告辞）

// 工作线程从阻塞队列拉取任务的操作
private Runnable getTask() {boolean timedOut = false; // Did the last poll() time out?for (;;) {int c = ctl.get();int rs = runStateOf(c);// 判断线程池状态 如果状态已经变为stop或者状态为shutdown且工作队列任务都处理完毕if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {// 工作线程个数-1 并且干掉当前工作线程 // 线程正常死亡：run方法结束decrementWorkerCount();return null;//  return null： runWarker方法中 while循环结束，线程正常消亡；// 因为是Worker类中的run 方法中调用的runWarker方法，并且run方法中没有其他代码// 所以runWarker结束，run方法也就结束了，线程也就消亡了}int wc = workerCountOf(c);// 核心线程执行take  非核心线程执行poll方法（poll方法拉取最大空闲时间）// 线程池中的核心线程可以基于keepAliveTime（最大空闲时间）去结束吗？// 或者说线程池中的核心线程一定会永远存放在线程池里面吗？// 不一定 有一个属性allowCoreThreadTimeOut：是否允许核心线程超时，默认是false，但可以设置为trueboolean timed = allowCoreThreadTimeOut || wc > corePoolSize;if ((wc > maximumPoolSize || (timed && timedOut))&& (wc > 1 || workQueue.isEmpty())) {if (compareAndDecrementWorkerCount(c))return null;continue;}try {Runnable r = timed ?// poll方法，拉取阻塞队列任务，指定keepAliveTime时间workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :// take方法，死等任务，知道中断workQueue.take();if (r != null)return r;timedOut = true;} catch (InterruptedException retry) {timedOut = false;}}}

六、线程池关闭流程和锁

shutdown方法：

  • 将线程池状态修改为shutdown
  • 将空闲的工作线程直接中断
  • 在确认工作队列中的任务全部处理完并且工作线程个数为0，自动改为tidying状态
  • 在tidying状态下，执行terminated方法，变为terminated状态
  • 到这线程池结束
    // 优雅的关闭线程池// 为什么要加锁？// 会操作Worker对象public void shutdown() {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {checkShutdownAccess();advanceRunState(SHUTDOWN);// 线程池状态修改为shutdowninterruptIdleWorkers();// 中断空闲的工作线程onShutdown(); // hook for ScheduledThreadPoolExecutor} finally {mainLock.unlock();}tryTerminate();}

shutdownNow方法：

  • 将线程池状态修改为stop
  • 将所有的工作线程直接中断
  • 在工作线程个数为0之后，自动改为tidying状态
  • 在tidying状态下，执行terminated方法，变为terminated状态
  • 到这线程池结束

在工作中核心线程数、最大线程数、最大空闲时间、任务队列怎么设置比较好？

如果为了充分发挥硬件性能，一般只需要考虑三个信息的设置

  • 核心线程数：最重要的属性，你要根据你的任务类型，判断线程数设置多少合适

        任务类型：

                CPU密集型任务：线程一直在干活，不希望CPU做上下文切换。

                io密集型任务：因为线程干一会儿歇一会儿。

                混合型任务：因为混合型偶尔要求CPU一直调度，偶尔不干活，可以切换。

                想要设置好核心线程数，去发挥服务器硬件性能，需要动态的调试和压测。为了避免调试参数时反复重启，并且成本太高，可以直接设置动态线程池，因为线程池提供了Set方法设置核心参数，以及get方法查看核心参数，可以在压测时，根据CPU占用率和使用情况，来调整核心线程数。

  • 工作队列长度：根据服务器内存使用情况来调试，同时也要查看好jvm的堆内存大小。
  • 拒绝策略：根据任务来决定，如果任务就是写个日志啥的，那就直接扔了，如果任务是必须要执行的，那就直接重试，或者存储到数据库，后期做同意补偿操作。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/28310.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Unity的三种Update方法

Unity的三种Update方法

1、FixedUpdate 物理作用——处理物理引擎相关的计算和刚体的移动 (1) 调用时机&#xff1a;在固定的时间间隔内&#xff0c;而不是每一帧被调用 (2) 作用&#xff1a;用于处理物理引擎的计算&#xff0c;例如刚体的移动和碰撞检测 (3) 特点&#xff1a;能更准确地处理物理…
阅读更多...
植物大战僵尸杂交版全新版v2.1解决全屏问题

植物大战僵尸杂交版全新版v2.1解决全屏问题

文章目录 &#x1f68b;一、植物大战僵尸杂交版❤️1. 游戏介绍&#x1f4a5;2. 如何下载《植物大战僵尸杂交版》 &#x1f680;二、解决最新2.1版的全屏问题&#x1f308;三、画质增强以及减少闪退 &#x1f68b;一、植物大战僵尸杂交版 《植物大战僵尸杂交版》是一款在原版《…
阅读更多...
Es 索引查询排序分析

Es 索引查询排序分析

文章目录 概要一、Es数据存储1.1、_source1.2、stored fields 二、Doc values2.1、FieldCache2.2、DocValues 三、Fielddata四、Index sorting五、小结六、参考 概要 倒排索引 优势在于快速的查找到包含特定关键词的所有文档&#xff0c;但是排序&#xff0c;过滤、聚合等操作…
阅读更多...
内存分配器性能优化

内存分配器性能优化

背景 在之前我们提到采用自定义的内存分配器来解决防止频繁 make 导致的 gc 问题。gc 问题本质上是 CPU 消耗&#xff0c;而内存分配器本身如果产生了大量的 CPU 消耗那就得不偿失。经过测试初代内存分配器实现过于简单&#xff0c;产生了很多 CPU 消耗&#xff0c;因此必须优…
阅读更多...
跨语言翻译的突破：使用强化学习与人类反馈提升机器翻译质量

跨语言翻译的突破：使用强化学习与人类反馈提升机器翻译质量

在人工智能领域&#xff0c;知识问答系统的性能优化一直是研究者们关注的焦点。现有的系统通常面临知识更新频繁、检索成本高、以及用户提问多样性等挑战。尽管采用了如RAG&#xff08;Retrieval-Augmented Generation&#xff09;和微调等技术&#xff0c;但它们各有利弊&…
阅读更多...
C++ 45 之 赋值运算符的重载

C++ 45 之 赋值运算符的重载

#include <iostream> #include <string> #include <cstring> using namespace std;class Students05{ public:int m_age;char* m_name;Students05(){}Students05(const char* name,int age){// 申请堆空间保存m_name;this->m_name new char[strlen(name)…
阅读更多...
案例 采用Springboot默认的缓存方案Simple在三层架构中完成一个手机验证码生成校验的程序

案例 采用Springboot默认的缓存方案Simple在三层架构中完成一个手机验证码生成校验的程序

案例 Cacheable 是 Spring Framework 提供的一个注解&#xff0c;用于在方法执行前先检查缓存&#xff0c;如果缓存中已存在对应的值&#xff0c;则直接返回缓存中的值&#xff0c;而不执行该方法体。如果缓存中不存在对应的值&#xff0c;则执行方法体&#xff0c;并将方法的…
阅读更多...
免费下载全球逐日气象站点数据

免费下载全球逐日气象站点数据

环境气象数据服务平台近期升级了NOAA GSOD 全球逐日气象站点数据&#xff08;NOAA Global Surface Summary of the Day &#xff09;的检索方式&#xff0c;升级后&#xff0c;用户无需注册&#xff0c;即可以在平台上下载全球逐日气象站点数据。 检索方式&#xff1a; 1. 访…
阅读更多...
Python学习打卡：day07

Python学习打卡：day07

day7 笔记来源于&#xff1a;黑马程序员python教程&#xff0c;8天python从入门到精通&#xff0c;学python看这套就够了 目录 day753、列表的常用操作课后练习题54、列表的循环遍历列表的遍历—— while 循环列表的遍历—— for 循环while 循环和 for 循环的对比练习 55、元组…
阅读更多...
3 高频小信号放大器

3 高频小信号放大器

分类与质量指标 分类 质量指标 增益 电压与功率的放大倍数。 通频带 放大效果比较好的频率范围。 选择性 放大目标信号以滤除其他信号的综合能力。 稳定性 噪声系数 晶体管高频等效电路 混合Π等效电路 共射三极管的等效电路。 Y参数等效电路 混合Π与Y参数等效电路的转换 单…
阅读更多...
蚂蚁集团：2023年科研投入211.9亿元

蚂蚁集团：2023年科研投入211.9亿元

6月13日&#xff0c;蚂蚁集团发布2023年可持续发展报告。报告显示&#xff0c;2023年蚂蚁集团科研投入达到211.9亿元&#xff0c;再创历史新高&#xff0c;蚂蚁科技投入的重点是人工智能和数据要素技术。 蚂蚁集团董事长兼CEO井贤栋在报告致辞中说&#xff0c;面向未来&#x…
阅读更多...
【LeetCode 动态规划】买卖股票的最佳时机问题合集

【LeetCode 动态规划】买卖股票的最佳时机问题合集

文章目录 1. 买卖股票的最佳时机含冷冻期 1. 买卖股票的最佳时机含冷冻期 题目链接&#x1f517; &#x1f34e;题目思路&#xff1a; &#x1f34e;题目代码&#xff1a; class Solution { public:int maxProfit(vector<int>& prices) {int n prices.size();ve…
阅读更多...
NVIDIA Triton系列01-应用概论

NVIDIA Triton系列01-应用概论

NVIDIA Triton系列01-应用概论 推理识别是人工智能最重要的落地应用&#xff0c;其他与深度学习相关的数据收集、标注、模型训练等工作&#xff0c;都是为了得到更好的最终推理性能与效果。 几乎每一种深度学习框架都能执行个别的推理工作&#xff0c;包括 Tensorflow、Pytorc…
阅读更多...
STL——set、map、multiset、multimap的介绍及使用

STL——set、map、multiset、multimap的介绍及使用

文章目录 关联式容器键值对树形结构与哈希结构setset的介绍set的使用set的模板参数列表set的构造set的使用set的迭代器使用演示 multisetmultiset演示 mapmap的定义方式map的插入map的查找map的[ ]运算符重载map的迭代器遍历multimapmultimap的介绍multimap的使用 在OJ中的使用…
阅读更多...
tsp可视化python

tsp可视化python

随机生成点的坐标并依据点集生成距离矩阵&#xff0c;通过点的坐标实现可视化 c代码看我的这篇文章tsp动态规划递归解法c from typing import List, Tuple import matplotlib.pyplot as plt from random import randintN: int 4 MAX: int 0x7f7f7f7fdistances: List[List[in…
阅读更多...
Codeforces Round 953 (Div. 2) A - C 题解

Codeforces Round 953 (Div. 2) A - C 题解

因为有事只做了A-C&#xff0c;都比较简单&#xff0c;全是很简单的思维&#xff0c;明天有空还会添加上D&#xff0c;如果有人需要可以明天常来看看&#xff01; 进入正题&#xff1a; A. Alice and Books 题意&#xff1a;给你n个数字&#xff0c;将这些数字分到两堆里&am…
阅读更多...
@AliasFor 使用

@AliasFor 使用

AliasFor 使用 AliasFor 它允许开发者为一个注解的属性指定别名。通过使用AliasFor&#xff0c;我们可以提供多个名称来引用同一属性&#xff0c;从而增加了代码的灵活性和可读性 定义一个注解 package com.example.demo.aspect;import org.springframework.core.annotation…
阅读更多...
asyncio协程提高执行效率

asyncio协程提高执行效率

from fastapi import FastAPI import asyncioapp FastAPI()async def task1():# 模拟执行任务1print("开始执行任务1")await asyncio.sleep(1)print("结束执行任务1")return "Result from Task 1"async def task2():# 模拟执行任务2print("…
阅读更多...
论文阅读笔记（通道注意力）

论文阅读笔记（通道注意力）

论文阅读笔记&#xff08;通道注意力&#xff09; 摘要Abstract1. SENet1.1 研究背景1.2 创新点1.3 SE块的构建过程1.3.1 注意力和门机制1.3.2 SE块具体运行过程1.3.3 通道间依赖关系的提取1.3.4 自适应重新校正(Excitation) 1.4 SE结合先进架构的灵活应用1.5 实验1.6 模型的实…
阅读更多...
软考初级网络管理员__操作系统单选题

软考初级网络管理员__操作系统单选题

1.使用Windows提供的网络管理命令(请作答此空)可以查看本机的路由表&#xff0c;()可以修改本机的路由表。 tracert arp ipconfig netstat 2.在Windows 的命令行窗口中键入命令C:\>nslookupset type MX>202.30.192.2这个命令序列的作用是查询()。 邮件服务器信息 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023