并发与高并发线程池

c++ 11多线程总结(二):条件变量 多线程程序中当你不仅想要保护数据,还想对单独的线程进行同步。例如,在第一个线程完成前,可能需要等待另一个线程执行完成。 c++11标准库提供了一些工具可用于同步操作:条件变量(condition variables)和期望(futures)。 条件变量(condition variables)基本使用 条件变量使用包含在头文件 condition_variable 中,条件变量需要和unique_lock共同工作。 使用condition_variable: 基本成员函数:wait() , notify_o 阅读详情

前言

之前的例子中基本上都用到了线程池,一般我们都是把任务初始化好之后直接丢到线程池就可以了,使用起来非常简单方便。

主体概要

  • 线程池与new Thread对比
  • 线程池的几个类介绍
  • 线程池的几种状态
  • ThreadPoolExecutor的几个方法
  • 线程池的合理配置

主体内容

一、线程池与new Thread对比

new Thread弊端

1.每次new Thread都要新建一个对象,性能差。

2.线程缺少统一管理,可能无限制的新建线程,相互竞争,有可能占用过多系统资源导致死机或者OOM。

3.缺少更多功能,如更多执行、定期执行、线程中断。

所以,我们一般不常用Thread,这里就不再细讲了。

线程池好处

1.重用存在的线程,减少对象创建,消亡的开销,性能佳。

2.可有效的控制最大并发线程数,提高系统资源利用率,同时可以避免过多资源竞争,避免阻塞。

3.提供定时执行、定期执行、单线程、并发数控制等功能。

二、线程池的几个类介绍

1.ThreadPoolExecutor

我们来看看ThreadPoolExecutor可以接收的几个参数来做初始化。

(1)corePoolSize:核心线程数量

(2)maximumPoolSize:线程最大线程数

(3)workQueue:阻塞队列,存储等待执行的任务,很重要,会对线程池运行过程产生重大影响

(4)keepAliveTime:线程没有任务执行时最多保持多久时间终止(当线程池的线程数量大于corePoolSize,如果这时没有新的任务提交,核心线程不会立即销毁,而是让他等待,直到超过这里的keepAliveTime)

(5)unit:keepAliveTime的时间单位

(6)ThreadFactoryL:线程工厂,用来创建线程

(7)rejectHandler:当拒绝处理任务时的策略

如果运行的线程数少于我们的corePoolSize,直接创建新线程来处理任务,即使线程池中的其他线程是空闲的;

如果运行的线程数大于我们的corePoolSize,且小于我们的maximumPoolSize,则只有当workQueue满了的时候,才创建新的线程去处理任务;

如果我们设置的corePoolSize和maximumPoolSize相同的话,那么创建的线程池的大小是固定的,这个时候如果有新任务提交,并且workQueue没满的时候,就把请求放到workQueue里面,等待有空闲的线程来这个队列取出任务;

如果运行的线程数大于maximumPoolSize的时候,这时workQueue也已经满了,那么它就要指定我们后面要讲的指定策略参数来处理。

接下来我们详细介绍一下workQueue队列:

它是保存等待执行的任务的一个阻塞队列,当我们提交一个新的任务到线程池的时候,线程池会根据当前线程池中正在运行着的数量来决定该任务的处理方式,处理方式总共有三种:直接切换,无界队列,有界队列。直接切换就是之前提到的SynchronousQueue,使用的无界队列一般是使用链表队列-LinkedBlockingQueue,如果采用无界队列,线程池中能创建的最大线程数就是corePoolSize。我们这里介绍的workQueue的有界队列,一般是ArrayBlockingQueue,使用这种方式呢我们可以把线程池最大线程数目限制为maximumPoolSize。

详细介绍一下rejectHandler的四种策略:

如果workQueue阻塞队列满了,并且没有空闲的线程池,此时,继续提交任务,需要采取一种策略来处理这个任务。
线程池总共提供了四种策略:

  • 直接抛出异常,这也是默认的策略。实现类为AbortPolicy。
  • 用调用者所在的线程来执行任务。实现类为CallerRunsPolicy。、
  • 丢弃队列中最靠前的任务并执行当前任务。实现类为DiscardOldestPolicy。
  • 直接丢弃当前任务。实现类为DiscardPolicy。

