线程池

Java线程池

 * 线程池的重要性： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大降低系统的效率，因为创建和销毁都需时间

 * 所以在Java中可以通过线程池来达到使线程复用，执行完一个任务之后并不会被销毁 在Java中实现线程池的类 ThreadPoolExecutor

 *

 * Java通过Executor提供四种线程池

 * 1、newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收空闲线程，则新建线程

 * 2、newFixedThreadPool 创建一个定长（长度固定）线程池，可控制线程最大并发数，超出的线程会在队列中等待

 * 3、newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行

 * 4、newSingleThreadPool

 * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，从而保证所有任务按照指定顺序执行

1、newCachedThreadPool

     

  ExecutorService cachedThreadPool ;
       cachedThreadPool = Executors.newCachedThreadPool();
        for(int i=0;i<20;i++){
            final int index = i;
            try{
                //Thread.sleep(1000);
           } catch(Exception ex){
               ex. printStackTrace();
           }
           cachedThreadPool.execute( new Runnable(){

                public void run() {
                   // TODO Auto-generated method stub
                   System. out.println(index);
                  System. out.println("使用的线程编号是：" +Thread.currentThread ().getId());

               }

           });
       }

        //该线程池为无限大，当执行第二个任务时，第一个任务已经完成，所以会去复用执行第一个任务的线程，而不用每次新建线程。

2、newFixedThreadPool

      

 ExecutorService fixedThreadPool;
       fixedThreadPool = Executors.newFixedThreadPool(5);
        for(int i=0;i<20;i++){
            final int index=i;
           fixedThreadPool.execute( new Runnable(){

                public void run() {
                   // TODO Auto-generated method stub
                   try{
                      System. out.println(index);
                      System. out.println("使用的线程编号是：" +Thread.currentThread ().getId());

                  } catch(Exception ex){
                      ex.printStackTrace();
                  }
               }

           });
       }

 3、newScheduledThreadPool 延迟执行

    

   ScheduledExecutorService scheduledThreadPool;
       scheduledThreadPool = Executors.newScheduledThreadPool(3);
       System. out.println("开始执行" );
       scheduledThreadPool.schedule( new Runnable() {
            public void run() {
                // TODO Auto-generated method stub
               System. out.println("延迟3秒执行,使用的线程编号是："
                      + Thread.currentThread().getId());
           }
       }, 1000, TimeUnit. MILLISECONDS);

      newScheduledThreadPool 定期执行

    

   ScheduledExecutorService scheduledThreadPool;
        scheduledThreadPool = Executors.newScheduledThreadPool(3);
       System. out.println("开始执行" );
         scheduledThreadPool.scheduleAtFixedRate( new Runnable() {

            public void run() {
                // TODO Auto-generated method stub
               System. out.println("你好啊！我现在用的线程编号是："
                      + Thread.currentThread().getId());
           }
       }, 5, 2, TimeUnit. SECONDS);
        // 延迟5秒后，每隔2秒执行一次

4、newSingleThreadExecutor

      

 ExecutorService singleThreadExecutor;
       singleThreadExecutor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            final int index = i;
           singleThreadExecutor.execute( new Runnable() {

                public void run() {
                   // TODO Auto-generated method stub
                   System. out.println(index);
                  System. out.println( "正在使用线程" +Thread.currentThread ().getId());
//                System.out.println("正在打印" + index + ",使用的线程编号是："
//                        + Thread.currentThread().getId());
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
               }
           });

            //通过结果，可以看出打印的顺序是依次执行的，相当于顺序执行每一个任务