Java由浅入深理解线程池设计和原理

news2024/12/23 10:17:56

目录

    • 1 线程
      • 1.1 什么是线程?什么是进程?
      • 1.2 java中线程的实现方式有几种?
      • 1.3 线程的生命周期是什么?
    • 2 线程存在的问题
      • 2.1 一个线程只能执行一个任务
      • 2.2 线程执行完后销毁,无法复用
      • 2.3 线程过多,导致JVM宕机
    • 3 初识线程池
      • 3.1 了解J.U.C
      • 3.2 线程池解决了什么问题
      • 3.3 线程池引发了什么问题
    • 4 线程池的设计思想
    • 5 线程池的原理
      • 5.1 了解线程池类继承结构图
      • 5.2 线程池工作状态
      • 5.3 掌握线程池个参数定义
      • 5.4 线程池结构说明
      • 5.5 线程池的任务提交
      • 5.6 线程池工具类Executors
      • 5.7 确定线程池的线程数
        • 5.7.1 为IO密集型任务确定线程数
        • 5.7.2 为CPU密集型任务确定线程数
        • 5.7.3 为混合型任务确定线程数
      • 5.8 线程池源码刨析
    • 5.9 Executors
    • 6 线程池的经典面试题
      • 6.1 线程池是如何保证线程不被销毁的呢?
      • 6.2 核心线程与非核心线程有区别吗?
      • 6.3 线程池7个参数的作用及生效时机


1 线程

1.1 什么是线程?什么是进程?

​ 进程:是指在系统中正在运行的一个应用程序,每个进程之间是独立的,每个进程均运行在其专用的且受保护的内存

​ 线程:进程的基本执行单元,一个进程的所有任务都在线程中执行,进程要想执行任务,必须得有线程,进程至少要有一条线程

1.2 java中线程的实现方式有几种?

​ 继承Thread类

