java 线程池使用

四种线程池使用

参考文档:

https://blog.csdn.net/qq_36881887/article/details/125707550

https://www.jianshu.com/p/7726c70cdc40

http://gityuan.com/2016/01/16/thread-pool/

https://www.cnblogs.com/dolphin0520/p/3949310.html

Executors类（并发包）提供了4种创建线程池方法 ;

这些方法最终都是通过配置ThreadPoolExecutor的不同参数，来达到不同的线程管理效果。

newCacheTreadPool( )

创建一个不限线程数上限的线程池,任何提交的任务都将立即执行

基本使用:

public static void demo(){
 //创建一个不限制最大线程数量的线程池
 ExecutorService executorService = Executors.newCachedThreadPool();

 //重写 Runnable 的run 方法
 Runnable runnable = new Runnable() {
     @Override
     public void run() {
         content();
     }
 };

 for (int i = 0; i < 100; i++) {
     //调用 .execute(Runnable runnable) 方法将 runnable 放入线程池中执行
     executorService.execute(runnable);
 }
 //关闭线程池
 executorService.shutdown();
}

使用lambda表达式创建:

public static void lambdaDemo(){
 //创建一个不限制最大线程数量的线程池
 ExecutorService executorService = Executors.newCachedThreadPool();


 for (int i = 0; i < 100; i++) {
     //使用lambda执行
     executorService.execute(()->{
         content();
     });
 }
 //关闭线程池
 executorService.shutdown();
}

执行内容:

private static void  content(){
 System.out.println("当前线程名:"+Thread.currentThread().getName()+" 开始+++");
 try {
     Thread.sleep(100);
 } catch (InterruptedException e) {
     e.printStackTrace();
 }
 System.out.println("当前线程名:"+Thread.currentThread().getName()+" 结束---");
}

newFixedThread( )

创建一个定长的线程池，可控制最大并发数，超出的线程进行队列等待。

基本创建:

public static void demo(){
 //创建一个最大连接数为:5 的线程池
 ExecutorService executorService = Executors.newFixedThreadPool(5);

 //重写Runnable 的run 方法
 Runnable runnable = new Runnable() {
     @Override
     public void run() {
         content();
     }
 };

 for (int i = 0; i < 100; i++) {
     //调用 .execute(Runnable r) 方法将 r 放入线程池中执行
     executorService.execute(runnable);
 }
 //关闭线程池
 executorService.shutdown();
}

使用lambda表达式创建:

public static void lambdaDemo(){
 //创建一个不限制最大线程数量的线程池
 ExecutorService executorService = Executors.newFixedThreadPool(5);


 for (int i = 0; i < 100; i++) {
     //使用lambda执行
     executorService.execute(()->{
         content();
     });
 }
 //关闭线程池
 executorService.shutdown();
}

执行内容:

private static void  content(){
 System.out.println("当前线程名:"+Thread.currentThread().getName()+" 开始+++");
 try {
     Thread.sleep(100);
 } catch (InterruptedException e) {
     e.printStackTrace();
 }
 System.out.println("当前线程名:"+Thread.currentThread().getName()+" 结束---");
}

newSingleExecutor( )

创建一个单线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

基本创建:

public static void demo(){
//创建一个只有一个连接的连接池
ExecutorService executorService =Executors.newSingleThreadExecutor();

//重写Runnable 的run 方法
 Runnable runnable = new Runnable() {
     @Override
  public void run() {
         content();
     }
 };

 for (int i = 0; i < 100; i++) {
     //调用 .execute(Runnable r) 方法将 r 放入线程池中执行
     executorService.execute(runnable);
}
 //关闭线程池
 executorService.shutdown();
}

使用lambda表达式创建:

public static void lambdaDemo(){
//创建一个不限制最大线程数量的线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();


 for (int i = 0; i < 100; i++) {
     //使用lambda执行
  executorService.execute(()->{
      content();
     });
 }
 //关闭线程池
 executorService.shutdown();
}

执行内容:

private static void  content(){
System.out.println("当前线程名:"+Thread.currentThread().getName()+" 开始+++");
try {
  Thread.sleep(100);
} catch (InterruptedException e) {
  e.printStackTrace();
}
 System.out.println("当前线程名:"+Thread.currentThread().getName()+" 结束---");
}

newScheduleThreadPool()

可以创建定长的、支持延迟任务，周期任务执行。

这个线程池有点特别 , 他有两种方式 ;

1, 延迟执行

​ 使用方法 .schedule(Runnable r , long delay , TimeUnit unit )

2, 周期执行

​ 使用方法 .scheduleAtFixedRate( Runnable command , long initialDelay , long period , TimeUnit unit)

执行内容:

private static void  content(){
    System.out.println("当前线程名:"+Thread.currentThread().getName()+" 开始+++");
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("当前线程名:"+Thread.currentThread().getName()+" 结束---");
}

延迟执行:

/*延迟执行任务  将任务交给线程池管理，延迟2秒后才开始执行线程池中的所有任务   */
public static void demo(){
    //创建一个最大只有五个连接的连接池
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

    //重写 Runnable 的run 方法
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            content();
        }
    };

    for (int i = 0; i < 100; i++) {
        // 将任务交给线程池管理，延迟2秒后才开始执行线程池中的所有任务
        							// 执行内容  时间     单位
        scheduledExecutorService.schedule(runnable,2, TimeUnit.SECONDS);
    }

    //关闭连接池
    scheduledExecutorService.shutdown();
}

周期执行

//周期性执行任务
public static void period(){
    //创建上限为5的线程池
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            content();
        }
    };
    //周期性的执行任务 , 延迟2s后 , 每3s一次的周期的执行任务
    scheduledExecutorService.scheduleAtFixedRate(runnable,2,3,TimeUnit.SECONDS);

}