三、线程池的几种状态

如图,线程池的5种状态转换如下:

 

分别来介绍一下这5种状态:

1、RUNNING

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

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

2、 SHUTDOWN

(1) 状态说明:线程池处在SHUTDOWN状态时,不接收新任务,但能处理阻塞队列中已添加的任务。 
(2) 状态切换:调用线程池的shutdown()接口时,线程池由RUNNING -> SHUTDOWN。

3、STOP

(1) 状态说明:线程池处在STOP状态时,不接收新任务,不处理阻塞队列中已添加的任务,并且会中断正在处理的任务。 
(2) 状态切换:调用线程池的shutdownNow()接口时,线程池由(RUNNING or SHUTDOWN ) -> STOP。

4、TIDYING

(1) 状态说明:当所有的任务已终止,ctl(ctl是对线程池的运行状态和线程池中有效线程的数量进行控制的一个字段, 它包含两部分的信息: 线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount))记录的”任务数量”为0,线程池会变为TIDYING状态。当线程池变为TIDYING状态时,会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的,若用户想在线程池变为TIDYING时,进行相应的处理;可以通过重载terminated()函数来实现。 
(2) 状态切换:当线程池在SHUTDOWN状态下,阻塞队列为空并且线程池中执行的任务也为空时,就会由 SHUTDOWN -> TIDYING。 
当线程池在STOP状态下,线程池中执行的任务为空时,就会由STOP -> TIDYING。

5、 TERMINATED

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

Linuxc/c++服务器开发高阶学习资料+群720209036获取

内容包括C/C++,Linux,Nginx,ZeroMQ,MySQL,Redis,MongoDB,ZK,流媒体,P2P,K8S,Docker,TCP/IP,协程,DPDK多个高级知识点。

 

 四、ThreadPoolExecutor的几个方法

1.基础方法

  • execute():提交任务,交给线程池执行
  • submit():提交任务,能够返回执行结果。(execute+Future)
  • shutdown():关闭线程池,等待任务都执行完
  • shutdownNow():关闭线程池,不等待任务执行完

2.监控方法

  • getTaskCount():线程池已执行和未执行的任务总数
  • getCompletedTaskCount():已完成的任务数量
  • getPoolSize():线程池当前的线程数量
  • getActiveCount():当前线程池中正在执行任务的线程数量

3.线程池类图

 

如图所示,J.U.C中有三个Executor接口:

  • Executor:一个运行新任务的简单接口;
  • ExecutorService:扩展了Executor接口。添加了一些用来管理执行器生命周期和任务生命周期的方法;
  • ScheduledExecutorService:扩展了ExecutorService。支持Future和定期执行任务。

而我们的ThreadPoolExecutor是功能最强大的,因为它可以自定义参数。

4.J.U.C框架是极其强大的,他还为我们提供了许多额外的方法

  • Executors.newCachedThreadPool():可以创建一个可缓存的线程池,如果线程池长度超过了处理的需要,可以灵活回收空闲线程;如果没有可以回收的,那么就新建线程。
  • Executors.newFixedThreadPool():它创建的是一个定长的线程池,可以控制线程的最大并发数,超出的线程会在队列中等待。
  • Executors.newScheduledThreadPool():它创建的也是一个定长的线程池,支持定时以及周期性的任务执行。
  • Executors.newSingleThreadPool():它创建的是一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指令顺序执行。

5 接下来我们分别对这几个方法做一个了解

(1)这是newCachedThreadPool的基本方法

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

还有一个可以传入指定的ThreadFactory参数

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

(2)这是newFixedThreadPool的基本方法

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

同样还有一个可以传入指定的ThreadFactory参数

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

(3)这是newScheduledThreadPool的基本方法

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

同样的,可以传入指定的threadFactory参数

 public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }
 public ScheduledThreadPoolExecutor(int corePoolSize,
                                       RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), handler);
    }

(4)这是newSingleThreadExecutor的基本方法

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

同样的,也可以传入指定的threadFactory参数

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

