Java四种常用线程池的详细介绍

package com.study.test;

import java.util.concurrent.executorservice;

import java.util.concurrent.executors;

public class threadpoolexecutortest {

   public static void main(string[] args) {

    //创建一个可缓存线程池

    executorservice cachedthreadpool = executors.newcachedthreadpool();

    for ( int i = 0 ; i < 10 ; i++) {

      try {

        //sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程

        thread.sleep( 1000 );

      } catch (interruptedexception e) {

        e.printstacktrace();

       }

      cachedthreadpool.execute( new runnable() {

        public void run() {

     //打印正在执行的缓存线程信息

           system.out.println(thread.currentthread().getname()+ "正在被执行" );

        }

       });

     }

   }

}

package com.study.test;

import java.util.concurrent.executorservice;

import java.util.concurrent.executors;

public class threadpoolexecutortest {

  public static void main(string[] args) {

     //创建一个可重用固定个数的线程池

     executorservice fixedthreadpool = executors.newfixedthreadpool( 3 );

     for ( int i = 0 ; i < 10 ; i++) {

      fixedthreadpool.execute( new runnable() {

         public void run() {

           try {

            //打印正在执行的缓存线程信息

            system.out.println(thread.currentthread().getname()+ "正在被执行" );

            thread.sleep( 2000 );

          } catch (interruptedexception e) {

            e.printstacktrace();

           }

         }

      });

     }

   }

}

package com.study.test;

import java.util.concurrent.executors;

import java.util.concurrent.scheduledexecutorservice;

import java.util.concurrent.timeunit;

public class threadpoolexecutortest {

   public static void main(string[] args) {

     //创建一个定长线程池，支持定时及周期性任务执行——延迟执行

     scheduledexecutorservice scheduledthreadpool = executors.newscheduledthreadpool( 5 );

     //延迟1秒执行

     scheduledthreadpool.schedule( new runnable() {

       public void run() {

         system.out.println( "延迟1秒执行" );

       }

     }, 1 , timeunit.seconds);

    }

}

package com.study.test;

import java.util.concurrent.executors;

import java.util.concurrent.scheduledexecutorservice;

import java.util.concurrent.timeunit;

public class threadpoolexecutortest {

   public static void main(string[] args) {

     //创建一个定长线程池，支持定时及周期性任务执行——定期执行

     scheduledexecutorservice scheduledthreadpool = executors.newscheduledthreadpool( 5 );

     //延迟1秒后每3秒执行一次

     scheduledthreadpool.scheduleatfixedrate( new runnable() {

        public void run() {

         system.out.println( "延迟1秒后每3秒执行一次" );

       }

     }, 1 , 3 , timeunit.seconds);

   }

}

package com.study.test;

import java.util.concurrent.executorservice;

import java.util.concurrent.executors;

public class testthreadpoolexecutor {

   public static void main(string[] args) {

     //创建一个单线程化的线程池

     executorservice singlethreadexecutor = executors.newsinglethreadexecutor();

     for ( int i = 0 ; i < 10 ; i++) {

       final int index = i;

        singlethreadexecutor.execute( new runnable() {

         public void run() {

           try {

             //结果依次输出，相当于顺序执行各个任务

             system.out.println(thread.currentthread().getname()+ "正在被执行,打印的值是:" +index);

             thread.sleep( 1000 );

           } catch (interruptedexception e) {

              e.printstacktrace();

           }

         }

        });

     }

    }

}

package com.study.test;

import java.util.concurrent.arrayblockingqueue;

import java.util.concurrent.blockingqueue;

import java.util.concurrent.threadpoolexecutor;

import java.util.concurrent.timeunit;

class tempthread implements runnable {

   @override

   public void run() {

     // 打印正在执行的缓存线程信息

     system.out.println(thread.currentthread().getname() + "正在被执行" );

      try {

       // sleep一秒保证3个任务在分别在3个线程上执行

       thread.sleep( 1000 );

      } catch (interruptedexception e) {

        e.printstacktrace();

     }

    }

}

public class testthreadpoolexecutor {

   public static void main(string[] args) {

     // 创建数组型缓冲等待队列

     blockingqueue<runnable> bq = new arrayblockingqueue<runnable>( 10 );

     // threadpoolexecutor:创建自定义线程池，池中保存的线程数为3，允许最大的线程数为6

     threadpoolexecutor tpe = new threadpoolexecutor( 3 , 6 , 50 , timeunit.milliseconds, bq);

     // 创建3个任务

      runnable t1 = new tempthread();

      runnable t2 = new tempthread();

      runnable t3 = new tempthread();

      // runnable t4 = new tempthread();

      // runnable t5 = new tempthread();

      // runnable t6 = new tempthread();

      // 3个任务在分别在3个线程上执行

      tpe.execute(t1);

      tpe.execute(t2);

      tpe.execute(t3);

      // tpe.execute(t4);

      // tpe.execute(t5);

      // tpe.execute(t6);

      // 关闭自定义线程池

      tpe.shutdown();

    }

}