多任务处理
1. 多任务的介绍
2. 多任务的概念
3. 多任务的执行方式


1. 多任务的介绍
多任务的最大好处是充分利用CPU资源，提高程序的执行效率。
2. 多任务的概念
多任务是指在同一时间内执行多个任务，例如: 现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件。
多任务效果图:


3. 多任务的执行方式

并发
并行


并发:
在一段时间内交替去执行任务。
例如:
对于单核cpu处理多任务,操作系统轮流让各个软件交替执行，假如:软件1执行0.01秒，切换到软件2，软件2执行0.01秒，再切换到软件3，执行0.01秒……这样反复执行下去。表面上看，每个软件都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像这些软件都在同时执行一样，这里需要注意单核cpu是并发的执行多任务的。
并行:
对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，多个内核是真正的一起执行软件。这里需要注意多核cpu是并行的执行多任务，始终有多个软件一起执行。

突然记起以前遇到的一个面试的问题，所以想写写。

问题大概意思是这样的：一个任务需要启动多个线程去处理，如果获取每个线程的执行结果呢？

 

实现方式是  Callable + Future

 

Callable 是一个要去实现的线程接口，用该接口去实现一个线程的好处是，它的要求你去覆盖的call方法会带一个返回值，我们获取的线程结果就是从这个返回值中取的。

Future 可以说是 Callable 线程结果的存取站点。官方解释网上很多，直搜就是了。

 

下面的代码例子是用for 循环的实现与多线程的实现作对比了一下，让大家更直接感觉到多线程的性能优点。因为在我的工作中，经常遇到一个功能的性能优化问题，很多是因为接口时长长得让人无法接受，而当时发现很多是因为for 循环中做了很耗时的动作。比如到各业务节点，需调rest接口到各业务节点获取连接状态，开发时可能没考虑过业务节点数的问题，写代码时直接用for循环来实现。如果调一次接口需要花0.3秒，当节点数10个左右时，也就花3、4秒，这里当然感觉不到性能问题；当节点数达到100 或 更多时问题就出来了，那么光这里就得耗上30多秒，这是个很长的耗的，一般10秒以上就会感觉到时间长了。所以在此机会也让大家感觉一下多线程的实际好处。

例子中场景是：有10份礼物要送给10户人家，送完之后整理所有接收礼物的人家的心情感觉。for循环相当于派一个人依次去给10户人家送；用线程池相当于派几个人（具体看线程数设置，设置为1那么就1个人，10那就是10个人）。

一个实现Callable 的线程类

package com.learn.thread;

import java.util.Map;
import java.util.Random;
import java.util.concurrent.Callable;

public  class SendGift implements Callable<String[]> {

    private String gift ;
    private Map<String,String> resultMap ;

    public SendGift(String gift ,Map<String,String> resultMap ){
        this.gift = gift ;
        this.resultMap = resultMap ;
    }

    @Override
    public String[] call() throws Exception {
        Random r = new Random();
        int code = r.nextInt(100);
        code = code%5;
        String result = resultMap.get(code+"") ;
        //System.out.println("the code is "+code+" , the result is "+result);
        //,为了让测试结果明显一点，一个循环设置花2秒
        Thread.sleep(2000);
        String[] resultArray  = {this.gift ,result};
        return resultArray ;
    }
}


 

main 方法

package com.learn.thread;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.*;

public class TestMain {
    private static final int poolSize = 15 ;