需要注意的是,他们返回值都是ExecutorService对象,而非ThreadPoolExecutor对象,因此缺少监控方法和部分基本方法,只有shutdown(),submit(),shutdownNow()基本方法,这是ExecutorService的局限性。

6.最后,分别演示一下代码例子

(1)newCachedThreadPool

mport lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Slf4j
public class ThreadPoolExample1 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        for(int i=0;i<10;i++){
            final int index = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("task:{}",index);
                }
            });
        }
        executorService.shutdown();
    }
}

结果:

21:52:22.217 [pool-1-thread-2] INFO com.practice.aqs.ThreadPoolExample1 - task:1
21:52:22.217 [pool-1-thread-4] INFO com.practice.aqs.ThreadPoolExample1 - task:3
21:52:22.217 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample1 - task:0
21:52:22.217 [pool-1-thread-8] INFO com.practice.aqs.ThreadPoolExample1 - task:7
21:52:22.217 [pool-1-thread-6] INFO com.practice.aqs.ThreadPoolExample1 - task:5
21:52:22.217 [pool-1-thread-5] INFO com.practice.aqs.ThreadPoolExample1 - task:4
21:52:22.217 [pool-1-thread-7] INFO com.practice.aqs.ThreadPoolExample1 - task:6
21:52:22.217 [pool-1-thread-10] INFO com.practice.aqs.ThreadPoolExample1 - task:9
21:52:22.217 [pool-1-thread-9] INFO com.practice.aqs.ThreadPoolExample1 - task:8
21:52:22.217 [pool-1-thread-3] INFO com.practice.aqs.ThreadPoolExample1 - task:2

(2)

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class ThreadPoolExample2 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for(int i=0;i<10;i++){
            final int index = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("task:{}",index);
                }
            });
        }
        executorService.shutdown();
    }
}

结果:

21:55:17.350 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample2 - task:0
21:55:17.350 [pool-1-thread-2] INFO com.practice.aqs.ThreadPoolExample2 - task:1
21:55:17.350 [pool-1-thread-3] INFO com.practice.aqs.ThreadPoolExample2 - task:2
21:55:17.354 [pool-1-thread-3] INFO com.practice.aqs.ThreadPoolExample2 - task:5
21:55:17.354 [pool-1-thread-2] INFO com.practice.aqs.ThreadPoolExample2 - task:4
21:55:17.354 [pool-1-thread-3] INFO com.practice.aqs.ThreadPoolExample2 - task:6
21:55:17.354 [pool-1-thread-3] INFO com.practice.aqs.ThreadPoolExample2 - task:8
21:55:17.354 [pool-1-thread-2] INFO com.practice.aqs.ThreadPoolExample2 - task:7
21:55:17.354 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample2 - task:3
21:55:17.354 [pool-1-thread-3] INFO com.practice.aqs.ThreadPoolExample2 - task:9

(3)newSingleThreadExecutor

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class ThreadPoolExample3 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        for(int i=0;i<10;i++){
            final int index = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("task:{}",index);
                }
            });
        }
        executorService.shutdown();
    }
}

结果:

21:57:01.913 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:0
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:1
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:2
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:3
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:4
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:5
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:6
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:7
21:57:01.916 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:8
21:57:01.917 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample3 - task:9

(4)newScheduledThreadPool(注意:返回值与以上不同)

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadPoolExample4 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                log.info("schedule run");
            }
        },3, TimeUnit.SECONDS);//延时3秒执行该输出任务
        scheduledExecutorService.shutdown();
    }
}

结果(这个结果是延时3秒出来的):

22:03:22.303 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample4 - schedule run

Process finished with exit code 0

除了schedule()方法,他还有scheduleAtFixedRate(以指定的速率去执行任务),scheduleWithFixedDelay(以指定的一个延迟执行任务)

先说scheduleAtFixedRate

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Slf4j
public class ThreadPoolExample4 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

     
       scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
           @Override
           public void run() {
               log.info("schedule run");
           }
       },1,3,TimeUnit.SECONDS);//延迟一秒,每隔3秒执行一次任务
    }
}

结果(注意观察时间间隔):