public class MyThread extends Thread{
    @Override
    public void run() {
        // 执行自己代码逻辑
        System.out.println("自己线程被执行");
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

​ 实现Runnable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 执行自己代码逻辑
        System.out.println("自己Runnable被执行");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

1.3 线程的生命周期是什么?

在这里插入图片描述

  • NEW:刚刚创建,没做任何操作

    Thread thread = new Thread();
    System.out.println(thread.getState());
    
  • RUNNABLE:调用run,可以执行,但不代表一定在执行(RUNNING,READY)

    thread.start();
    System.out.println(thread.getState());
    
  • BLOCKED:抢不到锁

        final byte[] lock = new byte[0];
        new Thread(new Runnable() {
            public void run() {
                synchronized (lock){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock){
                }
            }
        });
        thread2.start();
        Thread.sleep(1000);
        System.out.println(thread2.getState());
  • WAITING
Thread thread2 = new Thread(new Runnable() {
    public void run() {
        LockSupport.park();
    }
});

thread2.start();
Thread.sleep(500);
System.out.println(thread2.getState());
LockSupport.unpark(thread2);
Thread.sleep(500);
System.out.println(thread2.getState());

TIMED_WAITING

Thread thread3 = new Thread(new Runnable() {
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
thread3.start();
Thread.sleep(500);
System.out.println(thread3.getState());

TERMINATED

//等待1s后再来看
Thread.sleep(1000);
System.out.println(thread.getState());

2 线程存在的问题

2.1 一个线程只能执行一个任务

在这里插入图片描述

2.2 线程执行完后销毁,无法复用

在这里插入图片描述

public class MyThread extends Thread{
    @Override
    public void run() {
        // 执行自己代码逻辑
        System.out.println("自己线程被执行");
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        // main线程休息5秒,等待myThread执行完成
        TimeUnit.SECONDS.sleep(10);
        // 执行业务代码
        System.out.println("执行其他业务代码");
        // 业务代码执行完成,需要再次执行线程
        myThread.start();
    }
}

2.3 线程过多,导致JVM宕机

在这里插入图片描述

3 初识线程池

简介:

​ 在多线程编程中,任务都是一些抽象且离散的工作单元,而线程是使任务异步执行的基本机制。随着应用的扩张,线程和任务管理也变得非常复杂。为了简化这些复杂的线程管理模式,我们需要一个“管理者”来统一管理线程及任务分配,这就是线程池。

​ 在主要大厂的编程规范中,不允许在应用中自行显式地创建线程,线程必须通过线程池提供。由于创建和销毁线程需要时间以及系统资源开销,使用线程池的好处是减少这些开销,解决资源不足的问题。

3.1 了解J.U.C

​ J.U.C全称:java.util.concurrent,在并发编程中很常用的实用工具类。

​ 在并发编程中很常用的实用工具类,用于完成高并发、处理多线程的一个工具包。此包包括了几个小的、已标准化的可扩展框架,以及一些提供有用功能的类,没有这些类,这些功能会很难实现或实现起来冗长乏味

在这里插入图片描述

3.2 线程池解决了什么问题

  • 降低系统资源消耗,通过重用已存在的线程,降低线程创建和销毁造成的消耗;
  • 提高系统响应速度,当有任务到达时,通过复用已存在的线程,无需等待新线程的创建便能立即执行;
  • 方便线程并发数的管控。因为线程若是无限制的创建,可能会导致内存占用过多而产生OOM
  • 节省CPU切换线程的时间成本(需要保持当前执行线程的现场,并恢复要执行线程的现场)。
  • 提供更强大的功能,延时定时线程池。(Timer vs ScheduledThreadPoolExecutor)

3.3 线程池引发了什么问题

  • 异步任务提交后,如果JVM宕机,已提交的任务会丢失,需要考虑确认机制。
  • 使用不合理,可能导致内存溢出问题
  • 参数过多,代码结构引入数据结构与算法,增加学习难度。

4 线程池的设计思想

在这里插入图片描述

在这里插入图片描述

5 线程池的原理

5.1 了解线程池类继承结构图

在这里插入图片描述

说明:

  • 最常用的是ThreadPoolExecutor
  • 调度用ScheduledThreadPoolExecutor,类似Timer和TimerTask。
  • 任务拆分合并用ForkJoinPool
  • Executors是工具类,协助你创建线程池的

5.2 线程池工作状态

线程池状态

在这里插入图片描述

  • RUNNING:初始化状态是RUNNING。线程池被一旦被创建,就处于RUNNING状态,并且线程池中的任务数为0。RUNNING状态下,能够接收新任务,以及对已添加的任务进行处理。

  • SHUTDOWN:不接收新任务,但能处理已添加的任务。调用线程池的shutdown()接口时,线程池由RUNNING -> SHUTDOWN。

//shutdown后不接受新任务,但是task1,仍然可以执行完成

ExecutorService poolExecutor = Executors.newFixedThreadPool(5);
poolExecutor.execute(new Runnable() {
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("finish task 1");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
poolExecutor.shutdown();
poolExecutor.execute(new Runnable() {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
System.out.println("ok");
  • STOP:不接收新任务,不处理已添加的任务,并且会中断正在处理的任务。调用线程池的shutdownNow()接口时,线程池由(RUNNING 或 SHUTDOWN ) -> STOP

    注意:容易引发不可预知的结果!运行中的任务也许还会打印,直到结束,因为调的是Thread.interrupt

//改为shutdownNow后,任务立马终止,sleep被打断,新任务无法提交,task1停止
poolExecutor.shutdownNow();
  • TIDYING:所有的任务已终止,队列中的”任务数量”为0,线程池会变为TIDYING。线程池变为TIDYING状态时,会执行钩子函数terminated(),可以通过重载terminated()函数来实现自定义行为
//自定义类,重写terminated方法
public class MyExecutorService extends ThreadPoolExecutor {

    public MyExecutorService(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    protected void terminated() {
        super.terminated();
        System.out.println("terminated");
    }
    
    //调用 shutdownNow, ternimated方法被调用打印
    public static void main(String[] args) throws InterruptedException {
        MyExecutorService service = new MyExecutorService(1,2,10000,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(5));
        service.shutdownNow();
    }
}


  • TERMINATED:线程池处在TIDYING状态时,执行完terminated()之后,就会由 TIDYING -> TERMINATED

5.3 掌握线程池个参数定义

/**
 * @param corePoolSize 池中要保留的线程数
 * @param maximumPoolSize 中允许的最大线程数,前提是队列先满
 * @param keepAliveTime 当线程数大于核心,这是多余空闲线程的最长时间将在终止之前等待新任务。
 * @param keepAliveTime参数的时间单位
 * @param workQueue 用于保存任务的队列
 * @param threadFactory 执行器创建新线程的工厂
 * @param handler 阻止执行时要使用的处理程序,因为达到了线程边界和队列容量
 */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {

5.4 线程池结构说明

在线程池的编程模式下,任务是提交给整个线程池,而不是直接提交给某个线程,线程池在拿到任务后,就在内部协调空闲的线程,如果有,则将任务交给某个空闲的线程。一个线程同时只能执行一个任务,但可以同时向一个线程池提交多个任务。

(源码查看:两个集合,一个queue,一个hashset)

在这里插入图片描述

5.5 线程池的任务提交

  • 添加任务,如果线程池中线程数没达到coreSize,直接创建新线程执行
  • 达到core,放入queue
  • queue已满,未达到maxSize继续创建线程
  • 达到maxSize,根据reject策略处理
  • 超时后,线程被释放,下降到coreSize

5.6 线程池工具类Executors

  • newCachedThreadPool() : 弹性线程数
  • newFixedThreadPool(int nThreads) : 固定线程数
  • newSingleThreadExecutor() : 单一线程数
  • newScheduledThreadPool(int corePoolSize) : 可调度,常用于定时

5.7 确定线程池的线程数

​ 虽然使用线程池的好处很多,但是如果其线程数配置得不合理,不仅可能达不到预期效果,反而可能降低应用的性能。

按照任务类型对线程池进行分类:

(1)IO密集型任务

​ 此类任务主要是执行IO操作。由于执行IO操作的时间较长,导致CPU的利用率不高,这类任务CPU常处于空闲状态。Netty的IO读写 操作为此类任务的典型例子。

(2)CPU密集型任务

​ 此类任务主要是执行计算任务。由于响应时间很快,CPU一直在运行,这种任务CPU的利用率很高。

(3)混合型任务

​ 此类任务既要执行逻辑计算,又要进行IO操作(如RPC调用、数据库访问)。相对来说,由于执行IO操作的耗时较长(一次网络往 返往往在数百毫秒级别),这类任务的CPU利用率也不是太高。Web服务器的HTTP请求处理操作为此类任务的典型例子。一般情况 下,针对以上不同类型的异步任务需要创建不同类型的线程池,并进行针对性的参数配置。

5.7.1 为IO密集型任务确定线程数

​ 由于IO密集型任务的CPU使用率较低,导致线程空余时间很多,因此通常需要开CPU核心数两倍的线程。当IO线程空闲时,可以启用 其他线程继续使用CPU,以提高CPU的使用率。Netty的IO处理任务就是典型的IO密集型任务。所以,Netty的Reactor(反应器)实 现类(定制版的线程池)的IO处理线程数默认正好为CPU核数的两倍

5.7.2 为CPU密集型任务确定线程数

​ CPU密集型任务也叫计算密集型任务,其特点是要进行大量计算而需要消耗CPU资源,比如计算圆周率、对视频进行高清解码 等。CPU密集型任务虽然也可以并行完成,但是并行的任务越多,花在任务切换的时间就越多,CPU执行任务的效率就越低,所以要 最高效地利用CPU,CPU密集型任务并行执行的数量应当等于CPU的核心数。

​ 比如4个核心的CPU,通过4个线程并行地执行4个CPU密集型任务,此时的效率是最高的。但是如果线程数远远超出CPU核 心数量,就需要频繁地切换线程,线程上下文切换时需要消耗时间,反而会使得任务效率下降。因此,对于CPU密集型的任务来说,线 程数等于CPU数就行。

5.7.3 为混合型任务确定线程数

​ 混合型任务既要执行逻辑计算,又要进行大量非CPU耗时操作(如RPC调用、数据库访问、网络通信等),所以混合型任务CPU的利用率不是太高,非CPU耗时往往是CPU耗时的数倍。比如在Web应用中处理HTTP请求时,一次请求处理会包括DB操作、RPC操作、缓存操作等多种耗时操作。一般来说,一次Web请求的CPU计算耗时往往较少,大致在100~500毫秒,而其他耗时操作会占用500~1000毫秒,甚至更多的时间。在为混合型任务创建线程池时,如何确定线程数呢?业界有一个比较成熟的估算公式,具体如下:

最佳线程数 = ((线程等待时间+线程CPU时间) / 线程CPU时间) * CPU核数

通过公式可以看出:等待时间所占的比例越高,需要的线程就越多;CPU耗时所占的比例越高,需要的线程就越少。下面举一个例子:比如在Web服务器处理HTTP请求时,假设平均线程CPU运行时间为100毫秒,而线程等待时间(比如包括DB操作、RPC操作、缓存操作等)为900毫秒,如果CPU核数为8,那么根据上面这个公式,估算如下:

(900毫秒 + 100毫秒) / 100毫秒 * 8 = 10 * 8 = 80

5.8 线程池源码刨析

在这里插入图片描述

//任务提交阶段:(4个if条件路线)

public void execute(Runnable command) {
  if (command == null)
            throw new NullPointerException();
  int c = ctl.get();
  //判断工作数,如果小于coreSize,addWork,注意第二个参数core=true
  if (workerCountOf(c) < corePoolSize) {
      if (addWorker(command, true))
          return;
      c = ctl.get();
  }
  //否则,如果线程池还在运行,offer到队列
  if (isRunning(c) && workQueue.offer(command)) {
      //再检查一下状态
      int recheck = ctl.get();
      //如果线程池已经终止,直接移除任务,不再响应
      if (! isRunning(recheck) && remove(command))
          reject(command);
      //否则,如果没有可用线程的话(比如coreSize=0),创建一个空work
        //该work创建时不会给指派任务(为null),但是会被放入works集合,进而从队列获取任务去执行
      else if (workerCountOf(recheck) == 0)
          addWorker(null, false);
  }
  //队列也满,继续调addWork,但是注意,core=false,开启到maxSize的大门
  //超出max的话,addWork会返回false,进入reject
  else if (!addWorker(command, false))
      reject(command);
}
//线程创建

private boolean addWorker(Runnable firstTask, boolean core) {
    //第一步,计数判断,不符合条件打回false
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.

        for (;;) {
            int wc = workerCountOf(c);
            //判断线程数,注意这里!
            //也就说明线程池的线程数是不可能设置任意大的。
            //最大29位(CAPACITY=29位二进制)
            //超出规定范围,返回false,表示不允许再开启新工作线程,创建worker失败!
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
    //第二步,创建新work放入线程集合works(一个HashSet)
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        //符合条件,创建新的work并包装task
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            //加锁,workers是一个hashset,这里要保障线程安全性
            mainLock.lock();
            try {   
                        //...
                    //在这里!!!
                    workers.add(w);
                    
                    //...                    
                    workerAdded = true;
                
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                //注意,只要是成功add了新的work,那么将该新work立即启动,任务得到执行
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}
//任务获取与执行
  
//在worker执行runWorker()的时候,不停循环,先查看自己有没有携带Task,如果有,执行
while (task != null || (task = getTask()) != null)

//如果没用,会调用getTask,从队列获取任务

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // ...

        int wc = workerCountOf(c);

        // Are workers subject to culling? - 很形象,要不要乖乖的被“捕杀”?
        //判断是不是要超时处理,重点!!!决定了当前线程要不要被释放
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
                //线程数超出max,并且上次循环中poll等待超时了,那么说明该线程已终止
        //将线程队列数量原子性减
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            //计数器做原子递减,递减成功后,返回null,for被中止
            if (compareAndDecrementWorkerCount(c))
                return null;
            //递减失败,继续下一轮循环,直到成功
            continue;
        }

        try {
            //重点!!!
            //如果线程可被释放,那就poll,释放的时间为:keepAliveTime
            //否则,线程是不会被释放的,take一直被阻塞在这里,直到来了新任务继续工作
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            //到这里说明可被释放的线程等待超时,已经销毁,设置该标记,下次循环将线程数减少
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

5.9 Executors

以上构造函数比较多,为了方便使用,juc提供了一个Executors工具类,内部提供静态方法

1)newCachedThreadPool() : 弹性线程数

2)newFixedThreadPool(int nThreads) : 固定线程数

3)newSingleThreadExecutor() : 单一线程数

4)newScheduledThreadPool(int corePoolSize) : 可调度,常用于定时

6 线程池的经典面试题

6.1 线程池是如何保证线程不被销毁的呢?

答案:如果队列中没有任务时,核心线程会一直阻塞在获取任务的方法,直到返回任务。而任务执行完后,又会进入下一轮 work.runWork()中循环

验证:秘密就藏在核心源码里 ThreadPoolExecutor.getTask()

//work.runWork():
while (task != null || (task = getTask()) != null)
    
    
//work.getTask():
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :workQueue.take();

6.2 核心线程与非核心线程有区别吗?

答案:没有。被销毁的线程和创建的先后无关。即便是第一个被创建的核心线程,仍然有可能被销毁

验证:看源码,每个work在runWork()的时候去getTask(),在getTask内部,并没有针对性的区分当前work是否是核心线程或者类似的标记。只要判断works数量超出core,就会调用poll(),否则take()

6.3 线程池7个参数的作用及生效时机

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {}

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

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

相关文章

计网第五章(运输层)(六)(TCP可靠传输的实现)

目录 一、基本概述 二、具体实现 1.前后沿&#xff1a; 2.利用指针描述发送窗口的状态 3.有差错情况 之前在数据链路层时已经讨论过可靠传输&#xff08;计网第三章&#xff08;数据链路层&#xff09;&#xff08;二&#xff09;&#xff08;可靠传输&#xff09;&#x…

电表智能管理系统-实现智能化、数字化的电力管理

随着信息技术的发展&#xff0c;智能电表已经成为了现代电力管理的重要组成部分。智能电表能够实时监测和记录用电量&#xff0c;自动控制用电&#xff0c;从而实现更加智能、高效的电力管理。 智能电表是一种能够自动监测和记录用电量&#xff0c;并能够自动控制用电的设备…

IDEA中取消双击shift全局搜索

设置如图步骤&#xff1a; 取消双击shift之后&#xff0c;如果想再次使用全局搜索&#xff0c;可以通过&#xff1a; ctrlshifA

Vue与relation-graph:高效打造关系图的秘诀

产品提需求啦&#xff0c;有一个需求就是实现一个功能&#xff1a;展现各个文件之间的调用关系&#xff0c;通过关系图的形式进行展示出来。 之前考虑使用antv x6实现此功能&#xff0c;但是考虑到只是展示的功能&#xff0c;也不需要进行交互&#xff0c;所以放弃使用antv x6&…

【操作系统笔记十二】Linux常用基础命令

Linux 常用快捷键 Tab 命令或路径等的补全键&#xff0c;特别常用的快捷键Ctrl insert 复制命令行内容&#xff08;常用可提高效率&#xff09;Shift insert 粘贴命令行内容&#xff08;常用可提高效率&#xff09;Ctrl C 中断当前任务&#xff08;退出&#xff09;Ctrl Z…

Java笔记:看清类加载过程

1 类加载的过程 1.1 加载 “加载”是“类加载”(Class Loading)过程的第一步。这个加载过程主要就是靠类器实现的&#xff0c;包括用户自定义类加载器。 加载的过程 在加载的过程中&#xff0c;JVM主要做3件事情 1&#xff09;通过一个类的全限定名来获取定义此类的二进制字节…

【Linux网络编程】日志与守护进程

日志是网络服务器程序在后台以守护进程的形式运行时&#xff0c;处理情况的描述被打印到了日志文件里面&#xff0c;方便维护人员查看。 1.前台进程与后台进程 左边会话输入命令 sleep 10000 & 代表进程后台运行&#xff0c;右边会话输入命令 sleep 20000可以看到命令行解…

珠海建筑模板厂家-能强优品木业:为您提供优质建筑模板解决方案

在珠海这座美丽的沿海城市&#xff0c;建筑行业蓬勃发展&#xff0c;对于高质量的建筑模板需求也日益增加。在这里&#xff0c;有一家备受赞誉的建筑模板厂家&#xff0c;那就是能强优品木业。作为一家专业的建筑模板供应商&#xff0c;他们以优质的产品和卓越的服务在业界享有…

联合查询

1.条件 2.步骤 1.判断列数 2.判断回显 3.重要 在回显位置写 查看字段名字 使用工具 hackbar

C语言while循环嵌套-动态字母

1、题目 使用C语言实现对字母动态移动&#xff08;根据用户输入的字符将字符从屏幕的坐标移动屏幕的右边&#xff09;。 2、分析 字符的移动核心是在显示的字母前面补上对应的空格字符内容&#xff0c;配合上延时就可以实现字符从屏幕左边移动到屏幕右侧的效果&#xff0c;实现…

【全网最全】2023华为杯研究生数学建模B题完整思路+python代码+20页超详细启发式算法+FFT(后续会更新)

目录 点击资料获取入口 DFT在通信等领域的重要应用,以及目前采用FFT计算DFT的硬件开销大的问题。提出了将DFT矩阵分解为整数矩阵乘积逼近的方法来降低硬件复杂度。 建模目标是对给定的DFT矩阵F_N,找到一组K个矩阵A,使F_N和A的乘积在Frobenius范数意义下尽可能接近,即最小化目标…

开源负载测试神器K6

简介&#xff1a;K6是一个强大的开源负载和性能测试工具&#xff0c;用于测试软件系统的性能和可靠性。K6的使用主要是编写测试脚本并运行&#xff0c;这些脚本主要用JavaScript编写&#xff0c;可以使用HTTP&#xff0c;WebSocket等多种协议进行测试。并且易于安装和运行&…

Java Web框架,如Spring MVC,是一种用于构建Web应用程序的软件框架:学生考试Web应用程序

文章目录 什么是Java Web框架&#xff1f;MVC模式在Spring MVC中的应用简单的学生考试Web应用程序设置Spring MVC项目创建实体类创建考试实体类创建控制器创建服务层创建数据库创建视图配置Spring MVC实现功能运行应用程序运行应用程序 &#x1f388;个人主页&#xff1a;程序员…

MySQL学习笔记3

MySQL的源码编译安装&#xff1a; 1、参考MySQL的源码安装官方文档&#xff1a; 2、源码安装定制选项&#xff1a; 3、源码安装三部曲&#xff1a;配置、编译、安装。 4、软件安装包&#xff1a; mysql-boost-5.7.43.tar.gz 5、安装需求&#xff1a; 安装需求具体配置安装目…

安装gpu版本的paddle和paddleclas

安装gpu版本的paddle python -m pip install paddlepaddle-gpu2.3.2.post111 -f https://www.paddlepaddle.org.cn/whl/windows/mkl/avx/stable.html以上支持cuda11.1版本 其他需求可查阅文档在这里 安装paddleclas 1 在虚拟环境中安装所需的Python库&#xff1a; pip inst…

Cortex-M3/M4堆栈

一、Cortex-M3/M4堆栈操作 Cortex-M3/M4 使用的是“向下生长的满栈”模型。堆栈指针 SP 指向最后一个被压入堆栈的 32 位数值。在下一次压栈时&#xff0c; SP 先自减 4&#xff0c; 再存入新的数值&#xff0c;如图所示为堆栈的PUSH操作。 POP 操作刚好相反&#xff1a;先从 …

电子信息工程专业课复习知识点总结:(五)通信原理

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 第一章通信系统概述——通信系统的构成、各部分性质、性能指标1.通信系统的组成&#xff1f;2.通信系统的分类&#xff1f;3.调制、解调是什么&#xff1f;有什么用…

MySQL详解六:备份与恢复

文章目录 1. 数据库备份的分类1.1 从物理和逻辑上分类1.1.1 物理备份1.1.2 逻辑备份 1.2 从数据库的备份策略角度上分类1.2.1 完全备份1.2.2 差异备份1.2.3 增量备份 1.3 常见的备份方法 2. MySQL完全备份2.1 完全备份简介2.2 优点与缺点2.3 实现物理冷备份与恢复2.3.1 实现流程…

备受以太坊基金会青睐的 Hexlink,构建亿级用户涌入 Web3的入口

早在2021年9月&#xff0c;以太坊创始人Vitalik Buterin就曾提出了EIP-4337&#xff08;账户抽象&#xff09;提案&#xff0c;并在去年10月对该提案进一步更新&#xff0c;引发行业的进一步关注。在今年3月&#xff0c;EIP-4337提案正式通过审计&#xff0c;并成为了ERC-4337标…

conda常用指令

常用conda指令 查看当前有哪些环境&#xff0c;有base环境 conda env list 创建环境 # conda create -n 你的环境名 python版本号 # 创建python3.10&#xff0c;名为env虚拟环境 conda create -n env python3.10 激活环境 conda activate env