大家好,我是烤鸭:
今天给大家说的是多线程并发的异步监听的情况。
这里不得不说一下CompletableFuture这个类,普通我们执行多线程的时候只需要另外启动一条线程。
说一下线程的3种方式:
如果他们有没执行完的,主线程就一直等。这样就分工明确了,主线程的任务就是监视其他是否完毕,
今天给大家说的是多线程并发的异步监听的情况。
这里不得不说一下CompletableFuture这个类,普通我们执行多线程的时候只需要另外启动一条线程。
说一下线程的3种方式:
extends Thread,implements Runnable,implements Callable。
同步的实现方式有很多。这里贴一下我的。
这个handler是可以注入其他的比如service或者dao,完成业务逻辑,我这里是注入的redis。
package com.mys.my.wechat.handler;
import com.mys.my.wechat.config.redis.RedisClient;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Executor;
@Service("musicHandler")
public class MusicHandler {
public static Log logger = LogFactory.getLog(MusicHandler.class);
public String redisString;
public String openId;
@Autowired
private RedisClient redisClient;
@Autowired
private Executor taskAsyncPool;
public void doAllHandler() {
try {
taskAsyncPool.execute(new Runnable() {
@Override
public void run() {
logger.info("xiami 任务启动");
Date time = new Date();
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// String re_StrTime = sdf.format(time);
//过期时间1小时
redisClient.set("xiamiMusic:"+openId,redisString,60*60);
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}
调用:
//存redis
musicHandler.redisString = toJson;
musicHandler.openId = openId;
musicHandler.doAllMusicHandler();
以上就是同步调用,但是这样只是执行,你无法监听结果。
我现在说一下场景:
烧水的同时,洗衣机洗衣服,电脑下载,手机充电,我们生活中也会有同时干几件事的情况,而需求是这几件事都干完了我才能出门,多线程确实能执行,但是怎么监听结果呢。
以上也许可以说时间是可以预测的。
但是具体的业务场景,如果需要你去调用4个接口,而他们之间的没有任何影响,但是又必须4个接口都执行完才能返回数据。这样如果实现多线程的异步监听呢?
最常用的就是爬虫,我想同时抓取几个网站或者几个网页的数据,如果是单线程,效率很低。多线程又必须保证每条线程完成抓取并返回数据。以下是一个小例子。
用CompletableFuture,代码如下:
package com.mys.my.wechat.service.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.CompletableFuture;
final Integer res = 0;
final ArrayList<Integer> integers = new ArrayList<>();
CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
//模拟执行耗时任务
System.out.println("task 1 doing...");
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
//返回结果
return 1;
});
//注册完成事件
completableFuture1.thenAccept(result -> {
integers.add(1);
});
CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
//模拟执行耗时任务
System.out.println("task 2 doing...");
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
//返回结果
return 1;
});
//注册完成事件
completableFuture2.thenAccept(result -> {
integers.add(1);
});
CompletableFuture<Integer> completableFuture3 = CompletableFuture.supplyAsync(() -> {
//模拟执行耗时任务
System.out.println("task 3 doing...");
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
//返回结果
return 1;
});
//注册完成事件
completableFuture3.thenAccept(result -> {
integers.add(1);
});
while(true){
try {
Thread.sleep(1000);
if(integers.size()== 3){
System.out.println("done");
break;
}
System.out.println("s:"+integers.size());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
这里我们可以看到,主线程一直在监听,其他新开启的3个线程,如果他们执行完毕,就可以返回数据,
如果他们有没执行完的,主线程就一直等。这样就分工明确了,主线程的任务就是监视其他是否完毕,
而同时开启3条线程执行速度也会很快。
这只是一个demo和想法实现,欢迎交流。