线程池

package com.icefrog.async.export.handler;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class GlobalTaskService {
    private ExecutorService taskExecutorService;

    public GlobalTaskService() {
        this.taskExecutorService = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors() << 1, Runtime.getRuntime().availableProcessors() << 2, 120L, TimeUnit.SECONDS, new LinkedBlockingDeque(), new ThreadFactory() {
            private AtomicInteger atomicInteger = new AtomicInteger(0);

            public Thread newThread(Runnable r) {
                return new Thread(r, "tasker-" + this.atomicInteger.incrementAndGet());
            }
        });
    }


    public void registerTaskListener(Runnable runnable) {
        this.taskExecutorService.execute(runnable);
    }

    public <V> Future<V> registerFutureListener(Callable<V> callable) {
        return this.taskExecutorService.submit(callable);
    }

    public static void main(String[] args) {
//        System.out.println(Runtime.getRuntime().availableProcessors() << 1);
//        System.out.println(Runtime.getRuntime().availableProcessors() << 2);
        Object data = new Object();
        data = "sadfsaddfsaf";
        GlobalTaskService globalTaskService = new GlobalTaskService();
        ReentrantLock lock = new Locker().getLock("sadfdsafa");
        try {
            lock.lock();
            globalTaskService.registerTaskListener(new RunnableWrapper<Object>(data) {
                @Override
                public void run(Object data) {
                    System.out.println("data:" + data);
                }
            });
        } finally {
            lock.unlock();
        }
    }

    abstract static class RunnableWrapper<T> implements Runnable {
        private final T data;

        public RunnableWrapper(T data) {
            this.data = data;
        }

        @Override
        public void run() {
            run(data);
        }

        public abstract void run(T data);
    }


    static class Locker {

        private ConcurrentHashMap<String, ReentrantLock> lockHashMap = new ConcurrentHashMap<>();

        public ReentrantLock getLock(String key) {
            ReentrantLock reentrantLock = lockHashMap.get(key);
            if (reentrantLock == null) {
                reentrantLock = new ReentrantLock();
                if (lockHashMap.putIfAbsent(key, reentrantLock) == null) {
                    return reentrantLock;
                } else {
                    return lockHashMap.get(key);
                }
            }
            return reentrantLock;
        }
    }
}