学习JavaEE的日子 Day32 线程池

Day32 线程池

1.引入

一个线程完成一项任务所需时间为：

  1. 创建线程时间 - Time1
  2. 线程中执行任务的时间 - Time2
  3. 销毁线程时间 - Time3

2.为什么需要线程池(重要)

  1. 线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段
  2. 线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建线程的数目，提高线程的复用率
  3. 系统启动一个新线程的成本是比较高的，因为涉及与操作系统的交互，在这种情形下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时，优先考虑使用线程池

3.Java提供的线程池(了解即可)

一般不会使用这个，局限性太多

ExecutorService：线程池的接口

Executors：创建各种线程池的工具类

public class Test {
	
	public static void main(String[] args) {
		
		//创建单个线程的线程池
		//ExecutorService pool = Executors.newSingleThreadExecutor();
		//创建指定线程的线程池
		//ExecutorService pool = Executors.newFixedThreadPool(3);
		//创建可缓存线程的线程池，自动回收60s闲置线程
		ExecutorService pool = Executors.newCachedThreadPool();
		
		//循环创建任务对象，并提交给线程池
		for (int i = 1; i <= 100; i++) {
			//创建任务对象
			Task task = new Task(i);
			//提交任务
			pool.execute(task);
		}
		
		//关闭线程池
		pool.shutdown();
	}
}

class Task implements Runnable{
	private int i;
	public Task(int i) {
		this.i = i;
	}
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "处理了第" + num + "个任务");
	}
}

4.深入源码

ExecutorService pool = Executors.newSingleThreadExecutor();

ExecutorService pool = Executors.newFixedThreadPool(3);

ExecutorService pool = Executors.newCachedThreadPool();

三种线程池底层都是ThreadPoolExecutor类的对象

-- 分析ThreadPoolExecutor类的构造方法源码--------------------------------
public ThreadPoolExecutor(
	int corePoolSize,		------------- 核心线程数量 
    int maximumPoolSize,	------------- 最大线程数量 
	long keepAliveTime,		------------- 闲置时间，作用于核心线程数与最大线程数之间的线程
	TimeUnit unit,			------------- keepAliveTime的时间单位(可以是毫秒、秒....)
	BlockingQueue<Runnable> workQueue, -- 任务队列
	ThreadFactory threadFactory, -------- 线程工厂
	RejectedExecutionHandler handler ---- 达到了线程界限和队列容量时的处理方案(拒绝策略)
) {}
执行步骤:
	1.创建线程池后
    2.任务提交后，查看是否有核心线程：
        3.1 没有 -> 就创建核心线程 -> 执行任务 -> 执行完毕后又回到线程池中
        3.2 有 -> 查看是否有闲置核心线程：
        	4.1 有 -> 执行任务 -> 执行完毕后又回到线程池
        	4.2 没有 -> 查看当前核心线程数是否核心线程数量：
        		5.1 否 -> 就创建核心线程 -> 执行任务 -> 执行完毕后又回到线程池中
        		5.2 是 -> 查看任务列表是否装载满：
        			6.1 没有 -> 就放入列表中，等待出现闲置线程
        			6.2 装满 -> 查看是否有普通线程(核心线程数到最大线程数量之间的线程)
        				7.1 没有 -> 就创建普通线程 -> 执行任务 -> 执行完毕后又回到线程池中
        				7.2 有 -> 查看是否有闲置普通线程
        					7.1.1 有 -> 执行任务 -> 执行完毕后又回到线程池中
        					7.1.2 没有 -> 查看现在所有线程数量是否为最大线程数：
        						8.1 是 -> 执行处理方案（默认处理抛出异常）
        						8.2 否 ->就创建普通线程-> 执行任务 -> 执行完毕后又回到线程池中     			
注：
	1.为了更好的理解，在这里区分核心线程和普通线程，实际上区分的这么清楚，都是线程
    2.默认的处理方案就是抛出RejectedExecutionException

