常用的线程池方式

第一种：

package com.xxl.job.executor.service.datatask.warnconf.sender;

import java.net.URLEncoder;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;
import com.grand.common.Enum.Type;
import com.grand.common.utils.HttpUtils;
import com.grand.common.utils.SystemUtils;
import com.xxl.job.executor.service.datatask.SysUserPushService;
import com.xxl.job.executor.service.datatask.warnconf.confservice.WxConfService;
import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONObject;


//调用微信服务号的接口推送消息
@Slf4j
@Service
public class WxMsgSender {
    
    @Resource
    private WxConfService wxConfService;
    @Resource
    private SysUserPushService sysUserPushService;
    private final static ArrayBlockingQueue<Runnable> WORK_QUEUE = new ArrayBlockingQueue<>(500);
    private static ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 10, 20, TimeUnit.SECONDS, WORK_QUEUE);
    
    public String sendWxMsg(String title, String content, String remark, String id, Type warnType, Set<String> openidSet,Object time) {
        if(StringUtils.isEmpty(title) 
            || StringUtils.isEmpty(content) 
            || StringUtils.isEmpty(remark) 
            || StringUtils.isEmpty(id) 
            || warnType==null 
            || openidSet==null || openidSet.size()==0
        ) {
            return "error";
        }
        JSONObject json = new JSONObject();
        if(time==null || time.toString().trim().equals("")) {
            time = SystemUtils.getNowDate("yyyy-MM-dd HH:mm:ss");
        }
        json.put("time", time);
        json.put("title", title);
        json.put("content", content);
        json.put("remark", remark);
        json.put("id", id);
        json.put("warnType", warnType.getValue());
        
        // 微信告警消息推送
        for (String openid : openidSet) {
            // 循环调用微信下发消息服务
            pool.execute(()->{
                try {
                    String passport = wxConfService.getPassportByOpenid(openid);
                    json.put("openid", openid);
                    json.put("passport", passport);
                    Map<String,Object> pushConf = sysUserPushService.getPushConf(passport);
                    if(pushConf!=null && pushConf.get("weixin").toString().equals("1")) {
                        HttpUtils.sendGet("http://xxx.xxx.xxx.cn/weichat/wx/pushMessage", toParam(json));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    log.error(e.getMessage(),e);
                }
            });
         
        }
        return    "success";
    }
    
    private String toParam(JSONObject json) {
        StringBuffer sb = new StringBuffer();
        String value = null;
        for (Object key : json.keySet()) {
            try {
                value = json.get(key).toString();
                sb.append("&"+key+"="+URLEncoder.encode(value, "utf-8"));
            } catch (Exception e) {
                e.printStackTrace();
                log.error(e.getMessage(),e);
            }
        }
        if(sb.length()>0) {
            return sb.substring(1);
        }
        return null;
    }
    
}

第二种：

package demo.syn;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * callable 跟runnable的区别：
 * runnable的run方法不会有任何返回结果，所以主线程无法获得任务线程的返回值
 * 
 * callable的call方法可以返回结果，但是主线程在获取时是被阻塞，需要等待任务线程返回才能拿到结果
 * @author
 *
 */
public class SynDemo {
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newFixedThreadPool(4); 
        
        for(int i = 0; i < 10; i++){
            Future<String> submit = pool.submit(new Callable<String>(){
             
                public String call() throws Exception {
                    Thread.sleep(5000);
                    System.out.println("b--"+Thread.currentThread().getName() +" 我在线程里面执行");
                    return "b--"+Thread.currentThread().getName();
                }               
               });
            //从Future中get结果，这个方法是会被阻塞的，一直要等到线程任务返回结果
            System.out.println("我不是阻塞的，啦啦啦啦");
            System.out.println(submit.get());
        } 
            pool.shutdown();
    }
    
}