文章通过一个大厅办理业务的场景比喻，解释了如何使用Java实现任务队列和多线程来异步处理任务。任务被设计为接口，线程类作为处理窗口，任务队列控制任务分配。通过`TaskQueue`类管理任务和线程，`PrintTask`作为任务实例进行演示。文章强调了线程回收的重要性，防止线程无节制增长，影响系统性能。
场景待入
快速理解小场景描述：
【一群人】来到【一个大厅】办理业务，大厅中有【多个窗口】给我们办理业务。
每个人都有自己要办事情，处理过程需要消耗时间。
大厅根据人群多少，开始窗口梳理。
如果把“一群人”理解成一群待处理的n个【任务】，把这群人排成一个长队就形成了一个【任务队列】，“多个窗口”充当我们的【多个线程】异步处理任务队列。我们多线程解决任务队列的代入感来了，有木有！
“大厅”用来充当线程和任务的组装以及处理关系。如：大厅营业start:所有窗口等待办公创建多线程，大厅stop:所有窗口关闭，回收线程。
接下来，就是多个线程异步处理队列任务的干货！
任务类接口
1.首先使我们的任务接口
把这个任务设计成接口，为了后续我们使用的方便宜行，后续去实现接口，我们可以是发短信任务，发邮件任务，等待下载任务等等。
文件：ITask.java
package com.sboot.blog.task;
/**
* 任务的执行体或者携带体 理解成去窗口办事的人
*
* @author zhaoxinglu
*/
public interface ITask {
/**
* 执行体中 自定义任务内容
*/
void run();
}
线程类
2.我们的线程类
这里也就是大厅窗口的一个建设，用来处理任务
文件：TaskExecutor.class
package com.sboot.blog.task;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
/**
* 处理任务的窗口 窗口上班就位执行体办事儿
*
* @author zhaoxinglu
*/
public class TaskExecutor extends Thread {
/**
* 执行体队列
*/
private BlockingQueue<ITask> taskQueue;
/**
* 窗口的当前处理事务状态 初始化：窗口工作状态开启
*/
private boolean isRunning = true;
/**
* 窗口名字 做这个名字为了方便我们观察线程
*/
private String taskName;
public TaskExecutor(BlockingQueue<ITask> taskQueue) {
this.taskQueue = taskQueue;
this.taskName = makeName();
}
/**
* 生成窗口名字
*/
public String makeName(){
String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
Random random = new Random();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 6; ++i) {
int number = random.nextInt(52);// [0,51)
sb.append(str.charAt(number));
}
return sb.toString();
}
/**
* 窗口工作状态关闭
*/
public void quit() {
isRunning = false;
interrupt();
}
@Override
public void run() {
// 窗口工作开启状态时 等待处理事务
while (isRunning) {
ITask iTask;
try {
//任务执行体进来 如果没有时间 继续等待处理事务
iTask = taskQueue.take();
System.out.println("窗口报：" + taskName + "后面还有：" + taskQueue.size() + "下一个来" + taskName);
} catch (InterruptedException e) {
if (!isRunning) {
// 发生意外了，是下班状态的话就把窗口关闭。
interrupt();
// 如果执行到break，后面的代码就无效了。
break;
}
// 发生意外了，不是下班状态，那么窗口继续等待。
continue;
}
// 为这个执行体办事
iTask.run();
}
}
}
任务列表和多线程
3.任务队列和多线程的调配
文件：TaskQueue
package com.sboot.blog.task;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* 任务队列
* 控制执行体和处理窗口的任务队列
*
* @author zhaoxinglu
*/
public class TaskQueue {
/**
* 某场景下 排队办事的执行体
*/
private BlockingQueue<ITask> mTaskQueue;
/**
* 某场景下 处理执行体的多个窗口
*/
public TaskExecutor[] mTaskExecutors;
/**
* 创建队列的时候 设定窗口数量
*
* @param size
*/
public TaskQueue(int size) {
mTaskQueue = new LinkedBlockingQueue<>();
mTaskExecutors = new TaskExecutor[size];
}
/**
* 场景开始启动
*/
public void start() {
//防止存在未关闭窗口 如果有先关闭
stop();
//所有窗口状态：等待处理事务
for (int i = 0; i < mTaskExecutors.length; i++) {
//每初始化一个窗口 都让窗口观望当前执行体队列mTaskQueue
mTaskExecutors[i] = new TaskExecutor(mTaskQueue);
mTaskExecutors[i].start();
}
}
/**
* 场景关闭 所有窗口关闭
*/
public void stop() {
if (mTaskExecutors != null) {
for (TaskExecutor taskExecutor : mTaskExecutors) {
if (taskExecutor != null) {
taskExecutor.quit();
}
}
}
}
/**
* 允许执行体添加进来
*
* @param task
* @param <T>
* @return
*/
public <T extends ITask> int add(T task) {
if (!mTaskQueue.contains((task))) {
mTaskQueue.add(task);
}
//返回当前排队的执行体数
return mTaskQueue.size();
}
public int getTaskQueueSize(){
return mTaskQueue.size();
}
}
实验
4.实例化一种任务 这里模拟打印机功能
文件：PrintTask.java
package com.sboot.blog.task;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 打印执行任务
*
* @author zhaoxinglu
*/
public class PrintTask implements ITask {
private int id;
public PrintTask(int id) {
this.id = id;
}
@Override
public void run() {
try {
Thread.sleep(2000);
System.out.println("干活，等了2s"+Thread.currentThread().getName());
} catch (InterruptedException ignored) {
}
//设置日期格式
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// new Date()为获取当前系统时间
System.out.println(df.format(new Date()));
System.out.println("当前的id:" + id);
System.out.println("wait...");
}
}
异步多线程
5.控制器中根据业务逻辑生成任务队列，创建多线程实现异步任务队列
package com.sboot.blog.sendmsg.controller;
import com.sboot.blog.task.ITask;
import com.sboot.blog.task.PrintTask;
import com.sboot.blog.task.TaskQueue;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
@Api(value = "sendmsg", tags = "发送信息")
@RestController
@RequestMapping("/send")
@Configuration //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling // 2.开启定时任务
public class SendMessageController {
@ApiOperation(value = "打印信息value", notes = "打印note")
@GetMapping(value = "/say")
//@Scheduled(cron = "0/5 * * * * ?")
// //或直接指定时间间隔，例如：5秒
// @Scheduled(fixedRate = 5000)
public String saything() {
//设置日期格式
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// new Date()为获取当前系统时间
System.out.println(df.format(new Date()));
return "test";
}
@ApiOperation(value = "测试窗口队列任务")
@GetMapping(value = "/test")
public String test() {
//场景开启 初始化执行窗口
TaskQueue taskQueue = new TaskQueue(8);
taskQueue.start();
System.out.println("初始化后的窗口length:" + taskQueue.mTaskExecutors.length);
//其他线程可以调用CountDownLatch的countDown()方法来对CountDownLatch中的数字减一， 当数字被减成0后，所有await的线程都将被唤醒。
//辅助方法阻塞 阻塞完成后 后续回收线程 这个方法场景：全部场景结束后，有操作 采用。注意 这个 18 队列完成18个后就会执行后面的【等待完成操作事件】 如果你的队列n<18 你等不到【等待完成操作事件】 如果n>18 你完成【等待完成操作事件】 后 还会继续队列。【等待完成操作事件】在后面有标注
CountDownLatch countDownLatch = new CountDownLatch(18);
for (int i = 0; i < 180; i++) {
PrintTask task = new PrintTask(i);
// int n = taskQueue.add(task);
int n = taskQueue.add(new ITask() {
@Override
public void run() {
try {
Thread.sleep(2000);
System.out.println("干活，等了2s"+Thread.currentThread().getName());
// 执行下面代码计数器减一
countDownLatch.countDown();
} catch (InterruptedException ignored) {
}
}
});
System.out.println("放置第" + i + "个时 队列内人数：" + n);
}
try {
//【等待完成操作事件】 这里的阻塞就是完成等待事件
countDownLatch.await();
System.out.println("队列执行完 回收");
//【关闭业务窗】这里对比 stop()的作用。调用之前，我们的操作窗口，还开着，可以继续往里防止队列处理
//强调对比一下 至此线程还在跑 9999的这个任务会被执行
PrintTask task = new PrintTask(9999);
taskQueue.add(task);
//线程回收
taskQueue.stop();
//【关闭业务窗】这里对比 stop()的作用。调用之后，业务窗口关闭，再添加队列 加不进来了
System.out.println("stop后窗口数:" + taskQueue.mTaskExecutors.length);
//接下来任务111111就不回执行了
PrintTask task1 = new PrintTask(111111);
taskQueue.add(task1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("放完队列后的后的窗口length:" + taskQueue.mTaskExecutors.length);
return "任务跑起来了";
}
}
例子日志
附上异步log:
名人指导
在几位资深钻石段位程序员的围观指正讨论下：
探讨一下 如果我们窗口不回收会怎么样 线程状况如何的
工具观察
借助工具：
运用工具 监控线程：
建立8个线程：
我们不主动回收 完全靠JC回收的状态：
我们在任务执行完毕后回收：
间隔20s执行带有回收机制图形：
间隔20s无回收调用图形：
小结
小总结：
如果这个异步线程调用比较频繁，如我们最后这两张图的展示间隔频率20s,此时在JC机制和JVM还没来得及自行回收线程，我们的下一次调用线程已经出发，会造成我们的线程出线性增长，这样就可能是一个比较危险的操作。条件允许，自行要把进程收回！小波浪稳定性线形图，肯定要比折线增长的安全！
具体主动回收，还是等待机制自己处理，这个需要看我们实际应用的业务场景！
至此结束！
- 多线程
多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理” 。
在计算机编程中，一个基本的概念就是同时对多个任务加以控制。许多程序设计问题都要求程序能够停下手头的工作，改为处理其他一些问题，再返回主进程。可以通过多种途径达到这个目的。最开始的时候，那些掌握机器低级语言的程序员编写一些“中断服务例程”，主进程的暂停是通过硬件级的中断实现的。尽管这是一种有用的方法，但编出的程序很难移植，由此造成了另一类的代价高昂问题。中断对那些实时性很强的任务来说是很有必要的。但对于其他许多问题，只要求将问题划分进入独立运行的程序片断中，使整个程序能更迅速地响应用户的请求 。
最开始，线程只是用于分配单个处理器的处理时间的一种工具。但假如操作系统本身支持多个处理器，那么每个线程都可分配给一个不同的处理器，真正进入“并行运算”状态。从程序设计语言的角度看，多线程操作最有价值的特性之一就是程序员不必关心到底使用了多少个处理器。程序在逻辑意义上被分割为数个线程；假如机器本身安装了多个处理器，那么程序会运行得更快，毋需作出任何特殊的调校。根据前面的论述，大家可能感觉线程处理非常简单。但必须注意一个问题：共享资源！如果有多个线程同时运行，而且它们试图访问相同的资源，就会遇到一个问题。举个例子来说，两个线程不能将信息同时发送给一台打印机。为解决这个问题，对那些可共享的资源来说（比如打印机），它们在使用期间必须进入锁定状态。所以一个线程可将资源锁定，在完成了它的任务后，再解开（释放）这个锁，使其他线程可以接着使用同样的资源。
线程是进程中的一部分，也是进程的的实际运作单位，它也是操作系统中的最小运算调度单位。进程中的一个单一顺序的控制流就是一条线程，多个线程可以在一个进程中并发。可以使用多线程技术来提高运行效率。
多线程是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的 。
- 异步
一、异步和多线程有什么区别？其实，异步是目的，而多线程是实现这个目的的方法。异步是说，A发起一个操作后（一般都是比较耗时的操作，如果不耗时的操作就没有必要异步了），可以继续自顾自的处理它自己的事儿，不用干等着这个耗时操作返回。.Net中的这种异步编程模型，就简化了多线程编程，我们甚至都不用去关心Thread类，就可以做一个异步操作出来。
二、随着拥有多个硬线程CPU（超线程、双核）的普及，多线程和异步操作等并发程序设计方法也受到了更多的关注和讨论。本文主要是想探讨一下如何使用并发来最大化程序的性能
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