    public static void main(String[] args ){
        //domain
        try {
            doTask("forEach");
            doTask("forThread");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void doTask(String type) throws  InterruptedException{
        System.out.println("--------------start doTask for type:"+type+"--------------");

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Long startMillis = System.currentTimeMillis() ;
        String startDate = sdf.format(new Date(startMillis));
        System.out.println("do "+type+" start time is :"+startDate);
        String[] gifts = {"apple","orange","cat","dog","tomato","monkey","birds","fish","milk","pen"};
        Map<String,String> resultMap = new HashMap<String,String>();
        initData(resultMap);
        Random r = new Random();
        Map<String , String> family = new HashMap<>();
        switch(type){
            case "forEach":
                doForEach(resultMap ,family,gifts);
                break;
            case "forThread":
                doByThread(resultMap ,family,gifts);
                break;
            default:
                break ;
        }
        Long endMillis = System.currentTimeMillis() ;
        String endDate = sdf.format(new Date(endMillis));
        System.out.println("do "+type+" end time is :"+endDate);
        System.out.println("do "+type+" cost time is :"+ (endMillis -startMillis)/1000);
        System.out.println(handleResult(family));
    }

    /**
     * 以循环的方式去执行任务
     * @throws InterruptedException
     */
    public static void doForEach(Map<String,String> resultMap ,Map<String , String> family,String[] gifts) throws  InterruptedException{

        Random r = new Random();
        //将10个礼物依次发出去，并收集感受
        for(String gift : gifts){

            int code = r.nextInt(100);
            code = code%5;
            String result = resultMap.get(code+"") ;
            //System.out.println("the code is "+code+" , the result is "+result);
            family.put(gift,result) ;
            //一个循环设置花2秒
            Thread.sleep(2000);

        }
    }


    /**
     * 以线程的方式去执行任务
     * @throws InterruptedException
     */
    public static void doByThread(Map<String,String> resultMap ,Map<String , String> family,String[] gifts)  throws  InterruptedException {

        Random r = new Random();
        ExecutorService es = Executors.newFixedThreadPool(poolSize);
        System.out.println("the poolSize is "+ poolSize);
        List<Future<String[]>> futureList = new ArrayList<>( );

        //将10个礼物依次发出去，并收集感受
        for(String gift : gifts){

            Future<String[]> future =  es.submit(new SendGift(gift ,resultMap));
            futureList.add(future) ;

        }
        es.shutdown();
        while(true){
            if(es.isTerminated()){
                System.out.println("所有线程都执行结束了.");
                break ;

            }
            Thread.sleep(100);
        }

        for(Future<String[]> f :futureList){
            try {
                String[] result = f.get();
                family.put(result[0],result[1]);
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

        }
    }


    /**
     * 设置收获感受
     * @param resultMap
     */
    private static void initData(Map<String,String> resultMap){
        if(resultMap == null){
            resultMap = new HashMap<String,String>() ;
        }
        resultMap.put("0","sed");
        resultMap.put("1","happy");
        resultMap.put("2","so so");
        resultMap.put("3","wanting others");
        resultMap.put("4","too nice");
    }

    /**
     * 处理打印结果
     * @param resultMap
     * @return
     */
    private  static String handleResult(Map<String ,String> resultMap){

        Iterator it = resultMap.entrySet().iterator();
        StringBuffer sb = new StringBuffer();
        while(it.hasNext()){
            Map.Entry<String,String> entry =  (Map.Entry<String,String>) it.next();
            String key = entry.getKey();
            String val = entry.getValue();
            sb.append("the family who get the "+key +" is think "+val +" ;\n");
        }

        return sb.toString().substring(0,sb.length()-1) ;
    }

}


 

线程数设置 为5 时的执行结果



线程数设置 为10 时的执行结果



线程数设置 为15 时的执行结果



 

从各个线程数值的执行结果可以看到，当设置的线程数越接近所需的线程数（礼物个数）时，所耗的时间越短（在线程数设置 为10个时，直接就是同时完成了所有任务）； 但我们也看到当设置的线程数为15时耗时并没有提升，这也说明了一个道理，线程数的值并不是越多越好，而是要合适就好，要不就会造成资源浪费。

目录

异步需求

同步任务 =》异步任务

邮件任务

定时邮件发送

 


异步需求


 

发送一封邮件时后台通过多线程进行异步处理，不影响用户对前台页面的操作。发送一封凌晨的定时邮件，用户大可不必陪在程序身旁监督是否发送成功。这些都是异步操作带来的好处。我们可以在Springboot中通过注解实现异步操作。

 

 


同步任务 =》异步任务


 

 

同步任务我们需要先新建一个spirngboot项目，导入web启动器。

现在我们通过hello请求访问hello页面



执行业务时让程序睡上三秒



启动web项目，浏览器会转3秒，然后再显示hello页面，控制台会在hello页面显示时打印“数据正在处理”

页面在执行sleep的3秒种你无法再对页面进行其他操作，只能尬等



 

异步任务很简单，只需要在2个地方加注解即可

首先，service中执行的具体方法上加上异步注解



然后在启动类上加入“开启异步的注解”



重启项目后发现，执行sleep的线程不会影响到主线程，用户可以随时对页面进行其他操作




邮件任务


 

导入mail启动器

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>

 邮件测试前需要确认你的邮箱开启了各种邮件协议服务



获取授权码，然后把以下信息写到你的applicaiton.properties文件中

发件人邮箱，发件人授权码，发件人的邮件服务器类型，如果是qq邮箱必须开启安全认证服务



然后打开测试类，邮件内容需要写上主体，内容，发件人，收件人



启动测试类，即可收到邮件

======================================================================================

我们再发送一个复杂的邮件



这次文字带了样式，并且附件是一张图片~

 

 


定时邮件发送


 

在springboot启动类里开启定时功能的注解



然后你新建一个service，开启Schedule注解，输入计划任务的参数



它这个执行时间是你电脑的时间，下面我测试一下，到点了会打印语句。

可以看到，打印成功。注意，没有任何controller调用这个方法，只用一个注解就实现了定时执行的功能

多任务的最大好处是充分利用CPU资源，提高程序的执行效率

**
多任务的概念
**

多任务是指在同一时间内执行多个任务，例如: 现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件。
多任务效果图:



**
多任务的执行方式
**

并发

并行
并发:
在一段时间内交替去执行任务。
例如:

对于单核cpu处理多任务,操作系统轮流让各个软件交替执行，假如:软件1执行0.01秒，切换到软件2，软件2执行0.01秒，再切换到软件3，执行0.01秒……这样反复执行下去。表面上看，每个软件都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像这些软件都在同时执行一样，这里需要注意单核cpu是并发的执行多任务的。
并行:
对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，多个内核是真正的一起执行软件。这里需要注意多核cpu是并行的执行多任务，始终有多个软件一起执行。
**
小结
**

使用多任务就能充分利用CPU资源，提高程序的执行效率，让你的程序具备处理多个任务的能力。

多任务执行方式有两种方式：并发和并行，这里并行才是多个任务真正意义一起执行。
**
进程
**

进程的介绍
在Python程序中，想要实现多任务可以使用进程来完成，进程是实现多任务的一种方式。
进程的概念

一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位，也就是说每启动一个进程，操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。
比如:现实生活中的公司可以理解成是一个进程，公司提供办公资源(电脑、办公桌椅等)，真正干活的是员工，员工可以理解成线程。
注意:
一个程序运行后至少有一个进程，一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程。
进程的作用

单进程效果图:


多进程效果图:

多进程可以完成多任务，每个进程就好比一家独立的公司，每个公司都各自在运营，每个进程也各自在运行，执行各自的任务。
进程是操作系统进行资源分配的基本单位。

进程是Python程序中实现多任务的一种方式
**
线程
**

线程的介绍
在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。
线程的概念
线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度 ，也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。
线程的作用
多线程可以完成多任务
多线程效果图:


线程是Python程序中实现多任务的另外一种方式，线程的执行需要cpu调度来完成。
进程和线程的对比的三个方向

关系对比

区别对比

优缺点对比
关系对比

线程是依附在进程里面的，没有进程就没有线程。

一个进程默认提供一条线程，进程可以创建多个线程。

对比
区别对比

进程之间不共享全局变量
线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
创建进程的资源开销要比创建线程的资源开销要大
进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
线程不能够独立执行，必须依存在进程中
多进程开发比单进程多线程开发稳定性要强
进程优缺点:

优点：可以用多核

缺点：资源开销大

线程优缺点:

优点：资源开销小

缺点：不能使用多核