• java线程池并发实现代码模板

    ThreadPoolExecutor，execute，Runnable

    线程池执行无返回值线程（无需知道执行结果）

    1. package codeTemplate.thread;
    2.  
    3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    4. import java.util.concurrent.ArrayBlockingQueue;
    5. import java.util.concurrent.ThreadPoolExecutor;
    6. import java.util.concurrent.TimeUnit;
    7.  
    8. public class ThreadPoolExecuteTemplate {
    9.     private static final ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 30, TimeUnit.SECONDS,
    10.             new ArrayBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("basic-thread-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());
    11.  
    12.     public void doSomething() {
    13.         for (int i = 0; i < 10; i++) {
    14.             executorService.execute(new Runnable() {
    15.                 @Override
    16.                 public void run() {
    17.                     System.out.println(Thread.currentThread().getName());
    18.                 }
    19.             });
    20.         }
    21.         System.out.println("over");
    22.     }
    23.  
    24.     public static void main(String[] args) {
    25.         new ThreadPoolExecuteTemplate().doSomething();
    26.     }
    27. }

    线程池执行无返回值线程（需要知道执行结果）

    一般主线程不会等线程并发执行完，所以需要用到其他工具

    CountDownLatch（运行结果放入HashMap）

    ThreadTask.java

    1. package codeTemplate.thread;
    2.  
    3. import java.util.Map;
    4. import java.util.concurrent.CountDownLatch;
    5.  
    6. public class ThreadTask implements Runnable {
    7.     private final String param;
    8.     private final CountDownLatch latch;
    9.     private Map result;
    10.  
    11.     public ThreadTask(Map result, String param, CountDownLatch latch) {
    12.         this.result = result;
    13.         this.param = param;
    14.         this.latch = latch;
    15.     }
    16.  
    17.     @Override
    18.     public void run() {
    19.         try {
    20.             System.out.println(Thread.currentThread().getName());
    21.             result.put(param, param + "over");
    22.         } finally {
    23.             latch.countDown();
    24.         }
    25.     }
    26. }

    使用

    1. package codeTemplate.thread;
    2.  
    3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    4.  
    5. import java.util.Arrays;
    6. import java.util.HashMap;
    7. import java.util.List;
    8. import java.util.Map;
    9. import java.util.concurrent.ArrayBlockingQueue;
    10. import java.util.concurrent.CountDownLatch;
    11. import java.util.concurrent.ThreadPoolExecutor;
    12. import java.util.concurrent.TimeUnit;
    13.  
    14. public class CountDownLatchTemplate {
    15.     private static final ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 30, TimeUnit.SECONDS,
    16.             new ArrayBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("basic-thread-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());
    17.  
    18.     public void doSomethingNeedResult() {
    19.         try {
    20.             Map result = new HashMap<>();
    21.             List params = Arrays.asList("1", "2", "3", "4", "5");
    22.             CountDownLatch latch = new CountDownLatch(params.size());
    23.             for (String param : params) {
    24.                 executorService.execute(new ThreadTask(result, param, latch));
    25.             }
    26.             latch.await(10, TimeUnit.MINUTES);
    27.             System.out.println(result);
    28.         } catch (InterruptedException e) {
    29.             e.printStackTrace();
    30.         }
    31.     }
    32.  
    33.     public static void main(String[] args) {
    34.         new CountDownLatchTemplate().doSomethingNeedResult();
    35.     }
    36. }

    CountDownLatch（运行结果放入LIst,不用保持原有顺序）

    ThreadResultToListTask.java

    1. package codeTemplate.thread;
    2.  
    3. import java.util.List;
    4. import java.util.Random;
    5. import java.util.concurrent.CountDownLatch;
    6. import java.util.concurrent.TimeUnit;
    7.  
    8. public class ThreadResultToListTask implements Runnable {
    9.     private final String param;
    10.     private final CountDownLatch latch;
    11.     private List result;
    12.  
    13.     public ThreadResultToListTask(List result, String param, CountDownLatch latch) {
    14.         this.result = result;
    15.         this.param = param;
    16.         this.latch = latch;
    17.     }
    18.  
    19.     @Override
    20.     public void run() {
    21.         try {
    22.             int randomNumber = new Random().nextInt(3);
    23.             System.out.println(Thread.currentThread().getName()+"------------"+randomNumber);
    24.             TimeUnit.SECONDS.sleep(randomNumber);
    25.             System.out.println(Thread.currentThread().getName()+"------------"+randomNumber);
    26.             result.add(param + "over");
    27.         } catch (InterruptedException e) {
    28.             e.printStackTrace();
    29.         } finally {
    30.             latch.countDown();
    31.         }
    32.     }
    33. }

    使用

    1. package codeTemplate.thread;
    2.  
    3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    4.  
    5. import java.util.*;
    6. import java.util.concurrent.ArrayBlockingQueue;
    7. import java.util.concurrent.CountDownLatch;
    8. import java.util.concurrent.ThreadPoolExecutor;
    9. import java.util.concurrent.TimeUnit;
    10.  
    11. public class CountDownLatchTemplate {
    12.     private static final ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 30, TimeUnit.SECONDS,
    13.             new ArrayBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("basic-thread-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());
    14.  
    15.     public void doSomethingNeedListResult() {
    16.         try {
    17.             List result = new ArrayList<>();
    18.             List params = Arrays.asList("1", "2", "3", "4", "5");
    19.             CountDownLatch latch = new CountDownLatch(params.size());
    20.             for (String param : params) {
    21.                 executorService.execute(new ThreadResultToListTask(result, param, latch));
    22.             }
    23.             latch.await(10, TimeUnit.MINUTES);
    24.             System.out.println(result);
    25.         } catch (InterruptedException e) {
    26.             e.printStackTrace();
    27.         }
    28.     }
    29.  
    30.     public static void main(String[] args) {
    31.         new CountDownLatchTemplate().doSomethingNeedListResult();
    32.     }
    33. }

    CountDownLatch（运行结果需要保持原有顺序）

    ThreadResultHoldOrderTask.java

    1. package codeTemplate.thread;
    2.  
    3. import java.util.List;
    4. import java.util.Random;
    5. import java.util.concurrent.CountDownLatch;
    6. import java.util.concurrent.TimeUnit;
    7.  
    8. public class ThreadResultHoldOrderTask implements Runnable{
    9.     private final List params;
    10.     private final CountDownLatch latch;
    11.     private final int index;
    12.  
    13.     public ThreadResultHoldOrderTask(List params,int index, CountDownLatch latch) {
    14.         this.params = params;
    15.         this.latch = latch;
    16.         this.index=index;
    17.     }
    18.  
    19.     @Override
    20.     public void run() {
    21.         try {
    22.             int randomNumber = new Random().nextInt(3);
    23.             System.out.println(Thread.currentThread().getName()+"------------"+randomNumber);
    24.             TimeUnit.SECONDS.sleep(randomNumber);
    25.             System.out.println(Thread.currentThread().getName()+"------------"+randomNumber);
    26.             params.set(index,params.get(index)+"over");
    27.         } catch (InterruptedException e) {
    28.             e.printStackTrace();
    29.         } finally {
    30.             latch.countDown();
    31.         }
    32.     }
    33. }

    使用

    1. package codeTemplate.thread;
    2.  
    3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    4.  
    5. import java.util.*;
    6. import java.util.concurrent.ArrayBlockingQueue;
    7. import java.util.concurrent.CountDownLatch;
    8. import java.util.concurrent.ThreadPoolExecutor;
    9. import java.util.concurrent.TimeUnit;
    10.  
    11. public class CountDownLatchTemplate {
    12.     private static final ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 30, TimeUnit.SECONDS,
    13.             new ArrayBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("basic-thread-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());
    14.  
    15.     public void doSomethingNeedOrderListResult() {
    16.         try {
    17.             List params = Arrays.asList("1", "2", "3", "4", "5");
    18.             CountDownLatch latch = new CountDownLatch(params.size());
    19.             for (int i = 0; i < params.size(); i++) {
    20.                 executorService.execute(new ThreadResultHoldOrderTask(params, i, latch));
    21.             }
    22.             latch.await(10, TimeUnit.MINUTES);
    23.             System.out.println(params);
    24.         } catch (InterruptedException e) {
    25.             e.printStackTrace();
    26.         }
    27.     }
    28.  
    29.     public static void main(String[] args) {
    30.         new CountDownLatchTemplate().doSomethingNeedOrderListResult();
    31.     }
    32.  
    33. }

    信号量（实现多线程对公共资源的并发访问控制）

    无需知道执行结果

    SemaphoreTask.java

    1. package codeTemplate.thread;
    2.  
    3. import java.util.concurrent.Semaphore;
    4. import java.util.concurrent.TimeUnit;
    5. import java.util.concurrent.atomic.AtomicInteger;
    6.  
    7. public class SemaphoreTask implements Runnable {
    8.     private final Semaphore semaphore;
    9.     private AtomicInteger resource;
    10.  
    11.     public SemaphoreTask(Semaphore semaphore, AtomicInteger resource) {
    12.         this.semaphore = semaphore;
    13.         this.resource = resource;
    14.     }
    15.  
    16.     @Override
    17.     public void run() {
    18.         try {
    19.             semaphore.acquire();
    20.             TimeUnit.SECONDS.sleep(3);
    21.             System.out.println(Thread.currentThread().getName() + "-------------" + resource.incrementAndGet());
    22.         } catch (InterruptedException e) {
    23.             e.printStackTrace();
    24.         } finally {
    25.             semaphore.release();
    26.         }
    27.  
    28.     }
    29. }

    使用

    1. package codeTemplate.thread;
    2.  
    3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    4.  
    5. import java.util.concurrent.ArrayBlockingQueue;
    6. import java.util.concurrent.Semaphore;
    7. import java.util.concurrent.ThreadPoolExecutor;
    8. import java.util.concurrent.TimeUnit;
    9. import java.util.concurrent.atomic.AtomicInteger;
    10.  
    11. public class SemaphoreTemplate {
    12.     private static final ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 30, TimeUnit.SECONDS,
    13.             new ArrayBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("basic-thread-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());
    14.  
    15.     public void doSomething() {
    16.         Semaphore semaphore = new Semaphore(3);
    17.         AtomicInteger resource = new AtomicInteger();
    18.         for (int i = 0; i < 10; i++) {
    19.             executorService.execute(new SemaphoreTask(semaphore, resource));
    20.         }
    21.     }
    22.  
    23.     public static void main(String[] args) {
    24.         new SemaphoreTemplate().doSomething();
    25.     }
    26.  
    27. }

    需知道执行结果

    SemaphoreResultTask.java

    1. package codeTemplate.thread;
    2.  
    3. import java.util.List;
    4. import java.util.concurrent.CountDownLatch;
    5. import java.util.concurrent.Semaphore;
    6. import java.util.concurrent.TimeUnit;
    7.  
    8. public class SemaphoreResultTask implements Runnable{
    9.     private final Semaphore semaphore;
    10.     private final CountDownLatch latch;
    11.     private final List params;
    12.     private final int index;
    13.  
    14.     public SemaphoreResultTask(Semaphore semaphore, CountDownLatch latch, List params,int index) {
    15.         this.semaphore=semaphore;
    16.         this.latch = latch;
    17.         this.params = params;
    18.         this.index = index;
    19.     }
    20.  
    21.     @Override
    22.     public void run() {
    23.         try{
    24.             semaphore.acquire();
    25.             params.set(index, params.get(index) + " over");
    26.             TimeUnit.SECONDS.sleep(1);
    27.             System.out.println("in task: "+params);
    28.             semaphore.release();
    29.         } catch (InterruptedException e) {
    30.             e.printStackTrace();
    31.         }finally {
    32.             latch.countDown();
    33.         }
    34.  
    35.     }
    36. }

    使用

    1. package codeTemplate.thread;
    2.  
    3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    4.  
    5. import java.util.Arrays;
    6. import java.util.List;
    7. import java.util.concurrent.*;
    8. import java.util.concurrent.atomic.AtomicInteger;
    9.  
    10. public class SemaphoreTemplate {
    11.     private static final ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 30, TimeUnit.SECONDS,
    12.             new ArrayBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("basic-thread-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());
    13.  
    14.     public void doSomethingNeedResult() {
    15.         try {
    16.             List params = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9", "10");
    17.             CountDownLatch latch = new CountDownLatch(params.size());
    18.             Semaphore semaphore = new Semaphore(3);
    19.             for (int i = 0; i < params.size(); i++) {
    20.                 executorService.execute(new SemaphoreResultTask(semaphore, latch, params, i));
    21.             }
    22.             latch.await(10, TimeUnit.MINUTES);
    23.             System.out.println("result: "+params);
    24.         } catch (InterruptedException e) {
    25.             e.printStackTrace();
    26.         }
    27.  
    28.     }
    29.  
    30.     public static void main(String[] args) {
    31.         new SemaphoreTemplate().doSomethingNeedResult();
    32.     }
    33. }

    ThreadPoolExecutor，submit，Callable，Future

    使用

    1. package codeTemplate.thread;
    2.  
    3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
    4.  
    5. import java.util.HashMap;
    6. import java.util.Map;
    7. import java.util.Random;
    8. import java.util.concurrent.*;
    9.  
    10. public class ThreadPoolSubmitCallTemplate {
    11.     private static final ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 30, TimeUnit.SECONDS,
    12.             new ArrayBlockingQueue<>(100), new ThreadFactoryBuilder().setNameFormat("basic-thread-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy());
    13.     public static Map> sessionMap = new HashMap<>();
    14.  
    15.     public void doSomething(String index) {
    16.         Future future = executorService.submit(new Callable() {
    17.             @Override
    18.             public String call() throws Exception {
    19.                 TimeUnit.SECONDS.sleep(new Random().nextInt(5));
    20.                 return "ok";
    21.             }
    22.         });
    23.         sessionMap.put(index, future);
    24.     }
    25.  
    26.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    27.         ThreadPoolSubmitCallTemplate submitCallTemplate = new ThreadPoolSubmitCallTemplate();
    28.         for (int i = 0; i < 10; i++) {
    29.             submitCallTemplate.doSomething("session-" + i);
    30.         }
    31.         System.out.println(sessionMap.get("session-7").get());
    32.     }
    33. }

  • 相关阅读:
    如何解除Mac系统文件的隐藏状态？
    IDEA jar看不到反编译后的源码（只有方法那一级/* compiled code*/）
    图书管理系统
    Pyhon函数定义中的：必选参数、可选参数、可变参数
    7天学完Spring：Spring框架搭建和解析以及Bean对象的创建
    携号转网查询易语言代码
    使用Springboot开发前后端分离校园智能出行拼车系统
    【MySQL】索引和事物
    k8s--基础--26.6--监控告警系统--kube-state-metrics
    C/C++ const相关 常量指针 常指针 常指针常量 顶层底层const
  • 原文地址：https://blog.csdn.net/jsq916/article/details/126435767