ThreadPoolExecutor原理解析

news2024/11/25 8:19:45

1. 工作原理

1.1 流程图

1.2 执行示意图

从上图得知

  • 如果当前运行的线程数小于corePoolSize(核心线程数)，则会创建新线程作为核心线程来执行任务(注意，执行这一步需要获取全局锁)。

  • 如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue中。

  • 如果无法将任务加入BlockingQueue(队列已满)，则将创建线程来执行任务(注意，执行这一步骤需要获取全局锁)。

  • 如果第三步创建线程使得当前线程数大于maximumPoolSize，任务将被拒绝，并调用RejectdExecutionHandler.rejectedExecution()方法。

2. 源码解析

2.1 核心参数

  • corePoolSize 核心线程数，池中所保存的线程数，包括空闲线程。

  • maximumPoolSize 线程池最大容量，在核心线程数的基础上可能会额外增加一些非核心线程，需要注意的是只有当workQueue队列填满时才会创建多于corePoolSize的线程(线程池总线程数不超过maxPoolSize)

  • workQueue 用于保存任务的队列

  • SynchronousQueue 线性安全、capacity是0不存储任何元素、可以在两个线程中传递同一个对象。synchronousQueue.put(object);synchronousQueue.take();如果不希望任务在队列中等待而是希望将任务直接移交给工作线程，可使用SynchronousQueue作为等待队列。

  • LinkedBlockingQueue 链式队列，队列容量不足或为0时自动阻塞。锁是分离的，高并发的情况下生产者和消费者可以并行地操作队列中的数据，可以提高吞吐量。当QPS很高，发送数据很大，大量的任务被添加到这个无界LinkedBlockingQueue 中，导致cpu和内存飙升服务器挂掉。

  • ArrayBlockingQueue 数组实现的有界队列，使用独占锁，生产者和消费者无法并行操作，在高并发场景下会成为性能瓶颈。

  • PriorityBlockingQueue PriorityBlockingQueue中的优先级由任务的Comparator决定。

  • keepAliveTime 空闲线程的存活时间 当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize。如果allowCoreThreadTimeout=true，则会直到线程数量=0。

  • threadFactory 线程工厂 默认DefaultThreadFactory 创建同样分组(ThreadGroup) 同样优先级(NORM_PRIORITY) non-daemon的线程。

  • handler 拒绝策略处理 默认AbortPolicy 抛异常RejectedExecutionException

  • AbortPolicy：不执行该任务，并抛出RejectedExecutionException异常。

  • CallerRunsPolicy：由调用线程处理该任务，如果执行程序已关闭，则会丢弃该任务。

  • DiscardOldestPolicy：丢弃队列中最老的一个任务，然后重新尝试执行任务(重复此过程。

  • DiscardPolicy：不执行该任务，也不抛异常。

2.2 线程池状态

2.2.1 线程池状态

成员变量ctl是Integer的原子变量，使用一个变量同时记录线程池状态和线程池中线程个数，假设计算机硬件的Integer类型是32位二进制标示，如下面代码所示，其中高3位用来表示线程池状态，后面29位用来记录线程池线程个数。

//线程个数掩码位数，并不是所有平台int类型是32位，所以准确说是具体平台下Integer的二进制位数-3后的剩余位数才是线程的个数

private static final int COUNT_BITS = Integer.SIZE - 3;
//线程最大个数(低29位)00011111111111111111111111111111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
//（高3位）：11100000000000000000000000000000
private static final int RUNNING = -1 << COUNT_BITS;
//（高3位）：00000000000000000000000000000000
private static final int SHUTDOWN = 0 << COUNT_BITS;
//（高3位）：00100000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
//（高3位）：01000000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
//（高3位）：01100000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;
获取线程池的运行状态和线程池中的线程个数
// 获取高三位 运行状态
private static int runStateOf(int c) { return c & ~CAPACITY; }
//获取低29位 线程个数
private static int workerCountOf(int c) { return c & CAPACITY; }
//计算ctl新值，线程状态 与 线程个数
private static int ctlOf(int rs, int wc) { return rs | wc; }

2.2.2 线程池状态含义：

  • RUNNING：接收新任务并且处理阻塞队列里的任务。

  • SHUTDOWN：拒绝新任务但是处理阻塞队列里的任务。

  • STOP：拒绝新任务并且抛弃阻塞队列里的任务，同时中断正在处理的任务。

  • TIDYING：所有任务都执行完（包含阻塞队列里面任务），当前线程池活动线程为0，将要调用terminated方法。

  • TERMINATED：终止状态。terminated方法调用完成以后的状态。

2.3 执行方法

2.3.1 线程池中任务提交方法

execute()方法
public void execute(Runnable command) {
    //(1) 如果任务为null，则抛出NPE异常
    if (command == null)
        throw new NullPointerException();

    //（2）获取当前线程池的状态+线程个数变量的组合值
    int c = ctl.get();
    //（3）当前线程池线程个数是否小于corePoolSize,小于则开启新线程运行
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    //（4）如果线程池处于RUNNING状态，则添加任务到阻塞队列
    if (isRunning(c) && workQueue.offer(command)) {
        //（4.1）二次检查
        int recheck = ctl.get();
        //（4.2）如果当前线程池状态不是RUNNING则从队列删除任务，并执行拒绝策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
            //（4.3）如果当前线程池线程为空，则添加一个线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //（5）如果队列满了，则新增线程，新增失败则执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}
submit(Runnable task)方法
public Future<?> submit(Runnable task) {
    // 6 NPE判断
    if (task == null) throw new NullPointerException();
    // 7 包装任务为FutureTask
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    // 8 投递到线程池执行
    execute(ftask);
    // 9 返回ftask
    return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

public FutureTask(Runnable runnable, V result) {
    //将runnable适配为Callable类型任务，并且让result作为执行结果
    this.callable = Executors.callable(runnable, result);
    this.state = NEW; // ensure visibility of callable
}
submit(Runnable task，T result)方法
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

2.3.2 线程池中任务执行方法

当用户线程提交任务到线程池后，在线程池没有执行拒绝策略的情况下，用户线 程会马上返回，而提交的任务要么直接切换到线程池中的Worker线程来执行，要么先放入线程池的阻塞队列里面，稍后再由Worker线程来执行。

Worker(Runnable firstTask) {
    // 在调用runWorker前禁止中断 避免当前Worker在调用runWorker方法前被中断（当其他线程调用了线程池的shutdownNow时，如果Worker状态≥0则会中断该线程）。status=0标示锁未被获取的状态，state=1标示锁已经被获取的状态，state=–1是创建Worker时默认的状态。
    setState(-1);
    this.firstTask = firstTask;
    //使用线程池中指定的线程池工厂创建一个线程作为该Worker对象的执行线程
    this.thread = getThreadFactory().newThread(this);
}

public void run() {
    runWorker(this);//委托给runWorker方法
}

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    //(1)status设置为0，允许中断。这时候调用shutdownNow会中断Worker线程。
    w.unlock();
    boolean completedAbruptly = true;
    try {
        //(2)当前task==null或者调用getTask从任务队列获取的任务返回null
        while (task != null || (task = getTask()) != null) {
            //(2.1)获取工作线程内部持有的独占锁
            w.lock();
            ...
            try {
                //(2.2)任务执行前干一些事情
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    //(2.3)执行任务
                    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 {
                    //(2.4)任务执行完毕后干一些事情
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                //(2.5)统计当前Worker完成了多少个任务
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        //(3)执行清工作
        processWorkerExit(w, completedAbruptly);
    }
}

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    ...
    //(3.1)统计整个线程池完成的任务个数,并从工作集里面删除当前woker 加全局锁
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
    //(3.2)如果当前线程池状态是shutdown状态并且工作队列为空，或者当前是
    stop状态并且当前线程池里面没有活动线程，则设置线程池状态为TERMINATED。
    tryTerminate();
    //(3.3)判断当前线程中的线程个数是否小于核心线程个数，如果是则新增一个线程。
    int c = ctl.get();
    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);
    }
}

2.3.3 线程池关闭方法

shutdown()方法

调用 shutdown后,线程池就不会再接收新的任务,但是工作队列里面的任务还是要执行的,该方法是立刻返回的,并不同步等待队列任务完成再返回。

首先使用CAS设置当前线程池状态为TIDYING，如果成功则执行扩展接口terminated在线程池状态变为TERMINATED前做一些事情，然后设置当前 线程池状态为TERMINATED，最后调用termination.signalAll()来激活调用线程池的 awaitTermination系列方法被阻塞的所有线程。

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //(1)权限检查如果设置了安全管理器，则看当前调用shutdown命令的线程是否有关闭线程的权限，如果有权限则还要看调用线程是否有中断工作线程的权限，如果没有权限则抛出SecurityException或者NullPointerException异常。
        checkShutdownAccess();
        //(2)设置当前线程池状态为SHUTDOWN，如果已经是SHUTDOWN则直接返回
        advanceRunState(SHUTDOWN);
        //(3)设置中断标志。这里首先加了全局锁，同时只有一个线程可以调用shutdown设置中断标志。然后尝试获取Worker本身的锁，获取成功则设置中断标识，由于正在执行的任务已经获取了锁，所以正在执行的任务没有被中断。这里中断的是阻塞到getTask()方法，企图从队列里获取任务的线程，也就是空闲线程。
        interruptIdleWorkers();
        onShutdown();
    } finally {
        mainLock.unlock();
    }
    //(4)尝试状态变为TERMINATED
    tryTerminate();
}

private void advanceRunState(int targetState) {
    for (;;) {
        int c = ctl.get();
        if (runStateAtLeast(c, targetState) ||
                ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}

private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            //如果工作线程没有被中断，并且没有正在运行则设置中断
            if (!t.isInterrupted() && w.tryLock()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}

final void tryTerminate() {
    for (;;) {
...
        int c = ctl.get();
...

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {//设置当前线程池状态为TIDYING
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    terminated();
                } finally {
                    //设置当前线程池状态为TERMINATED
                    ctl.set(ctlOf(TERMINATED, 0));
                    //激活调用条件变量termination的await系列方法被阻塞的所有线程
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
    }
}

shutdownNow()方法

调用 shutdownnow后,线程池就不会再接收新的任务,并且会丢弃工作队列里面的任务,正在执行的任务也会被中断,该方法是立刻返回的,并不同步等待激活的任务执行完成再返回。

调用线程池队列的drainTo方法把队列中的任务移除到taskList 里，如果发现线程池队列还不为空（比如DelayQueue或者其他类型的队列drainTo可能 移除元素失败），则循环移除里面的元素，最后返回移除的任务列表。

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //（5)权限检查
        checkShutdownAccess();
        //(6) 设置线程池状态为stop
        advanceRunState(STOP);
        //(7)中断所有线程，这里需要注意的是中断所有线程，包含空闲线程和正在执行任务的线程
        interruptWorkers();
        //（8）移动队列任务到tasks
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    //(9)终止状态
    tryTerminate();
    return tasks;
}

private void interruptWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)
            w.interruptIfStarted();
    } finally {
        mainLock.unlock();
    }
}

