Java 并发、并行、异步 应用场景、区别的简单总结

Java 并发、并行、异步 应用场景、区别的理解总结
一、并发
  多任务无事务性约束，线程池中各线程处理速度不一，同一时刻只有一个任务在执行
  示例代码：

package com.dubbo.rest.bingfa;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author Jupitor
 * @description 并发请求处理类
 * @date 2019年1月7日
 */
public class BFThreadPoolService {
  
  /** 线程池处理器 .*/
  private ThreadPoolExecutor executor;

  public BFThreadPoolService() {
    //并发请求处理类创建时，创建并发阻塞队列
    BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
    this.executor = new ThreadPoolExecutor(2, 10, 2, TimeUnit.SECONDS, queue);
  }
  
  /**
   * @description 接收请求并提交线程池
   */
  public void doService(String message) {
    executor.submit(new Handler(message));
  }
  
  public static void main(String[] args) {
    BFThreadPoolService service = new BFThreadPoolService();
    //并发处理会出现执行结果不是同一时间完成的情况 1  0  2  3  4  5  6  7  9  8 
    for(int i=0; i<10;i++) {
      service.doService(""+i);
    }
  }
}

package com.dubbo.rest.bingfa;

/**
 * @author Jupitor
 * @description 单一线程处理类
 * @date 2019年1月7日
 */
public class Handler implements Runnable{
  
  /** 需要打印的消息 .*/
  private String message;

  public Handler() {}
  
  public Handler(String message) {
    this.message = message;
  }

  @Override
  public void run() {
    System.out.print(message+"  ");
  }

}

二、并行
  多任务事务性较强的情况下，单个线程中，同一时刻执行多个任务，处理最长时间任务的时间决定该线程周期
  示例代码：

package com.dubbo.rest.parallel;

import java.util.Calendar;
import java.util.concurrent.CompletableFuture;

/**
 * @author Jupitor
 * @description 并行测试代码
 * @date 2019年1月7日
 */
public class ParallelTest {
  
  /**
   * 当主线程开始时，单个任务开始并行执行
   */
  public static void main(String[] args) {
    
    //并行1
    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> a());
    //并行2
    CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> b());
    //并行3
    CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> c());

    try {
      //并行任务开始时间:>会发现打印的执行时间小于睡眠时间，所以该时间仅供参照，实际并行已经在主线程开始时已经执行
      Long startTime = Calendar.getInstance().getTimeInMillis();
      if(future1.get()!=null) {
        System.out.println(Calendar.getInstance().getTimeInMillis()-startTime);
      }
      if(future2.get()!=null) {
        System.out.println(Calendar.getInstance().getTimeInMillis()-startTime);
      }
      if(future3.get()!=null) {
        System.out.println(Calendar.getInstance().getTimeInMillis()-startTime);
      }
      Long endTime = Calendar.getInstance().getTimeInMillis();
      System.out.println("并行任务共计用时："+(endTime-startTime));
    }catch (Exception e){

    }
  }

  public static String a(){
    try {
      Thread.sleep(1000);
      System.out.println("a");
    }catch (Exception e){}
    return "a";
  }

  private static String b(){
    try {
      Thread.sleep(2000);
      System.out.println("a");
    }catch (Exception e){}
    return "b";
  }
  private static String c(){
    try {
      Thread.sleep(5000);
      System.out.println("a");
    }catch (Exception e){}
    return "c";
  }
}

三、异步
  多任务无事务性的情况下，多个阻塞队列负责处理不同的任务集
  示例代码：

package com.dubbo.rest.service;

import java.util.Scanner;
import java.util.concurrent.ArrayBlockingQueue;

/**
 * @author Jupitor
 * @description 异步阻塞队列处理异步任务
 * @date 2019年1月7日
 */
public class BlockingQueue {

  /** 并发阻塞队列 .*/
  private static ArrayBlockingQueue<String> QUEUE;
  
  static {
    QUEUE = new ArrayBlockingQueue<>(500);
    //单个线程打印消息
    Thread t = new Thread() {
      @Override
      public void run() {
        while(true) {
          try {
            String message = QUEUE.take();
            System.out.println("正在处理消息："+message);
          } catch (InterruptedException e) {
            System.out.println("取消息异常");
          }
        }
      }
    };
    t.start();
  }
  
  /**
   * @description 存消息
   */
  public void saveMessage(String message) {
    try {
      QUEUE.put(message);
    } catch (InterruptedException e) {
      System.out.println("存放消息异常");
    }
  }
  
  public static void main(String[] args) {
    
    BlockingQueue service = new BlockingQueue();
//    Scanner sc = new Scanner(System.in);
//    while(true) {
//      System.out.println("请输入消息：");
//      String message = sc.nextLine();
//      service.saveMessage(message);
//    }
    for(int i=1; i<1000;i++) {
      service.saveMessage(""+i);
    }
  }
}