Java线程池大小的设置方法实例

package com.base.demo.design.play;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

  * @Description: 线程池代码

  * @BelongsProject: base-demo-design

  * @BelongsPackage: com.base.demo.design.play

  * @Author: ChenYongJia

  * @CreateTime: 2021-08-14 15:26

  * @Email: chen87647213@163测试数据

  * @Version: 1.0

  */

public class TestThreadPoolExecutor {

     public static void main(String[] args) {

         // 创建使用单个线程的线程池

         ExecutorService es1 = Executors.newSingleThreadExecutor();

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

             es1.submit( new Runnable() {

                 @Override

                 public void run() {

                     System.out.println(Thread.currentThread().getName() + "正在执行任务" );

                 }

             });

         }

         // 创建使用固定线程数的线程池

         ExecutorService es2 = Executors.newFixedThreadPool( 3 );

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

             es2.submit( new Runnable() {

                 @Override

                 public void run() {

                     System.out.println(Thread.currentThread().getName() + "正在执行任务" );

                 }

             });

         }

         // 创建一个会根据需要创建新线程的线程池

         ExecutorService es3 = Executors.newCachedThreadPool();

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

             es3.submit( new Runnable() {

                 @Override

                 public void run() {

                     System.out.println(Thread.currentThread().getName() + "正在执行任务" );

                 }

             });

         }

         // 创建拥有固定线程数量的定时线程任务的线程池

         ScheduledExecutorService es4 = Executors.newScheduledThreadPool( 2 );

         System.out.println( "时间：" + System.currentTimeMillis());

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

             es4.schedule( new Runnable() {

                 @Override

                 public void run() {

                     System.out.println( "时间：" +System.currentTimeMillis()+ "--" +Thread.currentThread().getName() + "正在执行任务" );

                 }

             }, 3 , TimeUnit.SECONDS);

         }

         // 创建只有一个线程的定时线程任务的线程池

         ScheduledExecutorService es5 = Executors.newSingleThreadScheduledExecutor();

         System.out.println( "时间：" + System.currentTimeMillis());

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

             es5.schedule( new Runnable() {

                 @Override

                 public void run() {

                     System.out.println( "时间：" +System.currentTimeMillis()+ "--" +Thread.currentThread().getName() + "正在执行任务" );

                 }

             }, 3 , TimeUnit.SECONDS);

         }

     }

}

public ThreadPoolExecutor( int corePoolSize, //线程池的核心线程数量

         int maximumPoolSize, //线程池的最大线程数

         long keepAliveTime, //当线程数大于核心线程数时，多余的空闲线程存活的最长时间

         TimeUnit unit, //时间单位

         BlockingQueue<Runnable> workQueue, //任务队列，用来储存等待执行任务的队列

         ThreadFactory threadFactory, //线程工厂，用来创建线程，一般默认即可

         RejectedExecutionHandler handler) //拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务

TimeUnit.DAYS;               //天

TimeUnit.HOURS;             //小时

TimeUnit.MINUTES;           //分钟

TimeUnit.SECONDS;           //秒

TimeUnit.MILLISECONDS;      //毫秒

TimeUnit.MICROSECONDS;      //微妙

TimeUnit.NANOSECONDS;       //纳秒

package com.base.demo.design.play;

import java.util.List;

/**

  * @Description: CPU测试

  * @BelongsProject: base-demo-design

  * @BelongsPackage: com.base.demo.design.play

  * @Author: ChenYongJia

  * @CreateTime: 2021-08-14 16:13

  * @Email: chen87647213@163测试数据

  * @Version: 1.0

  */

public class CPUTypeTest implements Runnable {

     /**

      * 整体执行时间，包括在队列中等待的时间

      */

     List<Long> wholeTimeList;

     /**

      * 真正执行时间

      */

     List<Long> runTimeList;

     private long initStartTime = 0 ;

     /**

      * 构造函数

      *

      * @param runTimeList

      * @param wholeTimeList

      * @return

      * @date 2021/8/14 16:13

      * @author ChenYongJia

      * @version 1.0

      */

     public CPUTypeTest(List<Long> runTimeList, List<Long> wholeTimeList) {

         initStartTime = System.currentTimeMillis();

         this .runTimeList = runTimeList;

         this .wholeTimeList = wholeTimeList;

     }

     /**

      * 判断素数

      *

      * @param number

      * @return boolean

      * @date 2021/8/14 16:13

      * @author ChenYongJia

      * @version 1.0

      */

     public boolean isPrime( final int number) {

         if (number <= 1 )

             return false ;

         for ( int i = 2 ; i <= Math.sqrt(number); i++) {

             if (number % i == 0 )

                 return false ;

         }

         return true ;

     }

     /**

      * 计算素数

      *

      * @param lower

      * @param upper

      * @return int

      * @date 2021/8/14 16:14

      * @author ChenYongJia

      * @version 1.0

      */

     public int countPrimes( final int lower, final int upper) {

         int total = 0 ;

         for ( int i = lower; i <= upper; i++) {

             if (isPrime(i))

                 total++;

         }

         return total;

     }

     @Override

     public void run() {

         long start = System.currentTimeMillis();

         countPrimes( 1 , 1000000 );

         long end = System.currentTimeMillis();

         long wholeTime = end - initStartTime;

         long runTime = end - start;

         wholeTimeList.add(wholeTime);

         runTimeList.add(runTime);

         System.out.println( "单个线程花费时间：" + (end - start));

     }

}

package com.base.demo.design.play;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.util.Vector;

/**

  * @Description: IO测试

  * @BelongsProject: base-demo-design

  * @BelongsPackage: com.base.demo.design.play

  * @Author: ChenYongJia

  * @CreateTime: 2021-08-14 16:18

  * @Email: chen87647213@163测试数据

  * @Version: 1.0

  */

public class IOTypeTest implements Runnable {

     /**

      * 整体执行时间，包括在队列中等待的时间

      */

     Vector<Long> wholeTimeList;

     /**

      * 真正执行时间

      */

     Vector<Long> runTimeList;

     private long initStartTime = 0 ;

     /**

      * 构造函数

      *

      * @param runTimeList

      * @param wholeTimeList

      */

     public IOTypeTest(Vector<Long> runTimeList, Vector<Long> wholeTimeList) {

         initStartTime = System.currentTimeMillis();

         this .runTimeList = runTimeList;

         this .wholeTimeList = wholeTimeList;

     }

     /**

      * IO操作

      *

      * @return void

      * @date 2021/8/14 16:18

      * @author ChenYongJia

      * @version 1.0

      */

     public void readAndWrite() throws IOException {

         File sourceFile = new File( "D:/test.txt" );

         //创建输入流

         BufferedReader input = new BufferedReader( new FileReader(sourceFile));

         //读取源文件,写入到新的文件

         String line = null ;

         while ((line = input.readLine()) != null ) {

             //System.out.println(line);

         }

         //关闭输入输出流

         input.close();

     }

     @Override

     public void run() {

         long start = System.currentTimeMillis();

         try {

             readAndWrite();

         } catch (IOException e) {

             // TODO Auto-generated catch block

             e.printStackTrace();

         }

         long end = System.currentTimeMillis();

         long wholeTime = end - initStartTime;

         long runTime = end - start;

         wholeTimeList.add(wholeTime);

         runTimeList.add(runTime);

         System.out.println( "单个线程花费时间：" + (end - start));

     }

}