线程池

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10, new DiyThreadFactory());
        for (int i = 0; i <10 ; i++) {
            scheduledExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }


 自定义ThreadFactory
class DiyThreadFactory implements ThreadFactory{
     ThreadGroup group =new  ThreadGroup("CONSUMER");
      private  static String namePrefix="_ORDER_";
    private final AtomicInteger threadNumber = new AtomicInteger(1);

    @Override
    public Thread newThread(Runnable runnable) {
        Thread thread = new Thread(group, runnable,
                group.getName()+namePrefix+threadNumber.getAndIncrement());
        return thread;
    }
}

/** * newSingleThreadExecutor 
* 创建单个线程 创建固定1核心同时最大数量也是1个数线程 
大于最大线程池数量1时：将按照顺序执行，
当大于最大Integer时默认直接拒绝 
*new LinkedBlockingQueue<Runnable>() * * *

 * newFixedThreadPool 创建固定核心个数线程 
* 大于最大线程池数量时：默认直接拒绝 
*new LinkedBlockingQueue<Runnable>() * * * * 

newScheduledThreadPool 
* 创建具有调度任务的线程 可以配置核心线程数量和制定工厂 * 
大于最大线程池数量时：默认直接拒绝 
*new DelayedWorkQueue()

*  newCachedThreadPool
 * 创建的线程具有重新使用 可以指定创建线程使用的工厂
 *最小核心数为0，最大为INTEGER最大值 
* 线程存活时间为60s，60s没被使用将销毁 
* 大于最大线程池数量时：默认直接拒绝 
* new SynchronousQueue<Runnable> 异步执行
 * *
* executor.invokeAny(callables)返回线程集合其中一个执行完成的结果 
* executor.invokeAll(callables)返回线程集合所有的执行结果 *
 * executor.submit()有返回结果
 * executor.execute()没回结果
 */

 

//        创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
//        execute 执行但不会返回结果   这个方法有个问题，就是没有办法获知task的执行结果。如果我们想获得task的执行结果，我们可以传入一个Callable的实例
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //异步执行
        for (int i = 0; i <10 ; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("如果帅有罪，请把我埋葬");
                }
            });

        }
        Thread.sleep(1000);
        executorService.shutdownNow();

 

//        这个方法有个问题，就是没有办法获知task的执行结果。如果我们想获得task的执行结果，我们可以传入一个Callable的实例
//        创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
//        executor.submit  执行会有返回结果， future.get()获取结果会阻塞线程
        ExecutorService executorService2 = Executors.newFixedThreadPool(2);
        //异步执行
        executorService2.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("cafa babe");
            }
        });
        Future<String> future1 = executorService2.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "蛟龙入海";
            }
        });
        Future future2 = executorService2.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("鹰击长空");
            }
        });
        Object o1 = future1.get();
        Object o2 = future2.get();
        System.out.println(o1);
        System.out.println(o2);
        executorService2.shutdown();

 

//        invokeAny 返回执行某个线程执行的结果
        ExecutorService executorSingleService = Executors.newFixedThreadPool(3);
        Set<Callable<String>> callables = new HashSet<Callable<String>>();

        callables.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 1";
            }
        });
        callables.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 2";
            }
        });
        callables.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 3";
            }
        });

        String result = executorSingleService.invokeAny(callables);
        System.out.println("result = " + result);


//        invokeAll   返回所有线程返回的结果
        Set<Callable<String>> callables0 = new HashSet<Callable<String>>();
        callables0.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 1";
            }
        });
        callables0.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 2";
            }
        });
        callables0.add(new Callable<String>() {
            public String call() throws Exception {
                return "Task 3";
            }
        });

        List<Future<String>> futures = executorSingleService.invokeAll(callables0);
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>:" + JSON.toJSONString(futures));
        executorSingleService.shutdown();

 

//      定时任务
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10, Executors.defaultThreadFactory());
//        延迟三秒执行
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟三秒执行");
            }
        }, 3, TimeUnit.SECONDS);

//        延迟三秒后每三秒执行一次
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟三秒后执行三秒");
            }
        }, 3, 3, TimeUnit.SECONDS);

//        第一次执行延迟三秒，然后每三秒执行一次
        scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("第一次执行延迟三秒，然后每三秒执行一次");
            }
        }, 3, 3, TimeUnit.SECONDS);
        Thread.sleep(1000000);
        scheduledExecutorService.shutdown();

 

       //线程池里面的线程数会动态变化，并可在线程线被移除前重用,可以使用之前的线程
        ExecutorService threadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= 20; i++) {
            int finalI = i;
            threadPool.execute(new Runnable() {    //接受一个Runnable实例
                public void run() {
                    System.out.println("线程名字： " + Thread.currentThread().getName() + "  任务名为： " + finalI);
                }
            });
        }

        threadPool.shutdown();

 

  //核心线程，最大线程数，存活时间，时间单位，队列
            ThreadPoolExecutor threadPoolExecutor1=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS,new LinkedBlockingDeque<>());
            //核心线程，最大线程数，存活时间，时间单位，队列，工厂方式
            ThreadPoolExecutor threadPoolExecutor2=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS,new LinkedBlockingDeque<>(), Executors.defaultThreadFactory());
            //核心线程，最大线程数，存活时间，时间单位，队列，大于最大线程数策略
            ThreadPoolExecutor threadPoolExecutor3=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS, new LinkedBlockingDeque<>(),new ThreadPoolExecutor.AbortPolicy());
            //核心线程，最大线程数，存活时间，时间单位，队列，工厂方式，大于最大线程数策略，
            ThreadPoolExecutor threadPoolExecutor4=new ThreadPoolExecutor(1,1, 1,TimeUnit.SECONDS,new LinkedBlockingDeque<>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
            threadPoolExecutor4.execute();
            threadPoolExecutor4.submit();