-- 分析单个线程的线程池的源码 --------------------------------
ExecutorService pool = Executors.newSingleThreadExecutor();
new ThreadPoolExecutor(
    1, -- 核心线程数量 
    1, -- 最大线程数量 
    0L, -- 闲置时间
    TimeUnit.MILLISECONDS, -- 时间单位(毫秒)
    new LinkedBlockingQueue<Runnable>() -- 无界任务队列，可以无限添加任务（内存溢出问题）
)  
-- 分析指定线程的线程池的源码 --------------------------------
ExecutorService pool = Executors.newFixedThreadPool(3);
new ThreadPoolExecutor(
    nThreads, -- 核心线程数量 
    nThreads, -- 最大线程数量 
    0L, -- 闲置时间
    TimeUnit.MILLISECONDS, -- 时间单位(毫秒)
    new LinkedBlockingQueue<Runnable>()-- 无界任务队列，可以无限添加任务（内存溢出问题）
)
-- 创建可缓存线程的线程池 -----------------------------------
new ThreadPoolExecutor(
    0, -- 核心线程数量 
    Integer.MAX_VALUE,-- 最大线程数量 
    60L, -- 闲置时间
    TimeUnit.SECONDS, -- 时间单位(秒)
    new SynchronousQueue<Runnable>() -- 直接提交队列(同步队列)：没有容量队列（最大线程数量是21亿多，太大了）

总结：核心线程满载 -> 任务队列 -> 普通线程 -> 拒绝策略

在这里插入图片描述

5.任务队列详解

队列名称详解
LinkedBlockingQueue无界任务队列使用无界任务队列，线程池的任务队列可以无限制的添加新的任务，而线程池创建的最大线程数量就是你corePoolSize设置的数量，也就是说在这种情况下maximumPoolSize这个参数是无效的，哪怕你的任务队列中缓存了很多未执行的任务，当线程池的线程数达到corePoolSize后，就不会再增加了；若后续有新的任务加入，则直接进入队列等待，当使用这种任务队列模式时，一定要注意你任务提交与处理之间的协调与控制，不然会出现队列中的任务由于无法及时处理导致一直增长，直到最后资源耗尽的问题
SynchronousQueue 同步任务队列 直接提交任务队列使用直接提交任务队列，队列没有容量，每执行一个插入操作就会阻塞，需要再执行一个删除操作才会被唤醒，反之每一个删除操作也都要等待对应的插入操作。 任务队列为SynchronousQueue，创建的线程数大于maximumPoolSize时，直接执行了拒绝策略抛出异常。 使用SynchronousQueue队列，提交的任务不会被保存，总是会马上提交执行。如果用于执行任务的线程数量小于maximumPoolSize，则尝试创建新的线程，如果达到maximumPoolSize设置的最大值，则根据你设置的handler执行拒绝策略。因此这种方式你提交的任务不会被缓存起来，而是会被马上执行，在这种情况下，你需要对你程序的并发量有个准确的评估，才能设置合适的maximumPoolSize数量，否则很容易就会执行拒绝策略；
ArrayBlockingQueue有界任务队列使用有界任务队列，若有新的任务需要执行时，线程池会创建新的线程，直到创建的线程数量达到corePoolSize时，则会将新的任务加入到等待队列中。若等待队列已满，即超过ArrayBlockingQueue初始化的容量，则继续创建线程，直到线程数量达到maximumPoolSize设置的最大线程数量，若大于maximumPoolSize，则执行拒绝策略。在这种情况下，线程数量的上限与有界任务队列的状态有直接关系，如果有界队列初始容量较大或者没有达到超负荷的状态，线程数将一直维持在corePoolSize以下，反之当任务队列已满时，则会以maximumPoolSize为最大线程数上限。
PriorityBlockingQueue优先任务队列使用优先任务队列，它其实是一个特殊的无界队列，它其中无论添加了多少个任务，线程池创建的线程数也不会超过corePoolSize的数量，只不过其他队列一般是按照先进先出的规则处理任务，而PriorityBlockingQueue队列可以自定义规则根据任务的优先级顺序先后执行。

对优先队列的使用说明：

除了第一个任务直接创建线程执行外，其他的任务都被放入了优先任务队列，按优先级进行了重新排列执行，且线程池的线程数一直为corePoolSize，也就是只有一个。

5.1 无界队列

理解：这个队列没有上线

继承关系：LinkedBlockingQueue -> AbstractQueue -> AbstractCollection

小结：

1.LinkedBlockingQueue是Collection集合家族的一员

2.Collection集合家族（List、Set、Queue）

3.LinkedBlockingQueue数据结构单向链表

缺点：LinkedBlockingQueue可能造成内存溢出

public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		//创建无界队列
		LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();
		
		//添加元素
		queue.put("aaa");
		queue.put("bbb");
		queue.put("ccc");
		queue.put("ddd");
		queue.put("eee");
		queue.put("fff");
		
		//删除元素
		queue.remove("ccc");
		
		//遍历队列
		Iterator<String> it = queue.iterator();
		while (it.hasNext()) {
			String string = it.next();
			System.out.println(string);
		}
		
		
	}
}