22:10:22.168 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample4 - schedule run
22:10:25.168 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample4 - schedule run
22:10:28.168 [pool-1-thread-2] INFO com.practice.aqs.ThreadPoolExample4 - schedule run
22:10:31.168 [pool-1-thread-1] INFO com.practice.aqs.ThreadPoolExample4 - schedule run
22:10:34.167 [pool-1-thread-3] INFO com.practice.aqs.ThreadPoolExample4 - schedule run

五、线程池的合理配置

1.CPU密集型

尽量使用较小的线程池,一般Cpu核心数+1

因为CPU密集型任务CPU的使用率很高,若开过多的线程,只能增加线程上下文的切换次数,带来额外的开销

2.IO密集型

方法一:可以使用较大的线程池,一般CPU核心数 * 2

IO密集型CPU使用率不高,可以让CPU等待IO的时候处理别的任务,充分利用cpu时间

方法二:线程等待时间所占比例越高,需要越多线程。线程CPU时间所占比例越高,需要越少线程。
下面举个例子:
比如平均每个线程CPU运行时间为0.5s,而线程等待时间(非CPU运行时间,比如IO)为1.5s,CPU核心数为8,那么根据上面这个公式估算得到:((0.5+1.5)/0.5)*8=32。这个公式进一步转化为:
最佳线程数目 = (线程等待时间与线程CPU时间之比 + 1)* CPU数目

3、混合型

可以将任务分为CPU密集型和IO密集型,然后分别使用不同的线程池去处理,按情况而定。

有三个线程T1,T2,T3,如何保证顺序执行? 阅读详情

相关推荐

Java 多线程并发实战:巧用线程池与锁机制,攻克高并发下资源争抢难题

在高并发的系统中,线程池的合理配置和锁机制的选择是保障系统稳定性和性能的关键。通过合理使用线程池、选择合适的锁机制(如和CAS),并结合电商秒杀、抢票等业务场景中的并发控制技术,我们可以有效地应对资源争抢带来的挑战。无论是通过线程池优化系统资源的利用,还是通过锁机制确保数据一致性,在高并发环境下,合理的设计和优化是系统性能的保证。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1880

Java - JUC详解

一、概述 1.1 什么是JUC? JUC是java.util.concurrent包的简称,在Java5.0添加,目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题! 1.2 什么是进程? 程序由指令和数据组成,但这些指令要运行,数据要读写,就必须将指令加载至CPU,数据加载至内存。在指令运行过程中还要用到磁盘、网络等设备。进程就是用来加载指令,管理内存管理IO的。 当一个进程被运行,从磁盘加载这个程序的代码至内存,这时就开启了一个进程。 进程就可以视为一个实例。

S mile0804的博客 6790

线程池任务丢失与幂等性保证:构建健壮的高并发系统

在高并发系统中,线程池(Thread Pool)是用于高效管理和复用线程资源的关键组件。然而,线程池本身是基于内存的,一旦服务重启,线程池中的任务(无论是正在执行还是待执行的)都会丢失。这对于需要确保任务不丢失的系统来说,尤其是在处理关键业务流程(如订单生成、支付处理等)时,可能导致严重的问题。因此,如何在服务重启后保证线程池中的数据不丢失,是一个需要谨慎解决的挑战。

jsjbrdzhh的博客 1493

17_juc

Java JUC简介 在 Java 5.0 提供了 java.util.concurrent (简称 JUC )包,在此包中增加了在并发编程中很常用 的实用工具类,用于定义类似于线程的自定义子 系统,包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。 volatile关键字-内存可见性 概述 内存可见性(Memory Visibility)是指当某个线程正在使用对象状态 而另一个线程在同时修改该状态,需要确保当一个

海涛帅帅的博客 593

C++多线程:线程创建、等待和异步处理

通过使用C++多线程,我们可以充分利用多核处理器的能力,提高程序的性能和响应能力。通过适当地使用多线程,我们可以将任务并行化,提高程序的效率。然而,在使用多线程时需要注意线程同步和资源竞争的问题,确保线程安全性。在C++中,多线程编程是一种常见的技术,可以提高程序的性能和响应能力。通过使用多线程,我们可以同时执行多个任务,从而充分利用多核处理器的能力。需要注意的是,分离线程后我们无法等待它的完成,因此在使用。在上面的示例代码中,异步任务执行了一个模拟的耗时任务,通过。在上面的代码中,我们定义了一个。