private List<Runnable> drainQueue() {
    //8.1获取任务队列
    BlockingQueue<Runnable> q = workQueue;
    ArrayList<Runnable> taskList = new ArrayList<Runnable>();
    //8.2 从任务队列移除任务到taskList列表
    q.drainTo(taskList);
    //8.3 如果q还不为空，则说明drainTo接口调用失效，则循环移除
    if (!q.isEmpty()) {
        for (Runnable r : q.toArray(new Runnable[0])) {
            if (q.remove(r))
                taskList.add(r);
        }
    }
    //8.4返回异常的任务列表
    return taskList;
}

2.4 参数优化

2.4.1 默认值

corePoolSize = 1
maxPoolSize = Integer.MAX_VALUE
queueCapacity = Integer.MAX_VALUE
keepAliveTime = 60s
allowCoreThreadTimeout = false
rejectedExecutionHandler = AbortPolicy()

需要根据几个值来决定

tasks ：每秒的任务数，假设为500~1000

taskcost：每个任务花费时间，假设为0.1s

responsetime：系统允许容忍的最大响应时间，假设为1s

corePoolSize

corePoolSize = 每秒需要多少个线程处理？

threadcount = tasks/(1/taskcost) = taskstaskcout = (500 ~ 1000)0.1 = 50~100 个线程。