public class Task implements Runnable,Comparable<Task>{

	private int priority;//优先级别
	
	public Task(int priority) {
		this.priority = priority;
	}

	@Override
	public void run() {
		System.out.println("任务被处理了");
	}

	//当前对象和其他对象做比较，当前优先级大就返回-1，优先级小就返回1,值越小优先级越高
	@Override
	public int compareTo(Task o) {
		return Integer.compare(this.priority, o.priority);
	}

	public int getPriority() {
		return priority;
	}
}
5.2 有界队列

继承关系：ArrayBlockingQueue -> AbstractQueue -> AbstractCollection

小结：

1.ArrayBlockingQueue数据结构一维数组

缺点：不能有效控制项目中的线程目数

public class Test02 {
	public static void main(String[] args) throws InterruptedException {
		
		//创建有界队列
		ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(6);
		
		//添加元素
		queue.put("aaa");
		queue.put("bbb");
		queue.put("ccc");
		queue.put("ddd");
		queue.put("eee");
		queue.put("fff");
		
		//删除元素
		queue.remove("ccc");
		
		//遍历队列
		Iterator<String> it = queue.iterator();
		while (it.hasNext()) {
			String string = it.next();
			System.out.println(string);
		}
				
	}
}
5.3 优先队列

继承关系：ArrayBlockingQueue -> AbstractQueue -> AbstractCollection

ArrayBlockingQueue数据结构一维数组

public class Test03 {
	public static void main(String[] args) throws InterruptedException {
		
		//创建优先队列
		PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();//无参构造底层使用的是元素的内置比较器
		
		//添加元素
		queue.add(new Task(3));
		queue.add(new Task(1));
		queue.add(new Task(4));
		queue.add(new Task(2));
				
		//遍历取出队列
		while(!queue.isEmpty()){
			//删除第一元素
			Task poll = queue.poll();
			System.out.println(poll.getPriority());
		}		
		
	}
}

6.拒绝策略

ThreadPoolExecutor自带的拒绝策略有四种，都实现了RejectedExecutionHandler接口

比如：new ThreadPoolExecutor.AbortPolicy()

拒绝策略解释
AbortPolicy当有任务添加到线程池被拒绝时，会抛出RejectedExecutionException异常 线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。
DiscardPolicy当有任务添加到线程池被拒绝时，直接丢弃，其他啥都没有
CallerRunsPolicy当有任务添加到线程池被拒绝时，线程池会将被拒绝的任务添加到线程池正在运行的线程中去运行。 一一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大
DiscardOledestPolicy当有任务添加到线程池被拒绝时，线程池会丢弃阻塞队列中末尾的任务（最老的任务），然后将被拒绝的任务添加到末尾。 如果项目中有允许丢失任务的需求，可以使用
6.1 自定义拒绝策略(实现RejectedExecutionHandler接口)
public class Test {
	
	public static void main(String[] args) {
		
		ThreadPoolExecutor pool = new ThreadPoolExecutor(1, 1, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(1), Executors.defaultThreadFactory(), new RejectedExecutionHandler() {
			@Override
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				System.out.println(r.toString()+"执行了拒绝策略");
			}
		});
		
		for (int i = 1; i <= 10; i++) {
			pool.execute(new Task());
		}
		
		pool.shutdown();
	}
}
class Task implements Runnable{
	