DarcyCode的博客 279

C++高并发服务器开发:线程池与epoll多路复用实战

在现代网络服务中,面对成千上万的并发连接请求,传统的单线程阻塞式I/O模型已无法胜任高性能需求。高并发服务器通常采用多线程I/O多路复用(如epoll)等核心技术,以提升吞吐能力和响应效率。其中,线程池用于管理并发线程资源,避免频繁创建销毁线程的开销;而epoll则实现了高效的I/O事件监听机制,支持同时处理大量连接。本章将围绕这些关键技术展开讲解,为后续章节中C++实现高性能服务器打下坚实基础。

weixin_36204513的博客 1369

Java并发编程实战线程池优化与高并发场景解决方案

注意:在Spring Boot等框架中,线程池配置应优先使用`@Bean`形式集中管理,避免单点配置混乱。| `CachedThreadPool` | 短暂任务 | 线程自动复用,无队列直接分配线程 || `FixedThreadPool` | 稳定负载场景 | 固定线程数,默认队列无限大 |// 公式:线程数 = (有效CPU核心数 × (1 + W/C))// CPU密集型 → 有界队列,队列容量 = N线程数 × 3。| QPS(订单吞吐) | 8,500 | 23,600 |

WEiDsjyC的博客 1181

常见的AXI总线仲裁器概述-AXI协议理解(一)

SoC 设计广泛采用共享总线式的片上通信,其中的仲裁器是共享总线的关键技术之一。AMBA AXI 总线协议以高性能、高频率的系统设计为目标,适合高带宽、低延迟的系统设计,可以达到高频率的操作而不需要复杂的总线桥,满足众多部件的接口要求,具备高度灵活的互联结构,并且向后兼容 AHB 和 APB 接口。

Paul 安的博客 1万+

常见线程池详解:适用场景与CachedThreadPool的高并发风险

摘要:Java线程池的选择需根据业务场景权衡。FixedThreadPool适合稳定负载但存在OOM风险;CachedThreadPool弹性伸缩但高并发下会无限创建线程,导致内存/CPU耗尽;ScheduledThreadPool支持定时任务;SingleThreadExecutor保证顺序执行。高并发场景推荐自定义ThreadPoolExecutor,控制线程数和队列容量,避免使用Executors默认实现的风险。(149字)

weixin_43076660的博客 880

简单的图书管理系统---SpringBoot+mysql通过前后端分离实现增删查改

SpringBoot+mysql通过前后端分离实现增删查改 上篇文章介绍了如何写后端接口 SpringBoot连接MySQL获取数据写后端接口 这篇文章,我们就介绍一下怎么写前端 点击修改跳出修改界面,点击添加书籍跳出添加书籍界面 点击删除,直接删除一行数据 其他的也没什么解释了,直接上代码(看不懂的可以私聊我哟) <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>

爱笑的博客 2015

数据安全实战技能解析:从加密攻防到数字水印的竞赛指南

数据安全是信息安全领域的核心,其基础在于密码学与信息隐藏技术。密码学通过加密算法(如AES、RSA)和哈希函数,保障数据的机密性与完整性,其原理涉及对称/非对称加密、工作模式及密钥管理。数字水印技术则基于信号处理(如DCT/DWT变换),将信息嵌入多媒体载体,用于版权保护与溯源。这些技术的价值在于为数据全生命周期提供“防泄漏”与“可追溯”的解决方案,广泛应用于企业数据治理、合规审计和**数据防泄漏(DLP)** 系统。本文以一场贴近实战的**数据安全职业技能竞赛**为切入点,深入剖析如何运用密码分析、磁盘取

weixin_34314962的博客 403

【Java并发请求处理方案】:揭秘高并发场景下的线程池优化与异步处理实战

掌握高效Java并发请求处理方案,提升系统吞吐量与响应速度。适用于高并发Web服务场景,结合线程池优化、异步编程与CompletableFuture实战,有效降低资源消耗。性能提升显著,值得收藏。

