精华内容
下载资源
问答
  • 2019-12-22 16:23:30

    java线程调度的两种方式:

    一 协同线程调度

    1.线程自己的工作执行完后,要主动通知系统切换到另一个线程上。

    2.好处是实现简单,没有什么线程同步问题。

    3.如果一个线程编写有问题,一直不告知系统进行线程切换,那么程序就会一直阻塞在那里。

    4.线程的执行时间是由自身掌控的。

    二 抢占式调度

    1.线程将由系统来分配执行时间,线程的切换不由线程自身决定。

    2.不会出现一个线程导致整个进程阻塞的问题。

    更多相关内容
  • zircon的两种调度理解

    万次阅读 2019-07-06 17:22:49
    zircon 实现两种调度机制,一种就是fair 其实现在fair_scheduler.cpp中,一种是基于时间片的其实现在sched.cpp 中,调度器的入口都在sche_reschedule()这个函数中。 例如fair的实现如下: void sched_reschedule() {...
    zircon 实现两种调度机制,一种就是fair 其实现在fair_scheduler.cpp中,一种是基于时间片的其实现在sched.cpp 中,调度器的入口都在sche_reschedule()这个函数中。
    例如fair的实现如下:
    void sched_reschedule() {
        FairScheduler::Reschedule();
    }
    fair的实现是一个cpp的类。
    另一中sche_reschedule()的实现在sched.cpp 中,我们简单看下
    void sched_reschedule() {
       
       
        current_thread->state = THREAD_READY;
    
        // idle thread doesn't go in the run queue
        if (likely(!thread_is_idle(current_thread))) {
    
    #可见会首先判断当前线程的时间片是否用尽,用尽的话,则加入到当前cpu 运行队列的末尾,否则就插入到head,这样下次调用这个函数的时候就会
    优先调用这个函数  
            if (current_thread->remaining_time_slice > 0) {
                insert_in_run_queue_head(curr_cpu, current_thread);
            } else {
                insert_in_run_queue_tail(curr_cpu, current_thread);
            }
        }
    
        sched_resched_internal();
    }
    void sched_resched_internal() {
        thread_t* current_thread = get_current_thread();
        uint cpu = arch_curr_cpu_num();
    
        
        CPU_STATS_INC(reschedules);
    
        // pick a new thread to run
    #从当前cpu 挑选一个thread 来运行,类似于linux的RR调度
        thread_t* newthread = sched_get_top_thread(cpu);
    
        DEBUG_ASSERT(newthread);
    
        newthread->state = THREAD_RUNNING;
    
        thread_t* oldthread = current_thread;
        oldthread->preempt_pending = false;
    
        
    #计算久进程的时间记账
        zx_time_t now = current_time();
    
        // account for time used on the old thread
        DEBUG_ASSERT(now >= oldthread->last_started_running);
        zx_duration_t old_runtime = zx_time_sub_time(now, oldthread->last_started_running);
        oldthread->runtime_ns = zx_duration_add_duration(oldthread->runtime_ns, old_runtime);
        oldthread->remaining_time_slice = zx_duration_sub_duration(
            oldthread->remaining_time_slice, MIN(old_runtime, oldthread->remaining_time_slice));
    
        // set up quantum for the new thread if it was consumed
        if (newthread->remaining_time_slice == 0) {
            newthread->remaining_time_slice = THREAD_INITIAL_TIME_SLICE;
        }
    
        newthread->last_started_running = now;
    #切换mmu
        // see if we need to swap mmu context
        if (newthread->aspace != oldthread->aspace) {
            vmm_context_switch(oldthread->aspace, newthread->aspace);
        }
    #进程切换
        // do the low level context switch
        final_context_switch(oldthread, newthread);
    }

     

    展开全文
  • 本文介绍APScheduler最基本的用法“定时几秒后启动job”,解释其中两种调度器BackgroundScheduler和BlockingScheduler的区别,说明了如何做到“让job在start()后就开始运行”,详述“job执行时间大于定时调度时间”...

    摘要

    本文介绍APScheduler最基本的用法“定时几秒后启动job”,解释其中两种调度器BackgroundSchedulerBlockingScheduler的区别,说明了如何做到“让job在start()后就开始运行”,详述“job执行时间大于定时调度时间”这种特殊情况的问题及解决方法,并说明了每个job都会以thread的方式被调度。

    基本的定时调度

    APScheduler是python的一个定时任务调度框架,能实现类似linux下crontab类型的任务,使用起来比较方便。它提供基于固定时间间隔、日期以及crontab配置类似的任务调度,并可以持久化任务,或将任务以daemon方式运行。

    下面是一个最基本的使用示例:

    from apscheduler.schedulers.blocking import BlockingScheduler
    
    def job():
        print('job 3s')
    
    
    if __name__=='__main__':
    
        sched = BlockingScheduler(timezone='MST')
        sched.add_job(job, 'interval', id='3_second_job', seconds=3)
        sched.start()
    

    它能实现每隔3s就调度job()运行一次,所以程序每隔3s就输出’job 3s’。通过修改add_job()的参数seconds,就可以改变任务调度的间隔时间。

    BlockingSchedulerBackgroundScheduler区别

    APScheduler中有很多种不同类型的调度器,BlockingSchedulerBackgroundScheduler是其中最常用的两种调度器。那他们之间有什么区别呢? 简单来说,区别主要在于BlockingScheduler会阻塞主线程的运行,而BackgroundScheduler不会阻塞。所以,我们在不同的情况下,选择不同的调度器:

    • BlockingScheduler: 调用start函数后会阻塞当前线程。当调度器是你应用中唯一要运行的东西时(如上例)使用。
    • BackgroundScheduler: 调用start后主线程不会阻塞。当你不运行任何其他框架时使用,并希望调度器在你应用的后台执行。

    下面用两个例子来更直观的说明两者的区别。

    • BlockingScheduler的真实例子
    from apscheduler.schedulers.blocking import BlockingScheduler
    import time
    
    def job():
        print('job 3s')
    
    
    if __name__=='__main__':
    
        sched = BlockingScheduler(timezone='MST')
        sched.add_job(job, 'interval', id='3_second_job', seconds=3)
        sched.start()
    
        while(True):
            print('main 1s')
            time.sleep(1)
    

    运行这个程序,我们得到如下的输出:

    job 3s
    job 3s
    job 3s
    job 3s

    可见,BlockingScheduler调用start函数后会阻塞当前线程,导致主程序中while循环不会被执行到。

    • BackgroundScheduler的真实例子
    from apscheduler.schedulers.background import BackgroundScheduler
    import time
    
    def job():
        print('job 3s')
    
    
    if __name__=='__main__':
    
        sched = BackgroundScheduler(timezone='MST')
        sched.add_job(job, 'interval', id='3_second_job', seconds=3)
        sched.start()
    
        while(True):
            print('main 1s')
            time.sleep(1)
    

    可见,BackgroundScheduler调用start函数后并不会阻塞当前线程,所以可以继续执行主程序中while循环的逻辑。

    main 1s
    main 1s
    main 1s
    job 3s
    main 1s
    main 1s
    main 1s
    job 3s

    通过这个输出,我们也可以发现,调用start函数后,job()并不会立即开始执行。而是等待3s后,才会被调度执行。

    如何让job在start()后就开始运行

    如何才能让调度器调用start函数后,job()就立即开始执行呢?

    其实APScheduler并没有提供很好的方法来解决这个问题,但有一种最简单的方式,就是在调度器start之前,就运行一次job(),如下

    from apscheduler.schedulers.background import BackgroundScheduler
    import time
    
    def job():
        print('job 3s')
    
    
    if __name__=='__main__':
        job()
        sched = BackgroundScheduler(timezone='MST')
        sched.add_job(job, 'interval', id='3_second_job', seconds=3)
        sched.start()
    
        while(True):
            print('main 1s')
            time.sleep(1)

    这样就能得到如下的输出

    job 3s
    main 1s
    main 1s
    main 1s
    job 3s
    main 1s
    main 1s
    main 1s

    这样虽然没有绝对做到“让job在start()后就开始运行”,但也能做到“不等待调度,而是刚开始就运行job”。

    如果job执行时间过长会怎么样

    如果执行job()的时间需要5s,但调度器配置为每隔3s就调用一下job(),会发生什么情况呢?我们写了如下例子:

    from apscheduler.schedulers.background import BackgroundScheduler
    import time
    
    def job():
        print('job 3s')
        time.sleep(5)
    
    if __name__=='__main__':
    
        sched = BackgroundScheduler(timezone='MST')
        sched.add_job(job, 'interval', id='3_second_job', seconds=3)
        sched.start()
    
        while(True):
            print('main 1s')
            time.sleep(1)
    

    运行这个程序,我们得到如下的输出:

    main 1s
    main 1s
    main 1s
    job 3s
    main 1s
    main 1s
    main 1s
    Execution of job "job (trigger: interval[0:00:03], next run at: 2018-05-07 02:44:29 MST)" skipped: maximum number of running instances reached (1)
    main 1s
    main 1s
    main 1s
    job 3s
    main 1s

    可见,3s时间到达后,并不会“重新启动一个job线程”,而是会跳过该次调度,等到下一个周期(再等待3s),又重新调度job()。

    为了能让多个job()同时运行,我们也可以配置调度器的参数max_instances,如下例,我们允许2个job()同时运行:

    from apscheduler.schedulers.background import BackgroundScheduler
    import time
    
    def job():
        print('job 3s')
        time.sleep(5)
    
    if __name__=='__main__':
        job_defaults = { 'max_instances': 2 }
        sched = BackgroundScheduler(timezone='MST', job_defaults=job_defaults)
        sched.add_job(job, 'interval', id='3_second_job', seconds=3)
        sched.start()
    
        while(True):
            print('main 1s')
            time.sleep(1)

    运行程序,我们得到如下的输出:

    main 1s
    main 1s
    main 1s
    job 3s
    main 1s
    main 1s
    main 1s
    job 3s
    main 1s
    main 1s
    main 1s
    job 3s

    每个job是怎么被调度的

    通过上面的例子,我们发现,调度器是定时调度job()函数,来实现调度的。

    那job()函数会被以进程的方式调度运行,还是以线程来运行呢?

    为了弄清这个问题,我们写了如下程序:

    from apscheduler.schedulers.background import BackgroundScheduler
    import time,os,threading
    
    def job():
        print('job thread_id-{0}, process_id-{1}'.format(threading.get_ident(), os.getpid()))
        time.sleep(50)
    
    if __name__=='__main__':
        job_defaults = { 'max_instances': 20 }
        sched = BackgroundScheduler(timezone='MST', job_defaults=job_defaults)
        sched.add_job(job, 'interval', id='3_second_job', seconds=3)
        sched.start()
    
        while(True):
            print('main 1s')
            time.sleep(1)

    运行程序,我们得到如下的输出:

    main 1s
    main 1s
    main 1s
    job thread_id-10644, process_id-8872
    main 1s
    main 1s
    main 1s
    job thread_id-3024, process_id-8872
    main 1s
    main 1s
    main 1s
    job thread_id-6728, process_id-8872
    main 1s
    main 1s
    main 1s
    job thread_id-11716, process_id-8872

    可见,每个job()的进程ID都相同,但线程ID不同。所以,job()最终是以线程的方式被调度执行。

    参考

    展开全文
  • ​​​​​​​核心思想:FCFS算法是指进程调度时是从就绪的进程队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行的一种调度算法。 作用对象:既可用于作业调度,又可以用于进程调度。 缺点 不...
    • FCFS(First-come first-served)先来先服务调度算法

    • ​​​​​​​ 核心思想:FCFS算法是指进程调度时是从就绪的进程队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行的一种调度算法。 
    • 作用对象:既可用于作业调度,又可以用于进程调度。
    • 缺点
      • 不利于短作业
    • SJF(Short Job First)短作业优先调度算法

      • 核心思想:SJF算法是指以作业的长短来计算优先级,作业越短,其优先级越高,越优先将他们调入内存运行。
      • 作用对象:该算法同FCFS算法一样,既可用于作业调度,又可以用于进程调度。
      • 缺点
        • 必须预知作业的运行时间
        • 对长作业非常不利
        • 人机无法交互
        • 无法及时处理紧迫的作业
    • FCFS算法和SJF算法的比较

      • 相同点
        • 性质相同:都是作为一种调度算法
        • 作用对象相同:都可以用于作业调度和进程调度
      • 不同点
        • 算法思想不同
          • FCFS算法是指进程调度时是从就绪的进程队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行的一种调度算法。
          • SJF算法是指以作业的长短来计算优先级,作业越短,其优先级越高,越优先将他们调入内存运行。
        • 优缺点相对
          • FCFS有利于长作业,不利于短作业
          • SJF有利于短作业,不利于长作业
    展开全文
  • 编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算法分别进行模拟调度
  • 分布式调度架构:调度

    万次阅读 2021-12-22 20:42:43
    对比这两种调度算法知识扩展:两层调度如何保证不同的业务不会互相干扰?总结 前言 单体调度的核心是,所有节点的资源以及用户的任务均由中央服务器统一管理和调度。因此,中央服务器很容易成为单点瓶颈,会直接...
  • 轮转调度算法和动态优先级调度算法

    万次阅读 多人点赞 2016-12-12 23:03:22
    进程的调度算法有很多,例如先来先服务调度算法(FCFS),短作业优先算法(SJF),时间片轮转算法(RR)和优先级算法,这里我将通过代码的方式主要介绍轮转调度算法(RR)和动态优先级调度算法.  首先介绍下轮转调度算法:
  • ①设计进程控制块PCB表结构,分别适用于可强占的优先数调度算法和循环轮转调度算法。 ②建立进程就绪队列。对两种不同算法编制入链子程序。...③编制两种进程调度算法:1)可强占的优先进程调度;2)短作业调度
  • 操作系统——进程调度的几算法

    千次阅读 2020-04-27 16:08:57
    目录01. 进程调度算法概述02. 先来先服务调度算法03. 时间片轮转调度法04. 短作业(SJF)优先调度算法05. 最短剩余时间优先06....​ 先来先服务调度算法是一最简单的调度算法,也称为先进先出或严格排队方...
  • CPU调度

    千次阅读 2018-11-10 13:04:00
    CPU调度 引入了线程,对于支持它们的操作系统,是内核级的线程被操作系统调度,而不是进程。不过,术语线程调度或进程调度常常被交替使用。...进程在这个状态之间切换。进程执行从CPU区间(CP...
  • 非抢占式方式:在采用这种调度方式时,一旦把处理机分配给某进程后,就一直让它运行下去,决不会因为时钟中断或任何其它原因去抢占当前正在运行进程的处理机,直至该进程完成,或发生某事件而被阻塞时,才把处理机...
  • 进程调度两种算法JAVA实现----FCFS(先来先服务)和SJF(最短作业优先) 直接能运行,完整版本,jdk 1.6就行
  • YARN三种调度方式

    千次阅读 2019-09-06 10:33:19
    1. 三种调度器 FIFO调度器 先进先出,但不适合资源公平性 容量调度器 独立的专门队列保证小作业也可以提交后就启动,队列容量是专门保留的 以整个集群的利用率为代价,与FIFO比,大作业执行的时间要长 ...
  • 常见的几页面调度算法

    万次阅读 2016-09-10 21:38:52
    常见的页面调度算法  a.随机算法rang(Random Algorithm) 利用软件或硬件的随机数发生器来确定主存储器中被替换的页面。这中算法最简单,而且容易实现。但是,这种算法完全没有利用主存储器中...
  • 实验三时间片轮转算法和优先级调度算法模拟实现 ...2.编写两种调度算法程序: 优先级调度算法 时间片轮转调度算法 3. 按要求输出结果。 二、实验目的 1. 加深理解有关进程控制块、进程队列等概念...
  • c++ 操作系统实验 进程调度

    千次阅读 2017-05-18 14:11:47
    实验一 进程调度 实验学时:4学时 实验类型:设计 实验要求:必修 一、 实验目的 多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本...
  • 先来先服务(FCFS) 例题 短作业优先 例题
  • FCFS,SJF,HRRN调度算法总结分析(全)

    千次阅读 多人点赞 2020-06-22 22:37:35
    FCFS,SJF,HRRN调度算法三基本的调度算法先来先服务(FCFS, First Come First Serve )短作业优先(SJF, Shortest Job First )高响应比优先(HRRN,Highest Response Ratio Next )**三算法的总结:** 三基本的调度...
  • 【常用进程调度算法】

    千次阅读 2021-11-26 15:16:45
    试描述在采用下述几种调度算法时各个进程运行过程,并计算采用每种算法时的进程平均周转时间。假设忽略进程的调度时间。 ① 先来先服务调度算法。 ② 短进程优先调度算法。 ③时间片轮转调度算法(时间片为1ms)。 ...
  • yarn3种调度

    千次阅读 2020-05-30 12:34:19
    yarn调度器 试想一下,你现在所在的公司有一个hadoop的集群。但是A项目组经常做一些定时的BI报表,B项目组则经常使用一些软件做一些临时需求。那么他们肯定会遇到同时提交任务的场景,这个时候到底如何分配资源满足...
  • Yarn三种调度策略

    千次阅读 2019-11-21 18:21:01
    理想情况下,我们应用对Yarn资源的请求应该立刻得到满足,但现实情况资源往往是有限的,特别是在一个很繁忙的集群,一个应用资源的请求经常需要等待一段时间才能的到相应的...  在Yarn中有三种调度器可以选择:FI...
  • 【操作系统】_7进程调度算法

    千次阅读 2022-04-26 23:43:41
    书中一共描述了七种进程调度算法,为了学到这几种调度算法,后边做了几道练习题。 1. 先来先服务(FCFS)调度算法 先来先服务调度算法是最简单的调度方法。其基本原则是,按照进程进入就绪队列的先后次序进行选择。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 482,007
精华内容 192,802
关键字:

两种调度

友情链接: bv_cvxbook.rar