	@Override
	public void run() {
		try {
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

7.自定义线程池原因（重要）

为什么不使用java自带的线程池？而去自定义线程池？

在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面使线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活，而且有资源耗尽的风险（OOM - Out Of Memory ）。

一般我们创建线程池时，为防止资源被耗尽，任务队列都会选择创建有界任务队列，但这种模式下如果出现任务队列已满且线程池创建的线程数达到你设置的最大线程数时，这时就需要你指定ThreadPoolExecutor的RejectedExecutionHandler参数即合理的拒绝策略，来处理线程池"超载"的情况

7.1 自定义线程池

七大属性要记住

前提学习线程池中如何创建线程：

线程池中线程就是通过ThreadPoolExecutor中的ThreadFactory，线程工厂创建的。那么通过自定义ThreadFactory，可以按需要对线程池中创建的线程进行一些特殊的设置，如命名、优先级等

public class Test01 {
	public static void main(String[] args) {
		
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				5, //核心线程数
				20, //最大线程数
				60, //闲置时间
				TimeUnit.SECONDS, //时间单位
				new ArrayBlockingQueue<>(30), //任务队列 -- 有界队列
				new ThreadFactory() {//自定义线程工厂
					private int num = 1;
					@Override
					public Thread newThread(Runnable r) {
						Thread t = new Thread(r);
						t.setName("自定义线程池中的线程"+num);
						t.setPriority(Thread.MAX_PRIORITY);
						num++;
						return t;
					}
				}, 
				new RejectedExecutionHandler() {//自定义拒绝策略
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.out.println("任务被拒绝了~~~");
					}
				}
			);
		
		for (int i = 1; i <= 100; i++) {
			Task task = new Task(i);
			pool.execute(task);
		}
		
		
		pool.shutdown();
		
	}
}

public class Task implements Runnable{

	private int num;
	
	public Task(int num) {
		this.num = num;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "处理了第" + num + "个任务");
	}

}
7.2 自己写一个线程池

自定义线程池类

//自己写的线程池
public class FastThreadPool extends ThreadPoolExecutor{
	
	public FastThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
			BlockingQueue<Runnable> workQueue) {
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new FastThreadFactory(), new FastRejectedExecutionHandler());
	}

	public FastThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
			BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
	}//七大属性记住，重要！！！
	
	@Override
	protected void beforeExecute(Thread t, Runnable r) {
		System.out.println("线程执行任务之前调用 -- " + r);
	}
	
	@Override
	protected void afterExecute(Runnable r, Throwable t) {
		System.out.println("线程执行任务之后调用 -- " + r);
	}
	
	@Override
	protected void terminated() {
		System.out.println("线程池关闭时调用");
	}
	
	//自定义线程工厂（实现ThreadFactory接口）
	private static class FastThreadFactory implements ThreadFactory{
		private int num;//线程编号
		@Override
		public Thread newThread(Runnable r) {
			Thread t = new Thread(r);
			t.setName("自定义线程池中的线程"+num);
			t.setPriority(Thread.MAX_PRIORITY);
			num++;
			return t;
		}
	}
	
	
	//自定义拒绝策略（实现RejectedExecutionHandler）
	private static class FastRejectedExecutionHandler implements RejectedExecutionHandler{
		@Override
		public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
			System.out.println("任务被拒绝了~~~");
		}
	}

}

任务类

public class Task implements Runnable{

	private int num;
	
	public Task(int num) {
		this.num = num;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "处理了第" + num + "个任务");
	}

	@Override
	public String toString() {
		return "任务" + num;
	}
}

测试类

public class Test01 {
	public static void main(String[] args) {
		
		FastThreadPool pool = new FastThreadPool(5, 20, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(30));
		
		for (int i = 1; i <= 100; i++) {
			Task task = new Task(i);
			pool.execute(task);
		}
		
		//设置为true后，闲置时间一旦到达，核心线程也会被销毁
		//经验：我们一般不会回收核心线程，因为设置回收后线程池中的线程有可能为0，这样就没有线程复用率的说法了
		//pool.allowCoreThreadTimeOut(true);
		
		pool.shutdown();
		
	}
}

面试题：线程池中核心线程会被回收吗？

当线程池调用了allowCoreThreadTimeOut(true);时，核心线程会被回收

但是一般不会调用该方法，也就是说，项目中线程池中的核心线程不要设计被回收，因为如果线程池中线程全部都回收了，就没有线程复用率这个说法

核心线程宁可闲置也不回收

7.3 ThreadPoolExecutor扩展

