并发专题第一篇，多线程快速入门和简单介绍

本篇文章主要内容

1.什么是进程、线程
2.多线程有那些好处
3.多线程的应用场景有那些
4.如何理解多线程上下文切换
5.使用多线程存在那些缺陷
6.多线程四种创建的方式 
7.如何创建带返回结果的线程
8.多线程综合案例，异步实现发送短信、异步实现记录请求日志
9.多线程五种状态有那些
10.如何优雅的停止一个线程

——————————————————————————————————————————————

什么是进程

 进程就是系统中正在运行的一个程序，程序一旦运行就是一个进程，在一个进程中可以开启多个不同的线程执行。

什么是多线程

  在同一个进程开启了多条不同的执行路径，每条执行路径就是一个线程，多条不同路径同时执行。

使用多线程的好处

1. 使用多线程可以提高程序效率
2. 快速响应给客户端，给用户更加好的体验
3. 每个线程之间相互不影响

使用多线程的应用场景

1.使用多线程实现异步发送短信

2.使用多线程实现异步的记录日志

3.使用多线程处理一些比较耗时间的业务逻辑

 

单线程与多线程之间的区别

单线程：就是使用一条线程从上到下执行完代码，效率比较低，且响应也比较慢，对用户不是很友好。

多线程：开启多条不同的线程，每个线程执行不同的任务，每个线程之间相互不影响。

如何理解线程上下文切换

 对于单核的CPU来说，CPU在同一个时刻只能够运行一个线程，当正在运行的线程切换到另外一个线程时，这个过程我们可以理解为CPU上下文切换。

 如果是多核处理器，比如我的上课电脑 I7 8700k 6核 12线程，也就是在同一个时刻可以开启12个线程同时运行，服务器支持的线程数越高可以减少CPU上下文的切换，从而提高效率。

  所以注意：单核的服务器开启了多线程，人为感知好像是多线程，但是真正意义上的底层不是多线程。

使用多线程真的开启越多越好吗

  如果项目比较小的情况下可以采用多线程异步实现处理是可以的，但是如果在高并发的情况下频繁的创建线程，同时也会被CPU分配调度，不断的切换，对服务器影响也是比较大，所以建议如果是在高并发的情况下采用MQ异步的形式替代多线程。

多线程四种创建的方式

1. 继承Thread类
2. 使用Runnable
3. 使用Callable
4. 线程池的方式

继承Thread类形式