corePoolSize设置应该大于50。根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80。

queueCapacity

队列容量 queueCapacity = (coreSizePool/taskcost)*responsetime

切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时,

不能新开线程来执行，响应时间会随之陡增。

maxPoolSize

最大线程数在生产环境上我们往往设置成corePoolSize一样，这样可以减少在处理过程中创建线程的开销。

rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理。

keepAliveTime和allowCoreThreadTimeout采用默认通常能满足。

2.4.2 参考值

@Configuration
public class ConcurrentThreadGlobalConfig {
    @Bean
    public ThreadPoolTaskExecutor defaultThreadPool() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程数目
        executor.setCorePoolSize(65);
        //指定最大线程数
        executor.setMaxPoolSize(65);
        //队列中最大的数目
        executor.setQueueCapacity(650);
        //线程名称前缀
        executor.setThreadNamePrefix("DefaultThreadPool_");
        //rejection-policy：当pool已经达到max size的时候，如何处理新任务
        //CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
        //对拒绝task的处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //线程空闲后的最大存活时间
        executor.setKeepAliveSeconds(60);
        //加载
        executor.initialize();
        return executor;
    }
}

以上

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

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

相关文章

C语言const的用法详解

C语言const的用法详解

有时候我们希望定义这样一种变量&#xff0c;它的值不能被改变&#xff0c;在整个作用域中都保持固定。例如&#xff0c;用一个变量来表示班级的最大人数&#xff0c;或者表示缓冲区的大小。为了满足这一要求&#xff0c;可以使用const关键字对变量加以限定&#xff1a;constin…
阅读更多...
大型智慧校园系统源码 智慧班牌 智慧安防 家校互联 智慧校园小程序源码