LiteTrans的博客 1030

从毫K级温控到分子级洁净:光刻机环境控制系统的技术演进与专利格局

摘要 光刻机环境控制系统是半导体制造中的"隐形精密工程",通过毫K级温度控制(±0.002℃)、超高洁净度(ISO Class 1)等核心技术为纳米级光刻提供环境保障。本文系统分析了温度、湿度、洁净度、流场和压力控制五大技术方向的发展趋势,揭示了从单参数控制向多参数协同智能控制的转型路径。研究显示:1)温度控制正从PID向神经网络智能控制演进;2)EUV光刻将湿度控制推至ppbv级;3)洁净度控制扩展到分子级污染物管理。头部厂商中,ASML侧重系统集成,Nikon专注浸没流场,Canon

huanghm88的专栏 324

高并发Java架构设计中的线程池与异步任务优化

通过合理配置线程池和优化异步任务,Java应用可以在高并发场景下实现良好的性能和响应速度。了解线程池的工作原理和配置方式是每个Java架构师的必备技能。只有通过不断的监控与调整,才能保证系统的高可用性和稳定性。本文著作权归聚娃科技微赚淘客系统开发者团队,转载请注明出处!

微赚淘客系统开发者博客 1107

11、牛转录组分析的实用生物信息学流程

本文详细介绍了一套实用的牛转录组分析生物信息学流程,涵盖从数据提取、基因组索引生成、读取比对到单样本表达分析及差异表达分析的完整步骤。使用Angus和Brahman牛的RNA-seq数据作为示例,介绍了HTSEQ、featureCounts和StringTie等工具在基因表达计数中的应用,并结合edgeR和limma进行差异表达分析。文中提供了详细的命令行与R代码示例,包含常见问题解答与关键注意事项,帮助研究人员高效、准确地完成转录组数据分析。

ios99的博客 112

【系统架构设计师】论文:论虚拟现实技术的应用与发展

虚拟现实技术是当前科学研究的热点,同时也是国家大力支持发展的核心技术之一。所谓虚拟现实,就是通过计算机等虚拟手段来构造一个非常接近真实世界的虚拟环境,它主要体现在视觉、触觉、嗅觉等方面的逼真模拟来达到高度的沉浸性,也就是如我们通常所说的“身临其境”。

数据知道的博客 1万+

关于高并发与多线程中的线程池

关于高并发与多线程中的线程池 定义 线程是稀缺资源,它的创建与销毁是一个相对偏重且耗资源的操作,而Java线程依赖于内核线程,创建线程需要进行操作系统状态切换,为避免资源过度消耗需要设法重用线程执行多个任务。线程池就是一个线程缓存,负责对线程进行统一分配、调优与监控。 什么时候使用线程池: 单个任务处理时间比较短 需要处理的任务数比较大 线程池的优势: 重用存在的线程,减少线程创建,消亡的开销,提高性能 提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。 提高线程的可管理性,可统一

我是个小佬 610

功能安全实战系列12-英飞凌TC3xx锁步核及其自检开发

本文介绍了英飞凌Tricore系列芯片的锁步核(Lockstep Core)功能及其故障注入自检机制。锁步核通过主核和检查核同步执行指令,并比较输出结果来检测硬件故障。文章详细阐述了锁步核的工作原理、使能配置方法以及故障注入自检的实现过程。故障注入测试通过专用寄存器LCLTEST触发,系统会定期自动测试比较器节点,验证锁步核的故障检测能力。当检测到异常时,会触发SMU模块的警报机制。该技术为汽车电子系统提供了重要的功能安全保障。

initiallizer的博客 923

多线程与高并发编程(七)【线程池一】

多线程与高并发编程(七)【线程池一】一、线程池前置1. Executor接口 executor()2. ExecutorSevice接口,定义了很多线程池的生命周期的方法3. Callable接口(定义了call()),类似runnable,是一个任务,但是相比runnable中的run()多了个返回值。4. Future接口,承接ExecutorService方法中的返回值,是一个结果5. Fu...

qq_36268025的博客 811