public class Thread001 extends Thread {     @Override     public void run() {         System.out.println("我是子线程:" + Thread.currentThread().getName());     }     public static void main(String[] args) {         System.out.println("我是主线程:" + Thread.currentThread().getName());         // 调用start方法启动线程         new Thread001().start();     } }

 

实现Runnable类形式

public class Thread002 implements Runnable {     public void run() {         System.out.println("我是子线程:" + Thread.currentThread().getName());     }     public static void main(String[] args) {         System.out.println("我是主线程:" + Thread.currentThread().getName());         new Thread(new Thread002()).start();     } }

 

使用Callable的形式

public class MyCallable implements Callable<String> {     public String call() throws Exception {         System.out.println(Thread.currentThread().getName() + "正在异步调用接口发送短信");         try {             Thread.sleep(3000);         } catch (Exception e) {         }         return "短信发送成功";     }     public static void main(String[] args) throws ExecutionException, InterruptedException {         FutureTask<String> futureTask = new FutureTask<String>(new MyCallable());         Thread thread = new Thread(futureTask);         thread.start();         String result = futureTask.get();         System.out.println(Thread.currentThread().getName() + result);     } }

带返回接口的线程

使用线程池的方式

ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(new Runnable() {     public void run() {         System.out.println(Thread.currentThread().getName());     } });

多线程综合实战案例

异步实现发送短信

 

@RestController @Slf4j public class LoginService {     @Autowired     private LoginManage loginManage;     @GetMapping("/login")     public ResponseEntity<String> login(UserEntity userEntity) {         UserEntity dbUser = dbLogin(userEntity);         if (dbUser == null) {             return ResponseEntity.status(500).body("账号或者是密码错误");         } //        // 异步开始写日志 //        loginLog(userEntity); //        sendSms(userEntity); //        sendEmail(userEntity); //        new Thread(new Runnable() { //            @Override //            public void run() { //                loginLog(userEntity); //                sendSms(userEntity); //                sendEmail(userEntity); //            } //        }).start();         asynLogin(userEntity);         loginManage.asynLogin(userEntity);         return ResponseEntity.status(200).body("登陆成功");     }     @Async     public void asynLogin(UserEntity userEntity) {         loginLog(userEntity);         sendSms(userEntity);         sendEmail(userEntity);     }     private UserEntity dbLogin(UserEntity userEntity) {         log.info(">>>1.正在查询数据库登陆<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }         return new UserEntity();     }     private void loginLog(UserEntity userEntity) {         log.info(">>>2.异步开始写登陆的日志<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }     }     private void sendSms(UserEntity userEntity) {         log.info(">>>3.异步开始发送短信<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }     }     private void sendEmail(UserEntity userEntity) {         log.info(">>>4.异步开始发送邮件<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }     } }

@Component @Slf4j public class LoginManage {     @Async     public void asynLogin(UserEntity userEntity) {         loginLog(userEntity);         sendSms(userEntity);         sendEmail(userEntity);     }     private UserEntity dbLogin(UserEntity userEntity) {         log.info(">>>1.正在查询数据库登陆<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }         return new UserEntity();     }     private void loginLog(UserEntity userEntity) {         log.info(">>>2.异步开始写登陆的日志<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }     }     private void sendSms(UserEntity userEntity) {         log.info(">>>3.异步开始发送短信<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }     }     private void sendEmail(UserEntity userEntity) {         log.info(">>>4.异步开始发送邮件<<<");         try {             Thread.sleep(2000);         } catch (Exception e) {         }     } }

返回带线程带结果

@Async public Future<String> futureTaskLogin(UserEntity userEntity) {     loginLog(userEntity);     sendSms(userEntity);     sendEmail(userEntity);     return new AsyncResult<String>("异步发送短信完成"); }

Future<String> stringFuture = loginManage.futureTaskLogin(userEntity); return ResponseEntity.status(200).body(stringFuture.get());

异步实现记录请求日志

使用aop打印日志

import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; import org.springframework.web.context.request.RequestContextHolder; import org.springframework.web.context.request.ServletRequestAttributes; import javax.servlet.http.HttpServletRequest; import java.util.Arrays; @Aspect @Component @Slf4j public class WebLogAspect {     /**      * 指定 com.ace.service 包下的注解      * */     @Pointcut("execution( * com.ace.service.*.*(..))")//两个..代表所有子目录，最后括号里的两个..代表所有参数     public void logPointCut() {     }     /**      * 指定当前执行方法在logPointCut之前执行      * */     @Before("logPointCut()")     public void doBefore(JoinPoint joinPoint) throws Throwable{         // 接收到请求，记录请求内容         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();         HttpServletRequest request = attributes.getRequest();         // 记录下请求内容         log.info("请求地址 : " + request.getRequestURL().toString());         log.info("HTTP METHOD : " + request.getMethod());         // 获取真实的ip地址         //logger.info("IP : " + IPAddressUtil.getClientIpAddress(request));         log.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "."                 + joinPoint.getSignature().getName());         log.info("参数 : " + Arrays.toString(joinPoint.getArgs()));         //loggger.info("参数 : " + joinPoint.getArgs());     }     /**      * 指定在方法之后返回      * */     @AfterReturning(returning = "ret", pointcut = "logPointCut()")// returning的值和doAfterReturning的参数名一致     public void doAfterReturning(Object ret) throws Throwable {         // 处理完请求，返回内容(返回值太复杂时，打印的是物理存储空间的地址)         log.info("返回值 : " + ret);     }     @Around("logPointCut()")     public Object doAround(ProceedingJoinPoint pjp) throws Throwable {         long startTime = System.currentTimeMillis();         Object ob = pjp.proceed();// ob 为方法的返回值         log.info("耗时 : " + (System.currentTimeMillis() - startTime));         return ob;     } }

改为异步的形式采集日志

@Component @Slf4j public class AopLogManage {     @Async     public void requestLog(JoinPoint joinPoint, HttpServletRequest request) {         // 接收到请求，记录请求内容         // 记录下请求内容         log.info("请求地址 : " + request.getRequestURL().toString());         log.info("HTTP METHOD : " + request.getMethod());         // 获取真实的ip地址         //logger.info("IP : " + IPAddressUtil.getClientIpAddress(request));         log.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "."                 + joinPoint.getSignature().getName());         log.info("参数 : " + Arrays.toString(joinPoint.getArgs()));         //loggger.info("参数 : " + joinPoint.getArgs());     } }

多线程五种的状态

1. 当我们新建一个线程的时候，new Thread的时候为新建的状态。
2. 当我们调用到start方法的时候，不会立马执行到我们的run方法，当前线程状态为就绪状态，需要等待cpu的切换。
3. 当cpu切换能够调用到该线程的时候，当前线程的状态为运行状态。
4. 当我们在线程调用sleep方法的时候，当前线程线程的状态为阻塞状态，当休眠的时候过了的时候有需要从新等待cpu调度，从就绪状态到运行。
5. 当我们线程调用stop方法或者run方法代码执行结束的时候当前线程的状态为死亡状态。

 

如何优雅的停止一个线程

官方不建议直接调用stop方法停止该线程，建议采用 中间件变量值的停止该线程。

public class Thread005 extends Thread {     private volatile boolean flag = true;     @Override     public void run() {         System.out.println(Thread.currentThread().getName());         while (flag) {         }     }     public void stopThread() {         this.flag = false;     }     public static void main(String[] args) {         Thread005 thread005 = new Thread005();         thread005.start();         try {             Thread.sleep(3000);             thread005.stopThread();         } catch (Exception e) {         }     } }

 

为什么官方不建议直接调用stop方法停止该线程？

答：（1）stop方法是过时的从Java编码规则来说，已经过时的方法不建议采用。（2）stop方法会导致代码逻辑不完整stop方法是一种“恶意”的中断，一旦执行stop方法，即终止当前正在运行的线程，不管线程逻辑是否完整，这是非常危险的。（3）stop方法会破坏原子逻辑多线程为了解决共享资源抢占的问题，使用了锁概念，避免资源不同步，但是正因此原因，stop方法却会带来更大的麻烦：它会丢弃所有的锁，导致原子逻辑受损。

我们想中断一个线程，可以使用interrupt和stop两种方式。 首先说interrupt， 它没有stop那么的粗暴，因为可以用catch捕捉到InterruptedException这个异常，无论是interrupt还是stop都是不安全的做法，因为如果我们在线程进行时打开了某些资源，那么这样粗暴的结束资源将无法正确关闭，所以提倡以上做法，用一个标志flag来控制线程的结束

总结：创建线程的几种方式，还有线程的五种状态面试中可能会问到。使用Callable创建多线程是会比不带返回值的性能要差一些的，我曾经用多线程做过一个类似数据迁移的功能，开启多线程之后用的是JPA分段插入10万数据Callable平均26秒，runable接口18秒，项目实战就是利用AOP，开启多线程异步执行，有空可以敲一下加深理解

思考：都说并发编程，那么并发和并行的区别？

答案下期回答

每一行代码都有它的涵义，多问一句为什么；别怕，理清思路，一切代码都是数据的流动和转化，耐心一点，慢慢积累！一起加油！！