大型智慧校园系统源码 智慧班牌 智慧安防 家校互联 智慧校园小程序源码

一款针对中小学研发的智慧校园系统源码&#xff0c;智慧学校源码&#xff0c;系统有演示&#xff0c;可正常上线运营正版授权。 技术架构&#xff1a; 后端&#xff1a;Java 框架&#xff1a;springboot 前端页面&#xff1a;vue element-ui 小程序&#xff1a;小程序原生…
阅读更多...
【CDP】CDP集群修改solr 存储路径 引发组件的ranger-audit 大量报错的解决方案

【CDP】CDP集群修改solr 存储路径 引发组件的ranger-audit 大量报错的解决方案

前言 我们生产上公司是使用的CDP集群&#xff0c;一次管理员通知&#xff0c;Solr 组件的数据存放路径磁盘空间不够。 我们的solr 组件时为 Ranger 服务提供日志审计功能&#xff0c; 在我们更改了磁盘路径&#xff0c;并重启了Solr 组件&#xff0c;然后发现相关组件&#…
阅读更多...
立创eda专业版学习笔记（6）（pcb板移动节点）

立创eda专业版学习笔记（6）（pcb板移动节点）

先要看一个设置方面的东西&#xff1a; 进入设置-pcb-通用 我鼠标放到竖着的线上面&#xff0c;第一次点左键是这样选中的&#xff1a; 再点一次左键是这样选中的&#xff1a; 这个时候&#xff0c;把鼠标放到转角的地方&#xff0c;点右键&#xff0c;就会出现对于节点的选项…
阅读更多...
关于VSCode安装go插件问题

