java基础-并发socekt异步计算

我们有一个需求，需要使用socket技术和多个业务同时通信，根据多个业务的返回结果来判断成功与否，
每个业务通信的时间长度不一致，且全部成功才是最终成功，有一个失败即是失败。这时候，我们可以采用java并发包中的异步计算返回结果。关键代码如下
private ReturnInfo run(HashMap<String,List<ReqContent>> map,String reqtype) throws ConfigurationException {
ReturnInfo res = new ReturnInfo();
try {
// 执行任务
List<Callable<ResMessage>> list = wrapTask(map,reqtype);
SocketService service = new SocketService(list);
List<Future<ResMessage>> futures = service.execute();

// 获取任务结果
Iterator it = futures.iterator();
String[] results = new String[list.size()];
String[] resultsmsg = new String[list.size()];
int i = 0;
while(it.hasNext()){
Future<ResMessage> fu = (Future<ResMessage>) it.next();
try {
results[i] = fu.get().getContent().getYdlx();
resultsmsg[i] = fu.get().getContent().getYdms();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
i++;
}

// 分析任务结果
res = parseTask(results,res,resultsmsg);
} catch (Exception e) {
e.printStackTrace();
res.setResultcode("-1");
res.setResultmsg("系统失败");
}
return res;
}

public class SocketService {
private List<Callable<ResMessage>> tasks;
private ExecutorService service;
public SocketService(List<Callable<ResMessage>> tasks){
this.tasks = tasks;
this.service = Executors.newCachedThreadPool();
}

public List<Future<ResMessage>> execute(){
try {
List<Future<ResMessage>> list = service.invokeAll(tasks);
return list;
} catch (InterruptedException e) {
e.printStackTrace();
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}

public class SocketTask implements Callable{
private List<ReqContent> reqContent;
private String reqTarget;
private String reqSn;
private String reqVersion;
private String reqType;
private String reqLy;
private SpringService springService =(SpringService)SpringContextUtil.getBean("springService");
private BossSocket socket;
private String reqKey;

public SocketTask(String reqVersion,String reqLy,String reqKey,List<ReqContent> reqContent,String reqTarget,String reqSn,String reqType) throws ConfigurationException, UnknownHostException, IOException{
// 根据产品名称 配置连接池
if(reqTarget.equals(SocketConstants.ECP)){
this.socket = EcpSocketConnPool.getSocket();
}

this.reqContent = reqContent;
this.reqTarget = reqTarget;
this.reqSn = reqSn;
this.reqType = reqType;
this.reqKey = reqKey;
this.reqLy = reqLy;
this.reqVersion = reqVersion;
}

public ResMessage call() throws Exception {
return sendAndReceived();
}

private ResMessage sendAndReceived() throws Exception{
ReqHead reqHead = MessageWrapper.warpHead(reqVersion, reqSn, reqType, reqLy, reqTarget);
ReqMessage req = new ReqMessage(reqHead,reqContent);
ResMessage res = new ResMessage();
SpringBw bw = insertBw(req.toString());
String result;
try{
BaseDesSecurity sec = new BaseDesSecurity();
String reqMsg = sec.encode(req.toString(),reqKey);
String resMsg = socket.SendAndRecv(reqMsg.getBytes();
res = MessageUtil.decode(resMsg,reqKey);
System.out.println("接收到的信息");
if(res.getContent().getYdlx().equals("0")){
result = "成功";
} else if(res.getContent().getYdlx().equals("-1")){
result = "失败";
} else {
result = "部分成功";
}
return res;
} catch (Exception e) {
e.printStackTrace();
return processException(e,bw);
}
}