精华内容
下载资源
问答
  • FreeRTOS调度是唯一可以切换任务状态的实体。 非运行态 阻塞态 等待事件的任务处于阻塞态,任务会因等待两种不同的事件进入阻塞态 时间相关事件-此类事件要么是一个延时的相对时间,要么是一个

    任务状态

    运行态

    任务分为运行态和非运行态两种,在处理器运行过程中,任一时刻只能有一个任务处于运行态,非运行态又包含很多子态。

    当任务处于非运行态时,任务处于休眠态(dormant),它的状态被保存,以便下一次调度程序决定它应该进入运行态。当一个任务恢复执行时,它从最后一次离开运行态之前将要执行的指令开始执行。

    在这里插入图片描述

    FreeRTOS调度器是唯一可以切换任务状态的实体。

    非运行态

    阻塞态

    等待事件的任务处于阻塞态,任务会因等待两种不同的事件进入阻塞态

    1. 时间相关事件-此类事件要么是一个延时的相对时间,要么是一个要到达的绝对时间。例如,任务可能会进入阻塞态等待10ms通过
    2. 同步事件-此类事件源自另外一个任务或中断

    FreeRTOS中消息队列、二值信号量、计数型信号量、互斥信号量、递归互斥信号量、时间标志组、任务通知都会产生同步事件

    挂起态

    调度器不能条用处于挂起状态的任务。进入挂起状态的唯一方法是通过调用vTaskSuspend() API函数,解除挂起状态的方法是通过调用vTaskResume()或xTaskResumeFromISR() API函数。大多数应用程序不使用挂起状态

    就绪态

    任务既不是运行态,也不是处于阻塞态或挂起态,则被认为是就绪态。这些任务能够运行,因此准备即将运行,但此时并未处在运行状态

    在这里插入图片描述
    创建 任务 到 就 绪 态 : 任务创建完成后进入就 绪 态,表明任务已准备就绪,只等待调度器进行调度即可运行。

    就 绪 态 到 运行 态 :调度器发生任务切换 时,就绪列表中最高优先级的任务优先执行,进入运行态

    运行 态 到 就 绪 态 : 创建或还原更高优先级的任务后,将进行任务调度 。 此 时 ,就 绪列表中优先级最高的任务将变为运行状态 。 然 后 , 原 始 正在 运行 的 任务 将 从运行 状态 更 改 为 就 绪 状 态 , 并 位 于 就 绪 列 表 中 。 更 高 优先 级 任务 运行 结束 后 ,继续运行原始任务。

    运行 态 到 阻塞 态 : 正在 运行 的 任务 发 生 阻 塞(挂 起 、 延 时 、 读 信号 量 等 待 )时 , 该 任务 会 从 就 绪 列 表 中 删除 , 任 务 状态 由 运行 态 变 成 阻塞 态 , 然 后 发 生 任 务切换 , 运 行 就 绪 列 表 中 当前 最 高 优先 级 任务 。

    阻塞 态 到 就 绪 态 : 阻塞 的 任务 被 恢复 后 (任务 恢复 、 延 时 时 间 超 时 、 读信号量 超 时 或 读 到 信号 量 等 ) 此 时 被 恢复 的 任务 会 被 加 入 就 绪 列 表 , 从 而 由 阻塞 态 变成就绪态;如果此时被恢复任务的优先级高于正在运行任务的优先级,则会发生任务切换,将该任务将再次转换任务状态,由就绪态变成运行态。

    就绪态、阻塞态、运行态到挂起态:任务可以通过调用vTaskSuspend()API函数可以将处于任何状态的任务挂起,被挂起的任务得不到CPU的使用权,也不会参与调度,除非它从挂起态中解除。

    挂起态到就绪态:把一个挂起状态的任务恢复的唯一途径就是调用VTaskResume()或vTaskResumeFromISR()API函数,如果此时被恢复任务的优先级高于正在运行任务的优先级,则会发生任务切换,将该任务将再次转换任务状态,由就绪态变成运行态。

    创建任务

    xTaskCreate() API

    BaseType_t xTaskCreate( TaskFunction_t pvTaskCode,
    					  const char * const pcName,
    					  uint16_t usStackDepth,
    					  void *pvParameters,
    					  UBaseType_t uxPriority,
    					  TaskHandle_t *pxCreatedTask );
    
    Parameters NameDescription
    pvTaskCode该参数是一个指向实现该任务的函数的指针(事实上,是函数名)
    pcName人为自定义的任务名称 (FreeRTOS.h中的宏定义 configMAX_TASK_NAME_LEN 定义了任务名的字符串最大长度,超过此长度,会被截断)
    usStackDepth该参数是任务堆栈空间的深度大小(任务在被创建时,由内核分配专属于自己的堆栈空间),单位是Words (字),而非Bytes(字节),例如32位宽的栈空间,usStackDepth=100,此堆栈空间分配400 字节(100 * 4 =400Bytes),堆栈深度*堆栈宽度的大小不得超过unit_16类型变量的最大值
    pvParameters传递给任务函数的值(void * 类型),若无参数传递,则为NULL
    uxPriority任务优先级,范围:0-----(configMAX_PRIORITIES – 1)
    pxCreatedTask任务句柄,可用于更改任务优先级或删除任务等,如果不使用任务句柄,可以设置为NULL
    Returned value返回pdPASS,表示任务创建成功,返回pdFALL,表示创建失败,可能是因为堆栈空间不够

    例程

    void vTask1( void *pvParameters )  //任务函数1
    {
    	const char *pcTaskName = "Task 1 is running\r\n";
    	volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    	/* As per most tasks, this task is implemented in an infinite loop. */
    	for( ;; )
    	{
    		/* Print out the name of this task. */
    		vPrintString( pcTaskName );
    		/* Delay for a period. */
    		for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
    		{
    		}
    	}
    }
    
    void vTask2( void *pvParameters )  //任务函数2
    {
    	const char *pcTaskName = "Task 2 is running\r\n";
    	volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    	/* As per most tasks, this task is implemented in an infinite loop. */
    	for( ;; )
    	{
    		/* Print out the name of this task. */
    		vPrintString( pcTaskName );
    		/* Delay for a period. */
    		for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
    		{
    		}
    	}
    }
    
    int main( void )
    {
    	xTaskCreate( vTask1, /* Pointer to the function that implements the task. */
    				"Task 1",/* Text name for the task. This is to facilitatedebugging only. */
    				1000, /* Stack depth - small microcontrollers will use muchless stack than this. */
    				NULL, /* This example does not use the task parameter. */
    				1, /* This task will run at priority 1. */
    				NULL ); /* This example does not use the task handle. */
    	/* Create the other task in exactly the same way and at the same priority. */
    	xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );
    	vTaskStartScheduler();  //开启任务调度器
    
    	for( ;; );
    }
    

    任务内创建任务

    在一个任务中包含另外一个任务,Task1 任务函数中可以创建Task2任务。

    void vTask1( void *pvParameters )
    {
    	const char *pcTaskName = "Task 1 is running\r\n";
    	volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    	/*在进入死循环前,创建任务2*/		
    	xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );
    	for( ;; )
    	{
    		/* Print out the name of this task. */
    		vPrintString( pcTaskName );
    		/* Delay for a period. */
    		for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
    		{
    		}
    	}
    }
    

    任务参数

    使用任务函数参数传递要打印的文本

    void vTask1( void *pvParameters )
    {
    	const char *pcTaskName = "Task 1 is running\r\n";
    	volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    	xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );
    	for( ;; )
    	{
    		/* Print out the name of this task. */
    		vPrintString( pcTaskName );
    		/* Delay for a period. */
    		for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )
    		{
    		}
    	}
    }
    
    static const char *pcTextForTask1 = "Task 1 is running\r\n";
    static const char *pcTextForTask2 = "Task 2 is running\r\n";
    int main( void )
    {
    	/* Create one of the two tasks. */
    	xTaskCreate( vTaskFunction, /*任务函数名 */
    				"Task 1", /* 任务名 */
    				1000, /* 任务堆栈空间深度*/
    				(void*)pcTextForTask1, /* 使用任务参数传递要打印的文本 */
    				1, /* 任务优先级 */
    				NULL ); /*此处未用任务句柄 */
    	xTaskCreate( vTaskFunction, "Task 2", 1000, (void*)pcTextForTask2, 1, NULL );
    	
    	vTaskStartScheduler();  //开启任务调度
    
    	for( ;; );
    }
    

    任务优先级

    xTaskCreate() API函数为任务定义了一个初始优先级,这个优先级在调度器运行后可以使用vTaskPrioritySet() API函数来修改

    任务优先级的取值范围为 0 ---- (configMAX_PRIORITIES – 1) ,但不同的任务可以使用共同的任务优先级

    configMAX_PRIORITIES在FreeRTOS.h中定义

    configMAX_PRIORITIES 的最大值取决于使用的方法:

    1. Generic Method(通用方法)

    当使用此种方法,FreeRTOS并不限制configMAX_PRIORITIES可以设置的最大值。但是,它总是明智自动的保持configMAX_PRIORITIES取值不大,因为它的值越高,将消耗更多的RAM,最坏情况执行时间越长

    如果在FreeRTOSConfig.h头文件中将 configUSE_PORT_OPTIMISED_TASK_SELECTION 设置为0,那么将使用泛型方法,或者configUSE_PORT_OPTIMISED_TASK_SELECTION未在头文件中定义,或者泛型方法是使用中的FreeRTOS端口提供的唯一方法

    1. Architecture Optimized Method (架构优化方法)

    架构优化方法使用了少量的汇编代码,其比Generic Method 方法更快。如果使用架构优化的方法,那么configMAX_PRIORITIES不能大于32,与通用方法一样,建议将configMAX_PRIORITIES保持在必要的最小值,因为它的值越高,就越多RAM将被消耗。

    如果在FreeRTOSConfig.h中将configUSE_PORT_OPTIMISED_TASK_SELECTION设置为1,那么将使用架构优化的方法

    FreeRTOS调度器将始终确保能够运行的最高优先级任务是进入运行状态的任务。当多个相同优先级的任务能够运行时,调度器依次将每个任务转换到运行状态或转换出运行状态

    展开全文
  • uCOS-II任务管理之改变任务的优先级 在uCOS-II 里,任务的优先级也是是可以修改的。优先级翻转问题是可以通过改变任务优先级解决。 那什么是优先级翻转问题呢? 所谓优先级翻转问题(priority inversion)即当一个高...
    uCOS-II任务管理之改变任务的优先级
    在uCOS-II 里,任务的优先级也是是可以修改的。优先级翻转问题是可以通过改变任务优先级解决。
    那什么是优先级翻转问题呢?
    所谓优先级翻转问题(priority inversion)即当一个高优先级任务通过信号量机制访问共享资源时,该信号量已被一低优先级任务占有,而这个低优先级任务在访问共享资源时可能又被其它一些中等优先级任务抢先,因此造成高优先级任务被许多具有较低优先级任务阻塞,实时性难以得到保证。
    如果在访问共享资源时,恰当地修改任务的优先级就可以解决优先级翻转问题了。
    但改变任务的优先级也是很花时间的,如果不发生优先级翻转而提升了任务的优先级,释放资源后又改回原优先级,则无形中浪费了许多CPU时。在mcu21项目中并没有改变任务的优先级。

    改变任务的优先级的操作也是很简单的。主要是调用uCOS-II 系统函数OSTaskChangePrio (INT8U oldprio, INT8U newprio); ,它需要两个参数,一个任务原来的优先级,一个是任务改变后的优先级。


    下面深入地解剖下OSTaskChangePrio (INT8U oldprio, INT8U newprio)的实现过程:
    系统函数OSTaskChangePrio()

    INT8U OSTaskChangePrio (INT8U oldprio, INT8U newprio)
    {
        OS_TCB   *ptcb;
        OS_EVENT *pevent;
        INT8U     x;
        INT8U     y;
        INT8U     bitx;
        INT8U     bity;
     
        if ((oldprio >= OS_LOWEST_PRIO && oldprio != OS_PRIO_SELF)  ||        //(1)
             newprio >= OS_LOWEST_PRIO) {
            return (OS_PRIO_INVALID);
        }
        OS_ENTER_CRITICAL();
        if (OSTCBPrioTbl[newprio] != (OS_TCB *)0) {                           //(2)
            OS_EXIT_CRITICAL();
            return (OS_PRIO_EXIST);
        } else {
            OSTCBPrioTbl[newprio] = (OS_TCB *)1;                              //(3)
            OS_EXIT_CRITICAL();
            y    = newprio >> 3;                                              //(4)
            bity = OSMapTbl[y];
            x    = newprio & 0x07;
            bitx = OSMapTbl[x];
            OS_ENTER_CRITICAL();
            if (oldprio == OS_PRIO_SELF) {                                    //(5)
                oldprio = OSTCBCur->OSTCBPrio;
            }
            if ((ptcb = OSTCBPrioTbl[oldprio]) != (OS_TCB *)0) {              //(6)
                OSTCBPrioTbl[oldprio] = (OS_TCB *)0;                          //(7)
                if (OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) {               //(8)
                    if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {  //(9)
                        OSRdyGrp &= ~ptcb->OSTCBBitY;
                    }
                    OSRdyGrp    |= bity;                                      //(10)
                    OSRdyTbl[y] |= bitx;
                } else {
                    if ((pevent = ptcb->OSTCBEventPtr) != (OS_EVENT *)0) {    //(11)
                        if ((pevent->OSEventTbl[ptcb->OSTCBY] &=      
                             ~ptcb->OSTCBBitX) == 0) {
                            pevent->OSEventGrp &= ~ptcb->OSTCBBitY;
                        }
                        pevent->OSEventGrp    |= bity;                        //(12)
                        pevent->OSEventTbl[y] |= bitx;
                    }
                }
                OSTCBPrioTbl[newprio] = ptcb;                                 //(13)
                ptcb->OSTCBPrio       = newprio;                              //(14)
                ptcb->OSTCBY          = y;                                    //(15)
                ptcb->OSTCBX          = x;
                ptcb->OSTCBBitY       = bity;
                ptcb->OSTCBBitX       = bitx;
                OS_EXIT_CRITICAL();
                OSSched();                                                    //(16)
                return (OS_NO_ERR);
            } else {
                OSTCBPrioTbl[newprio] = (OS_TCB *)0;                          //(17)
                OS_EXIT_CRITICAL();
                return (OS_PRIO_ERR);
            }
        }
    }

    修改任务的优先级,需要经过以下几大步骤:
    1、 首先,用户不能改变空闲任务的优先级(1),但用户可以改变调用本函数的任务或者其它任务的优先级。为了改变调用本函数的任务的优先级,用户可以指定该任务当前的优先级或OS_PRIO_SELF,OSTaskChangePrio()会决定该任务的优先级。用户还必须指定任务的新(即想要的)优先级。因为μC/OS-Ⅱ不允许多个任务具有相同的优先级,所以OSTaskChangePrio()需要检验新优先级是否是合法的(即不存在具有新优先级的任务)(2)。如果新优先级是合法的,μC/OS-Ⅱ通过将某些东西储存到OSTCBPrioTbl[newprio]中保留这个优先级(3)。如此就使得OSTaskChangePrio()可以重新允许中断,因为此时其它任务已经不可能建立拥有该优先级的任务,也不能通过指定相同的新优先级来调用OSTaskChangePrio()。接下来OSTaskChangePrio()可以预先计算新优先级任务的OS_TCB中的某些值(4)。而这些值用来将任务放入就绪表或从该表中移除(参看3.04,就绪表)。
    2、 其次,OSTaskChangePrio()检验目前的任务是否想改变它的优先级(5)。然后,OSTaskChangePrio()检查想要改变优先级的任务是否存在(6)。很明显,如果要改变优先级的任务就是当前任务,这个测试就会成功。但是,如果OSTaskChangePrio()想要改变优先级的任务不存在,它必须将保留的新优先级放回到优先级表OSTCBPrioTbl[]中(17),并返回给调用者一个错误码。
    3、 再次,OSTaskChangePrio()可以通过插入NULL指针将指向当前任务OS_TCB的指针从优先级表中移除了(7)。这就使得当前任务的旧的优先级可以重新使用了。接着,我们检验一下OSTaskChangePrio()想要改变优先级的任务是否就绪(8)。如果该任务处于就绪状态,它必须在当前的优先级下从就绪表中移除(9),然后在新的优先级下插入到就绪表中(10)。这儿需要注意的是,OSTaskChangePrio()所用的是重新计算的值(4)将任务插入就绪表中的。
      如果任务已经就绪,它可能会正在等待一个信号量、一封邮件或是一个消息队列。如果OSTCBEventPtr非空(不等于NULL)(8),OSTaskChangePrio()就会知道任务正在等待以上的某件事。如果任务在等待某一事件的发生,OSTaskChangePrio()必须将任务从事件控制块(参看6.00,事件控制块)的等待队列(在旧的优先级下)中移除。并在新的优先级下将事件插入到等待队列中(12)。任务也有可能正在等待延时的期满(参看第五章-任务管理)或是被挂起(参看4.07,挂起任务,OSTaskSuspend())。在这些情况下,从(8)到(12)这几行可以略过。

    4、 最后,这也是最关键的一步,任务的优先级就是这里被修改的,其实简单来说就是修改任务控制块里面的参数。在任务块里,OSTCBPrio、OSTCBY、OSTCBX、OSTCBBitY、OSTCBBitX这几个变量的值标注了任务的优先级,修改任务的优先级就是修改这几个变量的值。OSTaskChangePrio()将指向任务OS_TCB的指针存到OSTCBPrioTbl[]中(13)。新的优先级被保存在OS_TCB中(14),重新计算的值也被保存在OS_TCB中(15)。OSTaskChangePrio()完成了关键性的步骤后,在新的优先级高于旧的优先级或新的优先级高于调用本函数的任务的优先级情况下,任务调度程序就会被调用(16)。


    展开全文
  • uCOS-II任务管理之改变任务的优先级

    千次阅读 2016-12-01 21:46:01
    uCOS-II任务管理之改变任务的优先级 在uCOS-II 里,任务的优先级也是是可以修改的。优先级翻转问题是可以通过改变任务优先级解决。 那什么是优先级翻转问题呢? 所谓优先级翻转问题(priority inversion)即当一个...
    uCOS-II任务管理之改变任务的优先级
    在uCOS-II 里,任务的优先级也是是可以修改的。优先级翻转问题是可以通过改变任务优先级解决。
    那什么是优先级翻转问题呢?
    所谓优先级翻转问题(priority inversion)即当一个高优先级任务通过信号量机制访问共享资源时,该信号量已被一低优先级任务占有,而这个低优先级任务在访问共享资源时可能又被其它一些中等优先级任务抢先,因此造成高优先级任务被许多具有较低优先级任务阻塞,实时性难以得到保证。
    如果在访问共享资源时,恰当地修改任务的优先级就可以解决优先级翻转问题了。
    但改变任务的优先级也是很花时间的,如果不发生优先级翻转而提升了任务的优先级,释放资源后又改回原优先级,则无形中浪费了许多CPU时。在mcu21项目中并没有改变任务的优先级。

    改变任务的优先级的操作也是很简单的。主要是调用uCOS-II 系统函数OSTaskChangePrio (INT8U oldprio, INT8U newprio); ,它需要两个参数,一个任务原来的优先级,一个是任务改变后的优先级。


    下面深入地解剖下OSTaskChangePrio (INT8U oldprio, INT8U newprio)的实现过程:
    系统函数OSTaskChangePrio()

    [cpp]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. INT8U OSTaskChangePrio (INT8U oldprio, INT8U newprio)  
    2. {  
    3.     OS_TCB   *ptcb;  
    4.     OS_EVENT *pevent;  
    5.     INT8U     x;  
    6.     INT8U     y;  
    7.     INT8U     bitx;  
    8.     INT8U     bity;  
    9.    
    10.     if ((oldprio >= OS_LOWEST_PRIO && oldprio != OS_PRIO_SELF)  ||        //(1)  
    11.          newprio >= OS_LOWEST_PRIO) {  
    12.         return (OS_PRIO_INVALID);  
    13.     }  
    14.     OS_ENTER_CRITICAL();  
    15.     if (OSTCBPrioTbl[newprio] != (OS_TCB *)0) {                           //(2)  
    16.         OS_EXIT_CRITICAL();  
    17.         return (OS_PRIO_EXIST);  
    18.     } else {  
    19.         OSTCBPrioTbl[newprio] = (OS_TCB *)1;                              //(3)  
    20.         OS_EXIT_CRITICAL();  
    21.         y    = newprio >> 3;                                              //(4)  
    22.         bity = OSMapTbl[y];  
    23.         x    = newprio & 0x07;  
    24.         bitx = OSMapTbl[x];  
    25.         OS_ENTER_CRITICAL();  
    26.         if (oldprio == OS_PRIO_SELF) {                                    //(5)  
    27.             oldprio = OSTCBCur->OSTCBPrio;  
    28.         }  
    29.         if ((ptcb = OSTCBPrioTbl[oldprio]) != (OS_TCB *)0) {              //(6)  
    30.             OSTCBPrioTbl[oldprio] = (OS_TCB *)0;                          //(7)  
    31.             if (OSRdyTbl[ptcb->OSTCBY] & ptcb->OSTCBBitX) {               //(8)  
    32.                 if ((OSRdyTbl[ptcb->OSTCBY] &= ~ptcb->OSTCBBitX) == 0) {  //(9)  
    33.                     OSRdyGrp &= ~ptcb->OSTCBBitY;  
    34.                 }  
    35.                 OSRdyGrp    |= bity;                                      //(10)  
    36.                 OSRdyTbl[y] |= bitx;  
    37.             } else {  
    38.                 if ((pevent = ptcb->OSTCBEventPtr) != (OS_EVENT *)0) {    //(11)  
    39.                     if ((pevent->OSEventTbl[ptcb->OSTCBY] &=        
    40.                          ~ptcb->OSTCBBitX) == 0) {  
    41.                         pevent->OSEventGrp &= ~ptcb->OSTCBBitY;  
    42.                     }  
    43.                     pevent->OSEventGrp    |= bity;                        //(12)  
    44.                     pevent->OSEventTbl[y] |= bitx;  
    45.                 }  
    46.             }  
    47.             OSTCBPrioTbl[newprio] = ptcb;                                 //(13)  
    48.             ptcb->OSTCBPrio       = newprio;                              //(14)  
    49.             ptcb->OSTCBY          = y;                                    //(15)  
    50.             ptcb->OSTCBX          = x;  
    51.             ptcb->OSTCBBitY       = bity;  
    52.             ptcb->OSTCBBitX       = bitx;  
    53.             OS_EXIT_CRITICAL();  
    54.             OSSched();                                                    //(16)  
    55.             return (OS_NO_ERR);  
    56.         } else {  
    57.             OSTCBPrioTbl[newprio] = (OS_TCB *)0;                          //(17)  
    58.             OS_EXIT_CRITICAL();  
    59.             return (OS_PRIO_ERR);  
    60.         }  
    61.     }  
    62. }  

    修改任务的优先级,需要经过以下几大步骤:
    1、 首先,用户不能改变空闲任务的优先级(1),但用户可以改变调用本函数的任务或者其它任务的优先级。为了改变调用本函数的任务的优先级,用户可以指定该任务当前的优先级或OS_PRIO_SELF,OSTaskChangePrio()会决定该任务的优先级。用户还必须指定任务的新(即想要的)优先级。因为μC/OS-Ⅱ不允许多个任务具有相同的优先级,所以OSTaskChangePrio()需要检验新优先级是否是合法的(即不存在具有新优先级的任务)(2)。如果新优先级是合法的,μC/OS-Ⅱ通过将某些东西储存到OSTCBPrioTbl[newprio]中保留这个优先级(3)。如此就使得OSTaskChangePrio()可以重新允许中断,因为此时其它任务已经不可能建立拥有该优先级的任务,也不能通过指定相同的新优先级来调用OSTaskChangePrio()。接下来OSTaskChangePrio()可以预先计算新优先级任务的OS_TCB中的某些值(4)。而这些值用来将任务放入就绪表或从该表中移除(参看3.04,就绪表)。
    2、 其次,OSTaskChangePrio()检验目前的任务是否想改变它的优先级(5)。然后,OSTaskChangePrio()检查想要改变优先级的任务是否存在(6)。很明显,如果要改变优先级的任务就是当前任务,这个测试就会成功。但是,如果OSTaskChangePrio()想要改变优先级的任务不存在,它必须将保留的新优先级放回到优先级表OSTCBPrioTbl[]中(17),并返回给调用者一个错误码。
    3、 再次,OSTaskChangePrio()可以通过插入NULL指针将指向当前任务OS_TCB的指针从优先级表中移除了(7)。这就使得当前任务的旧的优先级可以重新使用了。接着,我们检验一下OSTaskChangePrio()想要改变优先级的任务是否就绪(8)。如果该任务处于就绪状态,它必须在当前的优先级下从就绪表中移除(9),然后在新的优先级下插入到就绪表中(10)。这儿需要注意的是,OSTaskChangePrio()所用的是重新计算的值(4)将任务插入就绪表中的。
      如果任务已经就绪,它可能会正在等待一个信号量、一封邮件或是一个消息队列。如果OSTCBEventPtr非空(不等于NULL)(8),OSTaskChangePrio()就会知道任务正在等待以上的某件事。如果任务在等待某一事件的发生,OSTaskChangePrio()必须将任务从事件控制块(参看6.00,事件控制块)的等待队列(在旧的优先级下)中移除。并在新的优先级下将事件插入到等待队列中(12)。任务也有可能正在等待延时的期满(参看第五章-任务管理)或是被挂起(参看4.07,挂起任务,OSTaskSuspend())。在这些情况下,从(8)到(12)这几行可以略过。

    4、 最后,这也是最关键的一步,任务的优先级就是这里被修改的,其实简单来说就是修改任务控制块里面的参数。在任务块里,OSTCBPrio、OSTCBY、OSTCBX、OSTCBBitY、OSTCBBitX这几个变量的值标注了任务的优先级,修改任务的优先级就是修改这几个变量的值。OSTaskChangePrio()将指向任务OS_TCB的指针存到OSTCBPrioTbl[]中(13)。新的优先级被保存在OS_TCB中(14),重新计算的值也被保存在OS_TCB中(15)。OSTaskChangePrio()完成了关键性的步骤后,在新的优先级高于旧的优先级或新的优先级高于调用本函数的任务的优先级情况下,任务调度程序就会被调用(16)。

    展开全文
  • 日常任务优先级管理

    千次阅读 2016-07-12 15:32:39
    作为一个开发人员,我们经常会接到一堆开发任务,这些任务常常表现的都很急,都需要尽快完成。但是我们精力是有限的,也不能像CPU那样并发执行任务任务再多也只能一件一件的去做。那么,怎么对这些任务排序呢?...

    作为一个开发人员,我们经常会接到一堆开发任务,这些任务常常表现的都很急,都需要尽快完成。但是我们精力是有限的,也不能像CPU那样并发执行任务,任务再多也只能一件一件的去做。那么,怎么对这些任务排序呢?下面讲解一个我从知乎上看到方法,可以很快把任务排列出一个合理的先后顺序。

    假设有如下任务:
    1、修复线上紧急Bug;
    2、增加一个统计用户活跃次数的功能;
    3、有个功能操作繁琐,体验较差,需要改善;
    4、用户定制功能;
    5、目前只支持支付宝,增加支持微信支付功能;

    第一步:任务名字简化,使用P1,P2,P3(P1最重要)标记任务的重要程度,并说明原因。
    1、紧急Bug:P1(影响用户使用,如果不修复,会导致用户流失)
    2、统计活跃次数:P3(并不是太紧急)
    3、简化操作:P2(能较大提高用户体验,目前也能正常使用);
    4、用户定制:P3(。。。)
    5、微信支付:P3(让用户支付更加方便,但是目前能正常支付)

    用图表表示出来如下:
    按照重要程度归类

    第二步:标记任务开发难度,使用D1,D2,D3(D1最容易实现)标记任务的开发难度,并说明原因。
    1、紧急Bug:D1(已经差到原因,修改比较容易)
    2、统计活跃次数:D1(写一个过滤器,拦截每个用户请求,做好记录即可)
    3、简化操作:D3(重新梳理操作流程,改动也较大);
    4、用户定制:D3(需求可能还有改变,定制内容较多,有些较为复杂)
    5、微信支付:D2(联系微信,调试支付接口)

    用图表表示如下:
    按照难度归类

    第三步:将重要程度(P序列)和难度程度(D序列)合并成一个表格,P作为纵向,D作为横向
    合并表格

    第四步:一般按照如下的开发顺序执行
    执行顺序

    这样分类后,就能知道应该按照什么顺序来做开发了。

    展开全文
  • 这边有三类的任务手动、半自动、自动任务,要求优先级手动>半自动>自动。 因为我这边节点只有一个因此也没有使用到分布式,如果分布式的话配置可能更复杂一些。 这边的Celery版本是4.x.x,现有的很多博客都是3...
  • ucos II任务管理之四:改变任务的优先级 在ucos II 里,任务的优先级是可以改变的。可以修改任务优先级的一个好处就是可以解决优先级翻转的问题。 什么是优先级翻转问题?偷偷地百度一下 所谓优先级翻转问题...
  • 网上找了下java里的异步任务调度,很多,但没有基于优先级队列的(或者我没发现),于是我写了一个。 前方干货预警! 一共四个文件。 AloneTask.java(带有优先级任务类) ComparableThreadPoolExecutor.java...
  • 进程管理ps,优先级,top命令 一、什么是进程 进程就是系统未完成并且正在进行的工作 二、查看进程 1)图片查看 gnome-system-monitor 2)ps命令 ps 1. a ##在当前环境中运行的进程 -A ##所有进程 f #...
  • 用户任务优先级确定

    千次阅读 2009-10-21 10:53:00
    用户任务优先级确定 VxWorks系统中优先级...当操作系统在目标板上启动成功后,系统级任务已在运行,对主机与目标机之间的通信进行管理,因此用户任务优先级要低于系统级任务,一般最高为150。同时,对于用户各任务优先
  • 文章目录资源管理资源是什么CPU的含义内存的含义请求和约束带资源请求的 Pod 如何调度和运行kubernetes资源对象请求(requests)上限(limits)默认资源配置(limit range)资源配额(resource quota)应用优先级QoS...
  • Java/Android中的优先级任务队列的实践

    万次阅读 多人点赞 2017-05-12 22:18:32
    本篇文章适用于Java和Android开发者,会从实现一个最简单的队列过渡到实现一个带有优先级的队列,使用生活中最常见的的例子结合讲解,保准你可以掌握基本的队列原理。
  • 项目为SSM框架,Web界面可以下发生产订单任务,订单任务可以设置优先级,后台由Control层接收请求后,由任务管理业务层通过RabbitMq发送消息到生产系统,实现是通过优先级队列完成,后期由于新增需求,处于等待中...
  • 火星探测优先级翻转

    千次阅读 2012-07-14 10:18:46
    如果这个参数on的话,探路者的行为就是另一个样子了:首 先,气象任务优先级最低)获得互斥量,做写操作,在还没有完成写操作的时候,总线管理任务优先级最高)申请信号量,所以互斥量的所有者,气象任务,将 ...
  • 在React的concurrent模式下,低优先级任务执行过程中,一旦有更高优先级任务进来,那么这个低优先级任务会被取消,优先执行高优先级任务。等高优先级任务做完了,低优先级任务会被重新做一遍。 我们用一个具体...
  • Linux任务管理器介绍

    千次阅读 2018-09-25 14:48:28
    第一行是任务队列信息,同uptime命令的执行结果。 eg. top - 15:09:51 up 17 days , 3:38 , 4 users , load average : 1.09 , 3.39 , 4.76 15:09:51 当前时间 up 17 days , 3:38 系...
  • 优先级翻转

    2018-04-19 11:26:06
    最近被问到优先级翻转,baidu了一下简单来说,优先级翻转就是高优先级任务访问共享资源的时候,当共享资源被低优先级任务占用时,高优先级任务被其他低优先级任务阻塞,出现低优先级任务先于高优先级任务执行...
  • 今天老师上课讲到了uC/OS中的任务机制,所以我想要结合《μC/OS-III源码分析笔记》和中国大学MOOC-电子科技大学《嵌入式系统及应用》PPT写一篇笔记对这部分的内容进行总结。
  • yarn资源管理优先级设置

    千次阅读 2018-09-26 18:07:01
    作业优先级:mapreduce.job.priority,优先级默认有5个:LOW VERY_LOW NORMAL(默认) HIGH VERY_HIGH 1、静态设置 1.1 Pig版本 SET mapreduce.job.queuename root.etl.distcp; SET mapreduce.job.pri...
  • Win10:如何修改双网卡的优先级

    万次阅读 2017-09-30 16:05:27
    如何才能调整合适的网络优先级呢?一般来说,有两种方法比较常用。 一、调整网络高级设置 Windows默认有能够调节网络优先级的位置,Win7/Win8.1/Win10理论上都有这个功能,就在网络和共享中心,具体步骤如下: ...
  • 本文是Android进程管理系列文章的第二篇,会讲解进程管理中的优先级管理。 进程管理的第一篇文章:《进程的创建》请跳转至这里。 本文适合Android平台的应用程序开发者,也适合对于Android系统内部实现感兴趣...
  • windows任务管理器

    千次阅读 2018-12-10 11:18:47
    今天发现使用windows任务管理器时,里面的功能并没有全部用过,需要解决很多问题时,非常慌张,做两个总结,探究一下windows10里任务管理器里的功能。 1.文件,选项,查看 点击文件 会出现运行新任务和退出,点击...
  • Linux下的任务管理器-top命令

    万次阅读 2012-07-11 00:04:40
    Windows下的任务管理器虽然不好用(个人更喜欢Process Explorer些),但也算方便,可以方便的查看进程,CPU,内存...也可以很容易的结束进程 没有图形化界面下的Linux,也有命令可以实现Windows的任务管理器功能,这...
  • 对于如何控制 APP 在任务管理器中的 Title,我们可能知道,可以通过在 AndroidManifest.xml 中设置 application 或者主 activity 的 android:label 来实现,而且 activity 的优先级高于 application
  • 在第3章中,他介绍了一种时间管理技术,该技术涉及列出任务并确定其优先级,以便能够快速完成生活中最重要的事情。根据最重要的因素,其本质上是生活。 我已经修改了象限,使其能够满足您的“比较” /“优先”需求,...
  • -添加“每日/重复任务”,“查看下一个任务”和“任务优先级”的选项(以确定首先看到哪些任务) -创建身份验证 技术/图书馆: Vue.js,Knex.js,PostgreSql,Moment.js和Bootswatch 安装说明: $ npm安装 联系...
  • 嵌入式系统设计过程中任务优先级调度的策略   调度程序的功能是调度任务的执行顺序,非调度实体的存在却会导致调度程序的效率下降,为时限调度程序而设计的系统总是尽可能地减少非调度实体的数量以及这些实体...
  • 转贴 详解任务管理器

    千次阅读 2011-05-08 22:10:00
    详解任务管理器 樱木花盗 发表于 2010-12-1 16:05:36 ㈠、概述及菜单 任务管理器提供正在您的计算上运行的程序和进程的相关信息。也显示最常用的度量进程性能的单位。使用任务管理器可以监视计算机性能的...
  • 是否觉得日常工作很无序,经常工作杂乱无章,丢三落四,不能很好地控制每样工作的进度? (点击放大下图) 我一直在关注 ToDoList这个开源项目,它是一个简单有效的个人任务管理器,一树状结
  • 那么FreeRTOS任务的中断优先级与之前的串口中断那个优先级更高呢,这里有个重要参数 MAX_PRIORITIES:最大优先级 如图所示这里将最大优先级设置为7,那么0-7的优先级不受系统管理,同时也不可以调用系统的API函数;...
  • 本次更新覆盖任务导出权限、优先级自定义、任务属性优化等,以及其他方面的优化。1导出任务权限点导出任务时,只能导出拥有权限的任务类型。该权限可由管理员在项目设置中进行配置。2优先级自定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,704
精华内容 43,881
关键字:

任务管理器改优先级