关于VSCode安装go插件问题

比较常见的go开发编辑工具有VSCode、GoLand等&#xff0c;其中&#xff0c;使用VSCode需要下载相关的go语言插件。但是大多数情况都会下载失败&#xff0c;因为有些资源需要翻墙的原因&#xff0c;有时候翻墙了还是会报错。   本文将介绍一种帮助大家成功下载go插件的方法&am…
阅读更多...
流水线使用（测试-＞构建-＞部署上线）

流水线使用（测试-＞构建-＞部署上线）

流水线介绍&#xff08;可直接查阅云效中流水线介绍&#xff09; 流水线在项目中的使用 1、选择我的流水线—>新建流水线 2、选择流水线模板&#xff08;可以根据需求选择不同模板&#xff09; 3、流水线配置 ①选择代码源&#xff1a;我目前展示的是直接使用codeup中的代码…
阅读更多...
apipost-一键压测

apipost-一键压测

apipost新功能可实现一键压测接口压测实践使用场景对指定接口进行性能测试。实现方式为实现高性能的并发需求&#xff0c;使用自研的压测引擎&#xff0c;可以实现一万以上并发。项目已经开源&#xff0c;github地址&#xff1a;https://github.com/Apipost-Team/runnerGo压测结…
阅读更多...
antd日期组件时间范围动态跟随

antd日期组件时间范围动态跟随

这周遇到了一个很诡异但又很合理的需求。掉了一周头发&#xff0c;死了很多脑细胞终于上线了。必须总结一下&#xff0c;不然对不起自己哈哈哈。 一、需求描述 默认当前日期时间不可清空。 功能 默认时间如下&#xff1a; 目的&#xff1a;将时间改为 2014-08-01 ~ 2014-08…
阅读更多...
网络工程师测试命令排行榜，快来看一看吧！ -ccie网络工程师

网络工程师测试命令排行榜，快来看一看吧！ -ccie网络工程师

网络工程师测试命令排行榜&#xff0c;快来看一看吧&#xff01; 01 Ping命令 ping命令的主要功能是用来检测网络的连通情况和分析网络运行速度。它是基于TCP/IP协议、通过发送和接收数据包来检测两台计算机间的连接状况。 网络工程师用 ping查看网络情况&#xff0c;主要…
阅读更多...
【无标题】tcpdump 命令

【无标题】tcpdump 命令

tcp一款sniffer工具&#xff0c;是Linux上的抓包工具&#xff0c;嗅探器语法tcpdump (选项)选项-c&#xff1a; 指定要抓取的包数量。注意&#xff0c;是最终要获取这么多个包。例如&#xff0c;指定"-c 10"将获取10个包&#xff0c;但可能已经处理了100个包&#xf…
阅读更多...
如何基于声网互动白板实现一个多人数独游戏

如何基于声网互动白板实现一个多人数独游戏

本文作者是声网社区的开发者“tjss”。他基于 Vue、声网的互动白板的代码模板&#xff0c;搭建出了一个支持多人互动的数独游戏。本文记录了他的实现过程&#xff0c;欢迎大家也可以尝试实现自己的小游戏或应用。 我基于声网互动白板的 SDK 与 Window Manager 开发了一个场景化…
阅读更多...
第二十三周周报

第二十三周周报

学习内容&#xff1a; 修改ViTGAN代码 学习时间&#xff1a; 2.3-2.10 学习产出&#xff1a; 现在的效果 可以看到在700k左右fid开始上升&#xff0c;相比vitgan&#xff0c;改的vitgan鉴别器loss有所下降&#xff0c;但是fid没有降下来&#xff0c;最好为23.134&#xf…
阅读更多...
Elasticsearch7.8.0版本进阶——分布式集群（水平扩容）

Elasticsearch7.8.0版本进阶——分布式集群（水平扩容）

