java线程池任务队列

        // 创建Callable任务
        List<Callable<Void>> tasks = new ArrayList<>();
        int numThreads = Runtime.getRuntime().availableProcessors(); // 获取处理器数量
        //ExecutorService executor = Executors.newFixedThreadPool(numThreads);

　　　　　　ExecutorService pool = new ThreadPoolExecutor(numThreads, 2 * numThreads, 1000, TimeUnit.MILLISECONDS, 
    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　new LinkedBlockingQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());

tasks.add(() -> {
    ......
    return null;
                    });

 

Runnable task = new Runnable() {
@Override
public void run() {
..................
}
};

 

try {
ClientInstanceMgr.getInstance().pool1.execute(task);
} catch (Exception e) {
log.error(TimeConvertUtil.getTimeStrNow() +",10Data,error:" +e.getMessage());
}

 

        


//执行任务并等待完成
        try {
            pool.invokeAll(tasks);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 关闭线程池
        pool.shutdown();

 

@Slf4j
public class ClientInstanceMgr {

    public ExecutorService pool = null;

    private static class ClientInstanceMgrHolder
    {
        private static final ClientInstanceMgr m_instance = new ClientInstanceMgr();
    }

    public static ClientInstanceMgr getInstance()
    {
        return ClientInstanceMgrHolder.m_instance;
    }


    private ClientInstanceMgr()
    {
        int numThreads = Runtime.getRuntime().availableProcessors(); // 获取处理器数量
        log.info("[ClientInstanceMgr]numThreads " + numThreads );
        pool = new ThreadPoolExecutor(numThreads, 10 * numThreads, 1000, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());
    }

    private final ReentrantLock m_ClientInstanceLock = new ReentrantLock();


    private final ConcurrentHashMap<Channel, ClientInstance> m_hmClientInstance = new ConcurrentHashMap<Channel, ClientInstance>();

    public void addClientInstance(Channel _channel, ClientInstance _oClientInstance)
    {
        m_hmClientInstance.put(_channel, _oClientInstance);
    }

    public void removeClientInstance(Channel _channel)
    {
        m_hmClientInstance.remove(_channel);
    }

    public ClientInstance getClientInstance(Channel _channel)
    {
        return m_hmClientInstance.get(_channel);
    }

    public boolean update(Channel key, ClientInstance newClientInstance){
        newClientInstance.updateTime();
        ClientInstance oldClientInstance = m_hmClientInstance.get(key);
        if (oldClientInstance != null) {

            return m_hmClientInstance.replace(key, oldClientInstance, newClientInstance);
        }
        return false;

    }

    public LinkedList<ClientInstance> getClientInstanceList()
    {
        LinkedList<ClientInstance> lstClientInstance = null;
        m_ClientInstanceLock.lock();

        try
        {

            if (!m_hmClientInstance.isEmpty())
            {
                lstClientInstance  = new LinkedList<ClientInstance>();
                Iterator<Map.Entry<Channel, ClientInstance>> iter = m_hmClientInstance.entrySet().iterator();
                while (iter.hasNext())
                {
                    Map.Entry<Channel, ClientInstance> entry = iter.next();
                    ClientInstance oClientInstance = entry.getValue();
                    if(oClientInstance  != null  &&  oClientInstance.getChannel() != null
                        && StringUtils.isNotBlank(oClientInstance.getTern()))
                    {
                        lstClientInstance.add(oClientInstance);
                    }

                }
            }
        }
        finally
        {
            m_ClientInstanceLock.unlock();
        }

        return lstClientInstance;
    }

}