实战二:基于LightGBM进行海洋轨迹预测 代码+数据(非常详细可作为毕设)

实战二:基于LightGBM进行海洋轨迹预测 代码+数据(非常详细可作为毕设)

1319

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

JAVA并发编程与高并发解决方案 - 并发编程 六 之 线程池

JAVA并发编程与高并发解决方案 - 并发编程 六 版本 作者 内容 2018.7.4 chuIllusions 线程池 线程池   在前面使用的例子用,我们已经使用过线程池,基本上就是初始化线程池实例之后,把任务丢进去,等待调度执行就可以了,使用起来非常简单、方便。虽然使用很简单,但线程池涉及到的知识点非常多。需要分析其实现。   JAVA中...

chuIllusions 的 博客 1240

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

Tomcat线程池深度优化指南:高并发场景下的maxConnections计算与监控体系

Tomcat线程池深度优化指南:高并发场景下的maxConnections计算与监控体系通过本指南的系统化配置,Tomcat线程池可稳定支撑数万并发连接,建议结合业务场景定期进行压力测试验证。

夜雨的博客 1168

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

看完这篇还不懂高并发中的线程与线程池你来打我

从这篇开始将会开启高性能、高并发系列,本篇是该系列的开篇,主要关注多线程以及线程池。 一切要从CPU说起 你可能会有疑问,讲多线程为什么要从CPU说起呢?原因很简单,在这里没有那些时髦的概念,你可以更加清晰的看清问题的本质。 CPU并不知道线程、进程之类的概念。 CPU只知道两件事: 1. 从内存中取出指令 2. 执行指令,然后回到1 你看,在这里CPU确实是不知道什么进程、线程之类的概念。 接下来的问题就是CPU从哪里取出指令呢?答案是来自一个被称为...

码农的荒岛求生 1220

Java高并发实战分布式锁与线程池优化指南

Redisson的`RLock`组件自动管理分布式锁,支持:`watchdog`监控锁超时自动回收、多节点竞争时的LZF均衡算法、基于RedLock模式的耐过载设计。核心特性包含:唯一性(同一时刻仅一个持有者)、无死锁、高性能开销、失效自动释放。典型实现使用Redis的`SETNX`+`EXPIRE`原子命令组合,避免超时失效后锁未手动释放。分布式锁需满足原子性、零丢失、可重入性等特性,同步需跨越多节点环境。- JVM的线程阻塞堆栈(通过`jstack`分析死锁倾向)- 分布式锁的获取失败率、平均延迟。

HzEuzbqf的博客 316

美团动态线程池设计与高并发优化实践

线程池作为Java并发编程的核心组件,其本质是通过线程复用降低资源消耗。传统固定参数线程池存在突发流量应对不足、资源利用率低下等痛点,动态线程池技术应运而生。通过实时监控线程活跃度、队列负载等指标,结合PID控制算法实现参数的弹性伸缩,可显著提升系统吞吐量。在高并发场景如秒杀系统中,动态线程池与本地缓存组合使用,既能实现流量削峰,又能避免资源浪费。美团技术团队通过改良的PID算法和智能拒绝策略,使线程池QPS提升54%,同时保持零请求拒绝。该方案已广泛应用于电商大促、金融交易等高并发场景,是构建弹性分布式系

weixin_30984001的博客 275

【[Java]并发编程实战深入剖析线程池与锁优化在高并发场景的落地实践】

自定义核心线程数与最大线程数:根据业务吞吐量与任务耗时设置`corePoolSize`和`maxPoolSize`。例如,对于CPU密集型任务,可设`corePoolSize = CPU核心数`。- 动态调整线程池:结合监控指标(如线程池活跃数、队列延迟),通过`ThreadPoolExecutor.setCorePoolSize()`实现弹性扩缩容。2. 锁竞争分析:通过`jstack`分析线程堆栈,结合`perf record -e sync:hostBlocked`定位热点锁。

LrpDiXTA的博客 469
上一篇: 【Linux后台开发系列】Nginx源码从模块开发开始,不再对nginx源码陌生丨源码分析
下一篇: 红黑树在linux中的3种应用场景,听完受益匪浅
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值