目录一、Elasticsearch集群的安装1.1、Elasticsearch集群的安装&#xff08;win10环境&#xff09;1.2、Elasticsearch集群的安装&#xff08;linux环境&#xff09;二、水平扩容&#xff08;win10环境集群演示&#xff09;三、想要扩容超过 6 个节点怎么办3.1、主分片和副分片…
阅读更多...
IDEA合并分支(从开发分支到测试分支)

IDEA合并分支(从开发分支到测试分支)

IDEA合并分支(从开发分支到测试分支) 1、先在当前分支拉去最新的代码且提交自己的修改到远程分支上 2、切换到目标分支(你要合并到的分支上),test测试分支 3、进行分支合并,这里其实有3个选项比较常用 ①Compare with ‘test’ 与当前分支(test)比较,这个比较回弹出个窗口…
阅读更多...
刷爆网络的ChatGpt，给大家搞来了。

刷爆网络的ChatGpt，给大家搞来了。

最近chatgpt可谓是顶上了热搜&#xff0c;之前写代码的同学们应该都知道出了一款插件叫做 Copilot&#xff0c;这是一款可以帮你自动写代码的插件&#xff0c;只要输入你想要写的代码&#xff0c;比如写一个js轮播图之类的&#xff0c;立马就可以帮你生成。不仅如此&#xff0c…
阅读更多...
随着攻击者适应绕过零信任，公司在苦苦挣扎

随着攻击者适应绕过零信任，公司在苦苦挣扎

商业情报公司 Gartner 表示&#xff0c;零信任安全方法有望减少威胁并降低成功攻击的破坏性&#xff0c;但公司不应期望实施零信任原则会很容易或阻止大多数攻击。 虽然对零信任架构的兴趣很高&#xff0c;但目前只有大约 1% 的组织拥有满足零信任定义的成熟程序。 该公司还估…
阅读更多...
论文投稿指南——中文核心期刊推荐（石油、天然气工业 2）

论文投稿指南——中文核心期刊推荐（石油、天然气工业 2）

【前言】 &#x1f680; 想发论文怎么办&#xff1f;手把手教你论文如何投稿&#xff01;那么&#xff0c;首先要搞懂投稿目标——论文期刊 &#x1f384; 在期刊论文的分布中&#xff0c;存在一种普遍现象&#xff1a;即对于某一特定的学科或专业来说&#xff0c;少数期刊所含…
阅读更多...
【火电机组、风能、储能】高比例风电电力系统储能运行及配置分析（Matlab代码实现）

【火电机组、风能、储能】高比例风电电力系统储能运行及配置分析（Matlab代码实现）

目录 摘 要 0 目标函数和约束条件 1 第一题 2 第二题 3 第三题 4 第四题&#xff1a;含高比例风电电力系统最小供电成本模型 6 第六题&#xff1a; 7 第七题&#xff1a; 8 所有题代码及文章详细讲解 9 结论&#xff1a; 10 参考文献 摘 要 高比例风电电力系统储…
阅读更多...
JVM——运行期优化

JVM——运行期优化

目录一、分层编译&#xff08;TieredCompilation&#xff09;即时编译器&#xff08;JIT&#xff09;与解释器的区别逃逸分析二、方法内联&#xff08;Inlining&#xff09;三、反射优化一、分层编译&#xff08;TieredCompilation&#xff09; JVM 将执行状态分成了 5 个层次…
阅读更多...
宜家EDI IFTMBC运输预定确认详解

宜家EDI IFTMBC运输预定确认详解

IFTMBC是宜家与其供应商之间传输的符合EDIFACT标准的报文&#xff0c;在此前的文章如何读懂EDIFACT报文中&#xff0c;我们已经对EDIFACT做了详细的解读。在供应商发给宜家IFTMBF运输预定请求后&#xff0c;宜家会回复IFTMBC运输预订确认给供应商。 本文将从供应商接收宜家发送…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023