ThreadPoolExecutor扩展主要是围绕beforeExecute()、afterExecute()和terminated()三个方法的重写， 通过这三个方法我们可以监控每个任务的开始和结束时间，或者其他一些功能。下面我们可以通过代码实现一下

方法解释
beforeExecute线程池中任务运行前执行
afterExecute线程池中任务运行完毕后执行
terminated线程池退出后执行

上面自己写的自定义线程池里有相关使用

8.线程池线程数量

实际工作中使用 sysbench多线程性能测试工具 （重要），因为七大属性中的核心线程数，最大线程数，闲置时间不能随便乱写一个数字上去，而是要进行相关测试才能得出数据

9.带有返回值的任务类(实现 Callable<>接口)

注意：带有返回值的任务类和线程池一起使用

需求：计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。

public class Test01 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		//创建数组
		int[] arr = new int[20000];
		
		//初始化数组数据 -- {1,2,3,....,20000}
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i+1;
		}
		
		//创建线程池
		FastThreadPool pool = new FastThreadPool(4, 4, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));
		
		//创建任务
		Task task1 = new Task(arr, 0, 5000,1);
		Task task2 = new Task(arr, 5000, 10000,2);
		Task task3 = new Task(arr, 10000, 15000,3);
		Task task4 = new Task(arr, 15000, 20000,4);
		
		//提交任务，任务完成后会返回Future对象，Future对象里存储了任务的返回值数据
		Future<Integer> future1 = pool.submit(task1);
		Future<Integer> future2 = pool.submit(task2);
		Future<Integer> future3 = pool.submit(task3);
		Future<Integer> future4 = pool.submit(task4);
		
		//合并任务返回值
		System.out.println(future1.get() + future2.get() + future3.get() + future4.get());
		
		
		pool.shutdown();
	}
}

带返回值的任务类

public class Task implements Callable<Integer>{
	
	private int[] arr;
	private int startIndex;
	private int endIndex;
	
	private int num;
	
	public Task(int[] arr, int startIndex, int endIndex,int num) {
		this.arr = arr;
		this.startIndex = startIndex;
		this.endIndex = endIndex;
		this.num = num;
	}

	//理解：线程抢到CPU资源后，才会调用call方法，call方法相当于Runnable接口中的run方法
	@Override
	public Integer call() throws Exception {
		
		int sum = 0;
		for (int i = startIndex; i < endIndex; i++) {
			sum += arr[i];
			System.out.println("任务" + num);
		}
		return sum;
	}

}

总结

1.Java自带的线程池
单个线程的线程池
指定线程个数的线程池
可缓存的线程池
延迟任务的线程池

2.线程池的7大参数
核心线程数
最大线程数
任务队列（有界、无界、同步、优先队列）
拒绝策略
闲置时间
时间单位
线程工厂

3.线程池的调用步骤（核心线程、任务队列、普通线程、拒绝策略）

4.任务队列及底层原理（有界、无界、同步、优先队列）

5.自定义线程池
自定义线程工厂
自定义拒绝策略

6.带有返回值的任务类 --Callable

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

磐启微PAN1020低功耗SOC芯片

磐启微PAN1020低功耗SOC芯片

PAN1020低功耗蓝牙芯片 典型应用 ⚫ 电视和机顶盒遥控器 ⚫ 无线游戏手柄 ⚫ 无线鼠键 ⚫ 智能家居 需要此物料&#xff0c;可联系周小姐 主要特性 ⚫ RF - 2.4GHz 射频收发机&#xff08;兼容 BLE4.2&#xff09; - 接收灵敏度&#xff1a;-90 dBm1Mbps - 接收信号&a…
阅读更多...
智慧公厕解决方案打造更加智能的卫生空间

智慧公厕解决方案打造更加智能的卫生空间

一、智慧公厕方案概述 智慧公厕方案旨在解决现有公厕存在的诸多问题&#xff0c;包括民众用厕困难、环境卫生状况不佳、管理效率低下等方面。针对民众的需求和管理方面的挑战&#xff0c;智慧公厕提供了一套综合解决方案&#xff0c;包括智能导航、环境监测、资源管理等功能&a…
阅读更多...
jvm（虚拟机）运行时数据区域介绍

jvm（虚拟机）运行时数据区域介绍

