了解线程池

/**
 *  Executor: 线程池接口的根类。   void execute(Runnable command); 执行任务方法。
 *     ExecutorService: 线程池根类下的子接口。
 *         shutdown():关闭线程池，如果线程池中还有为执行完的任务则需要等待任务执行完毕后在关闭。
 *         shutdownNow():立即关闭。
 *         isShutdown(): 是否关闭
 *         isTerminated():是否终结
 *         submit(): 提交任务给线程
 *  Executors: 线程池的一个工具类。 可以帮你创建线程池对象，
 *

public class Test {
    public static void main(String[] args) {
          //创建一个固定长度的线程池。
//          ExecutorService executorService = Executors.newFixedThreadPool(3);
          //创建一个可扩容的线程池
//        ExecutorService executorService = Executors.newCachedThreadPool();
         //创建单一线程池  任务队列。
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //提交任务给线程池，线程池会给该任务分配线程对象。
        for(int i=0;i<2;i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + "~~~~~~" + i);
                    }
                }
            });
        }
        executorService.shutdown();

    }
}

public class Test02 {
    public static void main(String[] args) {
        //因为实现类的参数个数非常多。所以使用工具类来创建线程池。
        // 习惯用实现类。更加灵魂。
//           int corePoolSize, 核心的个数初始化的个数。
//        int maximumPoolSize, 最大的个数
//        long keepAliveTime,  保持活跃的时间。
//         TimeUnit unit, 单位
//        BlockingQueue<Runnable> workQueue: 堵塞队列。

        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue(10);
        ExecutorService executorService=new ThreadPoolExecutor
                (2,5,10,TimeUnit.SECONDS,workQueue);

        for (int i = 0; i <15 ; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j <20 ; j++) {
                        System.out.println(Thread.currentThread().getName()+"~~~~~~~~"+j);
                    }
                }
            });
        }

        executorService.shutdown();
    }
}

public class Test {
//    public static void main(String[] args) throws Exception{
//         MyCallable myCallable=new MyCallable();//创建任务对象
//         FutureTask futureTask=new FutureTask(myCallable); //任务对象
//         Thread t=new Thread(futureTask);
//         t.start();
//
//         //获取任务执行的结果时，他会等待任务执行完毕后在输出
//        System.out.println(futureTask.get());//获取任务执行的结果
//        //思考:这种实现执行callable任务的代码复杂。 callable任务习惯和线程池一起使用。
//    }
public static void main(String[] args) throws Exception {
    ExecutorService executorService = Executors.newFixedThreadPool(2);
    MyCallable myCallable=new MyCallable();//创建任务对象
    Future<Integer> future = executorService.submit(myCallable);
    //submit可以提交callable类型的任务也可以提交runnable类型的任务；
    //返回Future对象，该对象就是把任务执行的结果封装为Future类对象。
    System.out.println(future.get());
}
}
//通过线程完成1~100的和
class MyCallable implements Callable<Integer>{

    public int sum=0;
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i <101 ; i++) {
            Thread.sleep(100);
            sum+=i;
        }
        return sum;
    }
}
class MyRunnable implements  Runnable{

    @Override
    public void run() {

    }
}