精华内容
下载资源
问答
  • 多任务处理

    2020-10-15 22:45:59
    多任务处理1. 多任务介绍2. 多任务概念3. 多任务执行方式 1. 多任务介绍 多任务最大好处是充分利用CPU资源,提高程序执行效率。 2. 多任务概念 多任务是指在同一时间内执行多个任务,例如: 现在电脑...


    1. 多任务的介绍

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

    2. 多任务的概念

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

    多任务效果图:
    在这里插入图片描述

    3. 多任务的执行方式

    • 并发
    • 并行

    并发:

    在一段时间内交替去执行任务。

    例如:

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

    并行:

    对于多核cpu处理多任务,操作系统会给cpu的每个内核安排一个执行的软件,多个内核是真正的一起执行软件。这里需要注意多核cpu是并行的执行多任务,始终有多个软件一起执行。

    展开全文
  • 问题大概意思是这样的:一个任务需要启动个线程去处理,如果获取每个线程的执行结果呢? 实现方式是 Callable + Future Callable 是一个要去实现的线程接口,用该接口去实现一个线程的好处是,它的要求你去...

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

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

     

    实现方式是  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中通过注解实现...

    目录

    异步需求

    同步任务 =》异步任务

    邮件任务

    定时邮件发送


     

    异步需求

     

    发送一封邮件时后台通过多线程进行异步处理,不影响用户对前台页面的操作。发送一封凌晨的定时邮件,用户大可不必陪在程序身旁监督是否发送成功。这些都是异步操作带来的好处。我们可以在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调用这个方法,只用一个注解就实现了定时执行的功能

    展开全文
  • 多任务的介绍

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

    多任务的最大好处是充分利用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调度的基本单位

    线程不能够独立执行,必须依存在进程中

    多进程开发比单进程多线程开发稳定性要强

    进程优缺点:
    优点:可以用多核
    缺点:资源开销大
    线程优缺点:
    优点:资源开销小
    缺点:不能使用多核

    展开全文
  • 线程的好处

    2020-10-16 16:43:25
    最典型的线程的好处如下: 更好的CPU 利用率 在一些情况下简化程序的设计 更具响应性的程序 不同任务中更公平的CPU 资源分工 更高的CPU 使用效率 设想一个程序从本地文件系统读取和处理文件。假设从磁盘读取...
  • 时候,我们需要对一个庞大的队列或者二维数组进行处理。这些处理可能是循环的,比如给一个excel个sheet的联系人...线程的好处是比较的,特别是能装装B,让你从男孩变成男人的感觉。不废话了,我简化了工...
  • 多任务

    2019-09-08 17:43:58
    多任务的最大好处是充分利用CPU资源,提高程序执行效率。 多任务是指在同一时间内执行多个任务,例如: 现在电脑安装操作系统都是多任务操作系统,可以同时运行着多个软件。 多任务的执行方式 并发 并行:是多个...
  • 线程有什么好处?提高CPU利用率,更好地利用系统资源,使用Monitor类可以同步静态/实例化方法全部...线程是指程序中包含个执行流,即在一个程序中可以同时运行个不同制线程来执行不同的任务,允许单...
  • Java线程处理任务时候,我们需要对一个庞大的队列或者二维数组进行处理。这些处理可能是循环的,比如网络爬出,也可能是有结尾的,比如给一个excel个sheet的联系人...线程的好处是比较的,特别是...
  • 刚开始接触java的时候对线程总是怀抱着好奇心,总想弄明白线程的好处,为什么要使用线程编程。甚至于认为使用线程就比单线程要高大上、要好。但事实真的是这样吗?下面就举一个案列看看 1.使用...
  • 6.2 ZeroMQ进程和混合语言编程使用ZeroMQ的一个最大的好处是我们可以用不同的语言来写不同的进程。这样我们就可以部署一个node.js写的进程发消息来向用python写的进程发消息和请求服务。在这个例子中,我们使用...
  • 多任务是指在同一时间执行多个任务,其最大的好处就是充分的利用CPU资源,提高程序的执行效率 ##多任务的执行方式分别有并发和并行两种方式: 并发 : 在一段时间内交替去执行任务 也就是当要执行的任务大于CPU的...
  • 何时使用线程技术,何时避免用它,是我们需要掌握的重要课题。线程技术是一把双刃剑,在使用时需要充分考虑它的优缺点。...(2)当前没有进行处理的任务时可以将处理器时间让给其它任务;(3)占用大量处理时...
  • 使用线程的好处有以下几点: ·使用线程可以把占据长时间的程序中的任务放到后台去处理 ·用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度 ·程序的...
  • 多任务——进程

    2020-08-06 20:17:57
    1-并发:当单核CPU处理多任务是就轮流交替执行,所以说看上去像是同时经行。 注意:单核CPU想要执行多任务只能使用并发。 2-并行:多核CPU处理多任务是 多个内核同时执行程序 注意:多核CPU是真正意义上同时进行...
  • MapReducer中的多次归约处理

    千次阅读 2015-07-28 09:06:41
    我们知道,MapReduce是分为Mapper任务和Reducer任务,Mapper任务的输出,通过网络传输到Reducer任务端,作为输入。 在Reducer任务中,通常做的事情是对数据进行归约处理。...这样的好处是减少了...
  • 014、多任务编程

    2019-05-15 23:51:27
    多任务的最大好处是充分利用CPU资源,提高程序执行效率。 3. 多任务的执行方式 并发 并行 并发: 在一段时间内交替去执行任务。 例如: 对于单核cpu处理多任务,操作系统轮流让各个软件交替执行,假如:软件1...
  • 多任务的最大好处是充分利用CPU资源,提高程序执行效率。 概念 多任务是指在同一时间内执行多个任务,例如: 现在电脑安装操作系统都是多任务操作系统,可以同时运行着多个软件。 小结 使用多任务就能充分利用...
  • 单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池,有可能造成系统创建大量线程而导致消耗完系统内存以及”过度...
  • 线程池的好处

    2017-05-14 11:33:56
    个人认为主要原因是:短时间内需要处理的任务数量很  使用线程池的好处:  1.减少在创建和销毁线程上所花的时间以及系统资源的开销  2.如不使用线程池,有可能造成系统创建大量线程而导致消耗完系统...
  • 使用线程池的好处

    2014-05-15 14:58:03
    单个任务处理的时间比较短   2.将需处理的任务的数量大   使用线程池的好处:   1.减少在创建和销毁线程上所花的时间以及系统资源的开销   2.如不使用线程池,有可能造成系统创建大量线程而导致消耗...
  • 线程有什么好处?提高CPU利用率,更好地利用系统资源,使用Monitor类可以同步静态/实例化方法全部...线程是指程序中包含个执行流,即在一个程序中可以同时运行个不同制线程来执行不同的任务,允许单...
  • 服务端的应用程序中经常出现的情况是:单个任务处理的时间很短而请求的数目却是巨大的。现在服务器的CPU一般都是多核的,如果我们在面对巨大的请求时,还是以单线程的方式去处理这样的一个任务,显然它的耗时是我们...
  • 线程池的好处和应用场景

    千次阅读 2018-03-06 01:09:32
    一、线程池使用场景•单个任务处理时间短•将需处理的任务数量大二、使用Java线程池好处1、使用new Thread()创建线程的弊端:•每次通过new Thread()创建对象性能不佳。•线程缺乏统一管理,可能无限制新建线程,...
  • Java线程池的好处

    2013-04-25 15:39:15
     之所以使用线程是因为线程可以共享内存,因为可以共享内存所以可以把1个任务交由个线程并行处理,这样增加了CPU的利用率,  其次是因为线程的创建销毁比进程的创建销毁开销小 Java线程池的好处
  • 近期项目中涉及到使用线程和线程池,但是可能不少人知道怎么用却不知道这样做的好处是什么,了解一下: 1、提高资源利用率 线程池可以重复利用已经创建了的线程 2、提高响应速度 因为当线程池中的线程没有超过...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 676
精华内容 270
关键字:

多任务处理的好处