Java虚拟机&#xff08;JVM&#xff09;运行时数据区域是Java程序在运行过程中使用的内存区域&#xff0c;它主要包括以下几个部分&#xff1a; 程序计数器&#xff08;Program Counter Register&#xff09;&#xff1a; 程序计数器是一块较小的内存区域&#xff0c;是线程私有…
阅读更多...
25G SFP28 AOC线缆最新数据传输解决方案

25G SFP28 AOC线缆最新数据传输解决方案

在当今云计算、大数据、人工智能等领域&#xff0c;对高速数据传输的需求不断增加。传统的1G和10G网络已经无法满足数据中心日益增长的流量&#xff0c;因此迫切需要更高速的解决方案。25G SFP28 AOC有源光缆迎合了这一需求&#xff0c;成为连接数据中心、服务器、存储等25G设备…
阅读更多...
RPA使用Native Messaging协议实现浏览器自动化

RPA使用Native Messaging协议实现浏览器自动化

RPA 即机器人流程自动化&#xff0c;是一种利用软件机器人或人工智能来自动化业务流程中规则性、重复性任务的技术。RPA 技术可以模拟和执行人类在计算机上的交互操作&#xff0c;从而实现自动化处理数据、处理交易、触发通知等任务。帮助企业或个人实现业务流程的自动化和优化…
阅读更多...
速通数据结构第二站 顺序表

速通数据结构第二站 顺序表

文章目录 速通数据结构与算法系列 1 速通数据结构与算法第一站 复杂度 http://t.csdnimg.cn/sxEGF 感谢佬们支持&#xff01; 目录 系列文章目录 前言一、顺序表 0 结构体 1 接口声明 2 初始化和销毁 3 扩容函数 4 打印和判空 5 尾插 …
阅读更多...
B2902A是德科技B2902A精密型电源

B2902A是德科技B2902A精密型电源

181/2461/8938产品概述&#xff1a; Agilent B2902A 精密源/测量单元 (SMU) 是一款 2 通道、紧凑且经济高效的台式 SMU&#xff0c;能够源和测量电压和电流。它用途广泛&#xff0c;可以轻松、高精度地执行 I/V&#xff08;电流与电压&#xff09;测量。4 象限源和测量功能的集…
阅读更多...
RabbitMQ安装及使用笔记

RabbitMQ安装及使用笔记

RabbitMQ安装及使用笔记 RabbitMQ是一个开源的消息代理软件&#xff0c;它实现了高级消息队列协议&#xff08;AMQP&#xff09;&#xff0c;用于在分布式系统中进行消息传递。 1.安装 利用docker load命令加载mq镜像 docker load -i mq.tar 基于Docker来安装RabbitMQ&#xff…
阅读更多...
【QT入门】 QListWidget各种常见用法详解之列表模式

【QT入门】 QListWidget各种常见用法详解之列表模式

往期回顾 【QT入门】 Qt代码创建布局之setLayout使用-CSDN博客 【QT入门】 Qt代码创建布局之多重布局变换与布局删除技巧-CSDN博客 【QT入门】 QTabWidget各种常见用法详解-CSDN博客 【QT入门】 QListWidget各种常见用法详解之列表模式 QListWidget有列表和图标两种显示模式&a…
阅读更多...
Blenderproc渲染6D位姿估计数据集

Blenderproc渲染6D位姿估计数据集

https://github.com/DLR-RM/BlenderProc/tree/main/examples/datasets/bop_challenge 目录 1.3d渲染原理 2.步骤 3.代码 生成mask_all 4.难例渲染 物体高反光​编辑​编辑强弱灯光(明暗)​编辑​编辑​编辑物体xyz范围缩小 物体重复 干扰物&#xff08;自定义干扰物遮…
阅读更多...
C#实现身份证格式验证（自建异常实现提醒）

C#实现身份证格式验证（自建异常实现提醒）

基本信息 中国居民身份证的格式包括18位数字&#xff0c;这些数字分别代表不同的信息&#xff1a; 第1、2位数字表示省份代码。 第3、4位数字表示城市代码。 第5、6位数字表示区县代码。 第7至14位数字表示出生年、月、日&#xff08;其中7、8、9、10位是年&#xff0c;11、12…
阅读更多...
整合SpringSecurity+JWT实现登录认证

整合SpringSecurity+JWT实现登录认证

一、关于 SpringSecurity 在 Spring Boot 出现之前&#xff0c;SpringSecurity 的使用场景是被另外一个安全管理框架 Shiro 牢牢霸占的&#xff0c;因为相对于 SpringSecurity 来说&#xff0c;SSM 中整合 Shiro 更加轻量级。Spring Boot 出现后&#xff0c;使这一情况情况大有…
阅读更多...
python实战之PyQt5桌面软件

python实战之PyQt5桌面软件

一. 演示效果 二. 准备工作 1. 使用pip 下载所需包 pyqt5 2. 下载可视化UI工具 QT Designer 链接&#xff1a;https://pan.baidu.com/s/1ic4S3ocEF90Y4L1GqYHPPA?pwdywct 提取码&#xff1a;ywct 3. 可视化UI工具汉化 把上面的链接打开, 里面有安装和汉化包, 前面的路径还要看…
阅读更多...
基于SSM学生信息管理系统

基于SSM学生信息管理系统

采用技术 基于SSM学生信息管理系统的设计与实现~ 开发语言&#xff1a;Java 数据库&#xff1a;MySQL 技术&#xff1a;SpringMVCMyBatis 工具&#xff1a;IDEA/Ecilpse、Navicat、Maven 页面展示效果 总体功能设计 登录页面 后台首页 学生信息页面 添加学生用户 编辑…
阅读更多...
Java代码混淆技术最佳实践与案例分享

Java代码混淆技术最佳实践与案例分享

摘要 本文探讨了代码混淆在保护Java代码安全性和知识产权方面的重要意义。通过混淆技术&#xff0c;可以有效防止代码被反编译、逆向工程或恶意篡改&#xff0c;提高代码的安全性。常见的Java代码混淆工具如IPAGuard、Allatori、DashO、Zelix KlassMaster和yGuard等&#xff0…
阅读更多...
单链表算法库

单链表算法库

singlelist.cpp #include "singlelist.h"/************************************************** ①函数名: CreatList_Head 功 能: 头插法建立单链表 参 数: (1)LinkList *&L: 传入的单链表指针地址(2)ElemType Array_used[]:要用来建表的数组(3)int Array_nu…
阅读更多...
win 11环境配置 之 python（cmd 输入 python --version 输出为空）

win 11环境配置 之 python（cmd 输入 python --version 输出为空）

当我安装好python后&#xff0c;在 cmd 终端输入 python 和 python --version 均无任何输出时&#xff0c;就知道有问题。 在 vscode 下载好 python插件后&#xff0c;编写demo文件&#xff0c;可以执行成功。 因此得出原因是 win 环境变量配置有问题 具体错误问题&#xff1a;…
阅读更多...
BabySQL【2019极客大挑战】

BabySQL【2019极客大挑战】

知识点&#xff1a; 功能分析 登录界面一般是 where username and password 可以从username出手&#xff0c;注释掉and语句单引号闭合绕过 通过测试和报错信息发现是一个单引号读取输入可以单引号闭合绕过关键字过滤 or and 过滤 || &&替换双写绕过select from wher…
阅读更多...
飞凌嵌入式即将亮相德国纽伦堡「Embedded World 2024」

飞凌嵌入式即将亮相德国纽伦堡「Embedded World 2024」

2024年德国纽伦堡嵌入式展览会&#xff08;Embedded World 2024&#xff09;将于4月9日~4月11日盛大开幕&#xff0c;本届展会将展示最新的电子技术与应用&#xff0c;涵盖了半导体、嵌入式系统、电源、电池、测试仪器、智能制造、电子设计自动化等众多领域&#xff0c;并将汇集…
阅读更多...
Aigtek：电压放大器对参数的要求是什么

Aigtek：电压放大器对参数的要求是什么

电压放大器是一种用于增大输入信号幅度的电子设备&#xff0c;它在各种应用中发挥着重要的作用。为了确保电压放大器的性能和可靠性&#xff0c;对其参数有一定的要求。下面安泰电子将介绍电压放大器的几个关键参数&#xff0c;包括增益、带宽、输入/输出阻抗和噪声等&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023