精华内容
下载资源
问答
  • FreeRTOS高级篇8---FreeRTOS任务通知分析

    万次阅读 多人点赞 2016-06-10 22:38:07
    在FreeRTOS版本V8.2.0中推出了全新的功能:任务通知。...我在《 FreeRTOS系列第14篇---FreeRTOS任务通知》一文中介绍了任务通知如何使用以及局限性,今天我们将分析任务通知的实现源码,看一下任务通知是如何做到效率
            在FreeRTOS版本V8.2.0中推出了全新的功能:任务通知。在大多数情况下,任务通知可以替代二进制信号量、计数信号量、事件组,可以替代长度为1的队列(可以保存一个32位整数或指针值),并且任务通知速度更快、使用的RAM更少!我在《 FreeRTOS系列第14篇---FreeRTOS任务通知》一文中介绍了任务通知如何使用以及局限性,今天我们将分析任务通知的实现源码,看一下任务通知是如何做到效率与RAM消耗双赢的。
            在《FreeRTOS高级篇6---FreeRTOS信号量分析》一文中我们已经知道,FreeRTOS的信号量是使用队列机制实现的,数据结构也完全是队列的那一套。而任务通知则不同,它的数据结构嵌在任务TCB(任务控制块,见《FreeRTOS高级篇2---FreeRTOS任务创建分析》)中的,并且数据结构十分简单,涉及到任务TCB的两个字段,我们将它单独列出来:
    volatile uint32_t ulNotifiedValue; 	/*任务通知值*/  
    volatile uint8_t ucNotifyState;	/*任务通知状态,标识任务是否在等待通知等*/
    这两个字段占用5字节RAM(本文都是在32位系统下讨论),而一个队列数据结构至少占用76字节RAM!这不是同一数量级的,所以任务通知在RAM消耗上完胜。
    在分析队列和信号量的文章中,我们知道在使用队列、信号量前,必须先创建队列和信号量,目的是为了创建队列数据结构。比如使用API函数xQueueCreate()创建队列,用API函数xSemaphoreCreateBinary()创建二进制信号量等等。再来看任务通知,由于任务通知的数据结构包含在任务TCB中,只要任务存在,任务通知数据结构就已经创建完毕,可以直接使用!在易用性上,任务通知再次获胜。
    要想了解任务通知在性能上占优的原因,就要分析源代码了。
    只有任务可以等待通知,中断服务函数中不可以。如果等待的通知无效,任务会进入阻塞状态,我们可以将等待通知的任务看作是消费者;其它任务和中断可以向等待通知的任务发送通知,发送通知的任务和中断服务函数可以认为是生产者。处于阻塞的消费者得到通知后会再次进入就绪态。
    任务通知API函数主要有两类,一类发送通知,一类等待通知。发送通知API函数可以用于任务和中断服务函数,等待通知API函数只能用在任务中。

    1.发送通知

          我们先看一下发送通知API函数。这类函数比较多,有6个。但仔细分析会发现它们只能完成3种操作,每种操作有两个API函数,分别为带中断保护版本和不带中断保护版本。FreeRTOS将API细分为带中断保护版本和不带中断保护版本是为了节省中断服务程序处理时间,提升性能。
    和信号量类似,大多数发送通知API接口也是由宏实现的,如表1-1所示。
    表1-1:发送通知API函数与实际调用函数列表

    1.1 xTaskGenericNotify()

    不带中断保护的发送通知API函数实际都是调用函数xTaskGenericNotify()实现的,我们看一下这个函数原型:
    BaseType_t xTaskGenericNotify( 
            TaskHandle_t xTaskToNotify, 
            uint32_t ulValue, 
            eNotifyAction eAction, 
            uint32_t *pulPreviousNotificationValue )
    • xTaskToNotify:被通知的任务句柄。
    • ulValue:更新的通知值
    • eAction:枚举类型,指明更新通知值的方法,枚举变量成员以及作用见表1-2所示。
    • pulPreviousNotifyValue:回传未被更新的任务通知值。如果不需要回传未被更新的任务通知值,这里设置为NULL。
    表1-2:eNotifyAction枚举成员以及作用

    与入队操作相比较,发送通知API函数显得非常简单,整理后的源码如下所示:
    BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )
    {
    TCB_t * pxTCB;
    BaseType_t xReturn = pdPASS;
    uint8_t ucOriginalNotifyState;
    
    
        configASSERT( xTaskToNotify );
        pxTCB = ( TCB_t * ) xTaskToNotify;
    
    
        taskENTER_CRITICAL();
        {
            if( pulPreviousNotificationValue != NULL )
            {
    			/* 回传更新前的通知值*/
                *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;
            }
    
    
            ucOriginalNotifyState = pxTCB->ucNotifyState;
    
    
            pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
    
    
            switch( eAction )
            {
                case eSetBits   :
                    pxTCB->ulNotifiedValue |= ulValue;
                    break;
    
    
                case eIncrement :
                    ( pxTCB->ulNotifiedValue )++;
                    break;
    
    
                case eSetValueWithOverwrite :
                    pxTCB->ulNotifiedValue = ulValue;
                    break;
    
    
                case eSetValueWithoutOverwrite :
                    if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )
                    {
                        pxTCB->ulNotifiedValue = ulValue;
                    }
                    else
                    {
                        /* 上次的通知值还未取走,本次通知值丢弃 */
                        xReturn = pdFAIL;
                    }
                    break;
    
    
                case eNoAction:
                    /* 不需要更新通知值*/
                    break;
            }
    
    
            traceTASK_NOTIFY();
    
    
            /* 如果被通知的任务因为等待通知而阻塞,现在将它解除阻塞 */
            if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
            {
                ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
                prvAddTaskToReadyList( pxTCB );
    
    
                if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
                {
                    /* 如果被通知的任务优先级高于当前任务,则触发PendSV中断,退出临界区后进行上下文切换T*/
                    taskYIELD_IF_USING_PREEMPTION();
                }
            }
        }
        taskEXIT_CRITICAL();
    
    
        return xReturn;
    }
    函数的功能可以概括为:按照指定的方法更新通知值,如果被通知的任务处于阻塞状态,则将它解除阻塞,解除阻塞任务的优先级如果大于当前任务的优先级,则触发一次任务切换。
    与释放信号量API函数相比,本函数少了很多调用子函数开销、少了很多判断、少了对事件列表的操作等等,确实是比释放信号量的实现要简洁的多。这也是有原因的,因为任务通知有它自己的局限性,并不能完全代替信号量。比如一个任务只能阻塞到一个通知上,如想要实现多个任务阻塞到同一个事件上,只能使用信号量了。也正是因为这种局限性,使得任务通知实现起来简单高效,并且大多数情况下,任务通知的方法就已经能解决问题了。

    1.2 vTaskNotifyGiveFromISR()

    这个API函数是vTaskNotifyGive()的带中断保护版本,是专门设计用来在某些情况下代替二进制信号量和计数信号量的。函数也很简单,我们直接看源码,源码经过整理和注释,以方便理解。
    void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )
    {
    TCB_t * pxTCB;
    uint8_t ucOriginalNotifyState;
    UBaseType_t uxSavedInterruptStatus;
    
    
        pxTCB = ( TCB_t * ) xTaskToNotify;
    
    
        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
        {
            ucOriginalNotifyState = pxTCB->ucNotifyState;
            pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
    
    
            /* 通知值加1,相当于释放了一个信号量 */
            ( pxTCB->ulNotifiedValue )++;
    
    
            /* 如果目标任务因为等待通知而阻塞,现在将它解除阻塞*/
            if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
            {
                /* 如果调度器正常,将任务放入就绪列表,否则放入挂起就绪列表 */
                if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
                {
                    ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
                    prvAddTaskToReadyList( pxTCB );
                }
                else
                {
                    vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
                }
    
    
                if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
                {
                    /* 如果解除阻塞的任务优先级大于当前任务优先级,则设置上下文切换标识,等退出函数后手动切换上下文,或者在系统节拍中断服务程序中自动切换上下文*/
                    if( pxHigherPriorityTaskWoken != NULL )
                    {
                        *pxHigherPriorityTaskWoken = pdTRUE;    /* 设置手动切换标志 */
                    }
                    else
                    {
                        xYieldPending = pdTRUE;                 /* 设置自动切换标志 */
                    }
                }
            }
        }
        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
    }

    1.3  xTaskGenericNotifyFromISR()

            如表1-1所示,带中断保护版本的API函数xTaskNotifyFromISR()和xTaskNotifyAndQueryFromISR()都是宏定义,真正被调用的函数为xTaskGenericNotifyFromISR()。这个函数用于在中断在中发送通知,与不带中断保护的API函数xTaskGenericNotify()非常相似,只是增加了一些中断保护措施,我们直接看源码。通用源码经过整理和注释,以方便理解。
    BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken )
    {
    TCB_t * pxTCB;
    uint8_t ucOriginalNotifyState;
    BaseType_t xReturn = pdPASS;
    UBaseType_t uxSavedInterruptStatus;
    
    
        pxTCB = ( TCB_t * ) xTaskToNotify;
    
    
        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
        {
            if( pulPreviousNotificationValue != NULL )
            {
                /* 回传更新前的通知值 */
                *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;
            }
    
    
            ucOriginalNotifyState = pxTCB->ucNotifyState;
            pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
            
            /* 根据参数设置通知值 */
            switch( eAction )
            {
                case eSetBits   :
                    pxTCB->ulNotifiedValue |= ulValue;
                    break;
    
    
                case eIncrement :
                    ( pxTCB->ulNotifiedValue )++;
                    break;
    
    
                case eSetValueWithOverwrite :
                    pxTCB->ulNotifiedValue = ulValue;
                    break;
    
    
                case eSetValueWithoutOverwrite :
                    if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )
                    {
                        pxTCB->ulNotifiedValue = ulValue;
                    }
                    else
                    {
                        /* 上次的通知值还未取走,本次通知值丢弃 */
                        xReturn = pdFAIL;
                    }
                    break;
    
    
                case eNoAction :
                    /* 不需要更新通知值*/
                    break;
            }
    
    
            traceTASK_NOTIFY_FROM_ISR();
    
    
            /* 如果被通知的任务因为等待通知而阻塞,现在将它解除阻塞 */
            if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
            {   
                /* 如果调度器正常,将任务放入就绪列表,否则放入挂起就绪列表 */
                if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
                {
                    ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
                    prvAddTaskToReadyList( pxTCB );
                }
                else
                {
                    vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
                }
    
    
                if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
                {
                    /* 如果解除阻塞的任务优先级大于当前任务优先级,则设置上下文切换标识,等退出函数后手动切换上下文,或者在系统节拍中断服务程序中自动切换上下文*/
                    if( pxHigherPriorityTaskWoken != NULL )
                    {
                        *pxHigherPriorityTaskWoken = pdTRUE;    /* 设置手动切换标志 */
                    }
                    else
                    {
                        xYieldPending = pdTRUE;                 /* 设置自动切换标志 */
                    }
                }
            }
        }
        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
    
    
        return xReturn;
    }

    2.等待通知

            等待通知API函数只能用在任务中,没有带中断保护版本,因此只有两个API函数:ulTaskNotifyTake()和xTaskNotifyWait ()。前者是为代替二进制信号量和计数信号量而专门设计的,它和发送通知API函数xTaskNotifyGive()、vTaskNotifyGiveFromISR()配合使用;后者是全功能版的等待通知,可以根据不同的参数实现轻量级二进制信号量、计数信号量、事件组和长度为1的队列。
            等待通知API函数都带有最大阻塞时间参数,当任务因为等待通知而进入阻塞时,用来规定最大阻塞时间。

    2.1 ulTaskNotifyTake()

    这个API函数用于实现轻量级的二进制信号量和计数信号量,源码如下所示。它有两个参数,如果第一个参数xClearCountOnExit设置为pdFALSE,则用来实现二进制信号量,函数退出时将通知值清零;如果第一个参数设置为pdTRUE,则用来实现计数信号量,函数退出时,将通知值减一。
    uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )
    {
    uint32_t ulReturn;
    
    
        taskENTER_CRITICAL();
        {
            /* 仅当通知值为0,才进行阻塞操作*/
            if( pxCurrentTCB->ulNotifiedValue == 0UL )
            {
                /* 设置标志,表示当前任务等待一个通知*/
                pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;
    
    
                if( xTicksToWait > ( TickType_t ) 0 )
                {   
                    /* 将任务加入延时列表 */
                    prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
                    traceTASK_NOTIFY_TAKE_BLOCK();
    
    
                    /* 触发PendSV中断,等到退出临界区时立即执行任务切换 */
                    portYIELD_WITHIN_API();
                }
            }
        }
        taskEXIT_CRITICAL();
        /* 到这里说明其它任务或中断向这个任务发送了通知,或者任务阻塞超时,现在继续处理*/
        taskENTER_CRITICAL();
        {
            traceTASK_NOTIFY_TAKE();
            ulReturn = pxCurrentTCB->ulNotifiedValue;   
    
    
            if( ulReturn != 0UL )
            {
                if( xClearCountOnExit != pdFALSE )
                {
                    pxCurrentTCB->ulNotifiedValue = 0UL;
                }
                else
                {
                    pxCurrentTCB->ulNotifiedValue = ulReturn - 1;
                }
            }
            /* 设置标志,表示不需要等待通知 */
            pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
        }
        taskEXIT_CRITICAL();
    
    
        return ulReturn;    /* 如果返回值为0,说明是任务阻塞超时了 */
    }
    与获取二进制信号量和获取计数信号量函数相比,本函数少了很多调用子函数开销、少了很多判断、少了事件列表处理、少了队列上锁与解锁处理等等,因此本函数相对效率很高。

    2.2xTaskNotifyWait()

    这个函数用于实现全功能版的等待通知,根据参数的不同,可以灵活的用于实现轻量级的队列、二进制信号量、计数信号量和事件组功能,函数原型为:
    BaseType_t xTaskNotifyWait( uint32_tulBitsToClearOnEntry,
                         uint32_tulBitsToClearOnExit,
                         uint32_t*pulNotificationValue,
                         TickType_txTicksToWait );
    • ulBitsToClearOnEntry:在使用通知之前,先将任务的通知值与参数ulBitsToClearOnEntry的按位取反值按位与操作。设置参数ulBitsToClearOnEntry为0xFFFFFFFF(ULONG_MAX),表示清零任务通知值。
    • ulBitsToClearOnExit:在函数xTaskNotifyWait()退出前,将任务的通知值与参数ulBitsToClearOnExit的按位取反值按位与操作。设置参数ulBitsToClearOnExit为0xFFFFFFFF(ULONG_MAX),表示清零任务通知值。
    • pulNotificationValue:用于向外回传任务的通知值。这个通知值在参数ulBitsToClearOnExit起作用前将通知值拷贝到*pulNotificationValue中。如果不需要返回任务的通知值,这里设置成NULL。
    • xTicksToWait:因等待通知而进入阻塞状态的最大时间。时间单位为系统节拍周期。宏pdMS_TO_TICKS用于将指定的毫秒时间转化为相应的系统节拍数。
    这个函数的实现和ulTaskNotifyTake()有很多相通之处,我将整个流程以注释形式置于源码中,源码如下所示:
    BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )
    {
    BaseType_t xReturn;
    
    
        taskENTER_CRITICAL();
        {
            /* 只有任务没有等待通知,才会将任务阻塞 */
            if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )
            {
                /* 使用任务通知值之前,先将参数ulBitsToClearOnEntryClear取反后与任务通知值位与.可以用这种方法在使用任务通知值之前,将通知值的某些或全部位清零 */
                pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;
    
    
                /* 设置任务状态标识:等待通知 */
                pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;
    
    
                if( xTicksToWait > ( TickType_t ) 0 )
                {
                    /* 阻塞当前任务 */
                    prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
                    traceTASK_NOTIFY_WAIT_BLOCK();
    
    
                    /* 触发PendSV中断,等到退出临界区后,执行任务切换 */
                    portYIELD_WITHIN_API();
                }
            }
        }
        taskEXIT_CRITICAL();
    
    
        /* 到这里说明其它任务或中断向这个任务发送了通知,或者任务阻塞超时,现在继续处理*/
        taskENTER_CRITICAL();
        {
            traceTASK_NOTIFY_WAIT();
    
    
            if( pulNotificationValue != NULL )
            {
                /* 输出当前通知值,通过指针参数传递*/
                *pulNotificationValue = pxCurrentTCB->ulNotifiedValue;
            }
    
    
            /* 判断是否是因为任务阻塞超时 */
            if( pxCurrentTCB->ucNotifyState == taskWAITING_NOTIFICATION )
            {
                /* 没有收到任务通知,是阻塞超时 */
                xReturn = pdFALSE;
            }
            else
            {
                /* 收到任务值,先将参数ulBitsToClearOnExit取反后与通知值位与,用于在退出函数前,将通知值的某些或者全部位清零. */
                pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnExit;
                xReturn = pdTRUE;
            }
            /* 更改任务通知状态,解除任务通知等待 */
            pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
        }
        taskEXIT_CRITICAL();
    
    
        return xReturn;
    }
    纵观整个任务通知的实现,可以发现它比队列、信号量相比要简单很多。它可以实现轻量级的队列、二进制信号量、计数信号量和事件组,并且使用更方便、更节省RAM、更高效。FreeRTOS的作者做过测试,在同一平台下,使用使用GCC编译器、-o2优化级别,相比使用信号量解除任务阻塞,使用任务通知可以快45%!这个性能的提升是巨大的。我们分析过信号量的源码,今天又分析了任务通知的源码,这使得我们知道,之所以有这么大的性能提升,一方面缘于任务通知数据结构简单、实现简洁;另一方面也跟FreeRTOS的信号量机制臃肿、效率低下有关。因为信号量的实现全部是使用队列机制,并没有为信号量做专门优化。
    此外,着重说明一下任务通知并不能完全代替队列、二进制信号量、计数信号量和事件组,任务通知有自己的局限性,我们就以它的局限性来结束本文:
    • 只能有一个任务接收通知事件。
    • 接收通知的任务可以因为等待通知而进入阻塞状态,但是发送通知的任务即便不能立即完成发送通知,也不能进入阻塞状态。



    展开全文
  • FreeRTOS系列第15篇---使用任务通知实现命令行解释器

    万次阅读 多人点赞 2016-02-12 09:27:02
    这一方面是因为任务通知使用起来非常简单,另一方面也因为对于嵌入式程序来说,使用命令行解释器来辅助程序调试是非常有用的。程序调试是一门技术,基本上我们需要两种调试手段,一种是可以单步仿真的硬件调试器,...

          虽然这是介绍FreeRTOS系列的文章,但这篇文章偏重于命令行解释器的实现。这一方面是因为任务通知使用起来非常简单,另一方面也因为对于嵌入式程序来说,使用命令行解释器来辅助程序调试是非常有用的。程序调试是一门技术,基本上我们需要两种调试手段,一种是可以单步仿真的硬件调试器,另外一种是可以长期监视程序状态的状态输出,可以通过串口、显示屏等等手段输出异常信息或者某些关键点。这里的命令行解释器就属于后者。

         本文实现的命令行解释器具有以下特性:

    • 支持十进制参数,识别负号;
    • 支持十六进制参数,十六进制以‘0x’开始;
    • 命令名长度可定义,默认最大20个字符;
    • 参数数目可定义,默认最多8个参数;
    • 命令名和参数之间以空格隔开,空格个数任意;
    • 整条命令以回车换行符结束;
    • 整条命令最大长度可定义,默认64字节,包括回车换行符;
    • 如果使用SecureCRT串口工具(推荐),支持该软件的控制字符,比如退格键、左移键、右移键等。

          一个带参数的命令格式如下所示:

                                          参数名 <参数1> <参数2> … <参数3>[回车换行符]

    1.编码风格

          FreeRTOS的编码标准及风格见《FreeRTOS系列第4篇---FreeRTOS编码标准及风格指南》,但我自己的编码风格跟FreeRTOS并不相同,并且我也不打算改变我当前坚持使用的编码风格。所以在这篇或者以后的文章中可能会在一个程序中看到两种不同的编码风格,对于涉及FreeRTOS的代码,我尽可能使用FreeRTOS建议的编码风格,与FreeRTOS无关的代码,我仍然使用自己的编码风格。我可以保证,两种编码风格决不会影响程序的可读性,编写良好可读性的代码,是我一直注重并坚持的。

    2.一些准备工作

    2.1串口硬件驱动

          命令行解释器使用一个硬件串口,需要外部提供两个串口底层函数:一个是串口初始化函数init_cmd_uart(),用于初始化串口波特率、中断等事件;另一个是发送单个字符函数my_putc()。此外,命令行为串口接收中断服务程序提供函数fill_rec_buf(),用于保存接收到的字符,当收到回车换行符后,该函数向命令行分析任务发送通知。

    2.2一个类printf函数

          类printf函数用来格式化输出,我一般用来辅助调试,为了方便的将调试代码从程序中去除,需要将类printf函数进行封装。我的文章《编写优质嵌入式C程序》第5.2节给出了一个完整的类printf函数实现和封装代码,最终我们使用到的类printf函数是如下形式的宏:

     MY_DEBUGF(CMD_LINE_DEBUG,("第%d个参数:%d\n",i+1,arg[i]));    

    3.使用任务通知

          我们将会创建一个任务,用来分析接收到的命令,如果命令有效则调用命令实现函数。这个任务名字为vTaskCmdAnalyze()。串口接收中断用于接收命令,如果接收到回车换行符,则向任务vTaskCmdAnalyze()发送任务通知,表明已经接收到一条完整命令,任务可以去处理了。

           示意框图如图3-1所示。


    4.数据结构

          命令行解释器程序需要涉及两个数据结构:一个与命令有关,包括命令的名字、命令的最大参数数目、命令的回调函数类型、命令帮助信息等;另一个与分析命令有关,包括接收命令字符缓冲区、存放参数缓冲区等。

    4.1与命令有关的数据结构

           定义如下:

       typedef struct {
            char const *cmd_name;                        //命令字符串
            int32_t max_args;                            //最大参数数目
            void (*handle)(int argc,void * cmd_arg);     //命令回调函数
            char  *help;                                 //帮助信息
        }cmd_list_struct;

          需要说明一下命令回调函数的参数,argc保存接收到的参数数目,cmd_arg指向参数缓冲区,目前只支持32位的整形参数,这在绝大多数嵌入式场合是足够的。

    4.2与分析命令有关数据结构

           定义如下:

    #define ARG_NUM     8          //命令中允许的参数个数
    #define CMD_LEN     20         //命令名占用的最大字符长度
    #define CMD_BUF_LEN 60         //命令缓存的最大长度
     
    typedef struct {
        char rec_buf[CMD_BUF_LEN];            //接收命令缓冲区
        char processed_buf[CMD_BUF_LEN];      //存储加工后的命令(去除控制字符)
        int32_t cmd_arg[ARG_NUM];             //保存命令的参数
    }cmd_analyze_struct;

          缓冲区的大小使用宏来定义,通过更改相应的宏定义,可以设置整条命令的最大长度、命令参数最大数目等。

    5.串口接收中断处理函数

          本文使用的串口软件是SecureCRT,在这个软件下敲击的任何键盘字符,都会立刻通过串口硬件发送出去,这与Telnet类似。所以我们无需使用串口的FIFO,每接收到一个字符就产生一次中断。串口中断与硬件关系密切,所以命令行解释器提供了一个与硬件无关的函数fill_rec_buf(),每当串口中断接收到一个字符,就以收到的字符为参数调用这个函数。       fill_rec_buf()函数主要操作变量cmd_analyze,变量的声明原型为:

           cmd_analyze_struct cmd_analyze;

           函数fill_rec_buf()的实现代码为:

    /*提供给串口中断服务程序,保存串口接收到的单个字符*/
    void fill_rec_buf(char data)
    {
        //接收数据 
        static uint32_t rec_count=0;
       
       cmd_analyze.rec_buf[rec_count]=data;
        if(0x0A==cmd_analyze.rec_buf[rec_count] && 0x0D==cmd_analyze.rec_buf[rec_count-1])
        {
           BaseType_t xHigherPriorityTaskWoken = pdFALSE;
           rec_count=0;
           
           /*收到一帧数据,向命令行解释器任务发送通知*/
           vTaskNotifyGiveFromISR (xCmdAnalyzeHandle,&xHigherPriorityTaskWoken);
           
           /*是否需要强制上下文切换*/
           portYIELD_FROM_ISR(xHigherPriorityTaskWoken );
        }
        else
        {
           rec_count++;
           
           /*防御性代码,防止数组越界*/
           if(rec_count>=CMD_BUF_LEN)
           {
               rec_count=0;
           }
        }    
    }

    6.命令行分析任务

          命令行分析任务大部分时间都会因为等待任务通知而处于阻塞状态。当接收到一个通知后,任务首先去除命令行中的无效字符和控制字符,然后找出命令名并分析参数数目、将参数转换成十六进制数并保存到参数缓冲区中,最后检查命令名和参数是否合法,如果合法则调用命令回调函数处理本条命令。

    6.1去除无效字符和控制字符

          串口软件SecureCRT支持控制字符。比如在输入一串命令的时候,发现某个字符输入错误,就要使用退格键或者左右移动键定位到错误的位置进行修改。这里的退格键和左右移动键都属于控制字符,比如退格键的键值为0x08、左移键的键值为0x1B0x5B 0x44。我们之前也说过,在软件SecureCRT中输入字符时,每敲击一个字符,该字符立刻通过串口发送给我们的嵌入式设备,也就是所有键值都会按照敲击键盘的顺序存入到接收缓冲区中,但这里面可能有我们不需要的字符,我们首先需要利用控制字符将不需要的字符删除掉。这个工作由函数get_true_char_stream()实现,代码如下所示:

    /**
    * 使用SecureCRT串口收发工具,在发送的字符流中可能带有不需要的字符以及控制字符,
    * 比如退格键,左右移动键等等,在使用命令行工具解析字符流之前,需要将这些无用字符以
    * 及控制字符去除掉.
    * 支持的控制字符有:
    *   上移:1B 5B 41
    *   下移:1B 5B 42
    *   右移:1B 5B 43
    *   左移:1B 5B 44
    *   回车换行:0D 0A
    *  Backspace:08
    *  Delete:7F
    */
    static uint32_t get_true_char_stream(char *dest,const char *src)
    {
       uint32_t dest_count=0;
       uint32_t src_count=0;
       
        while(src[src_count]!=0x0D && src[src_count+1]!=0x0A)
        {
           if(isprint(src[src_count]))
           {
               dest[dest_count++]=src[src_count++];
           }
           else
           {
               switch(src[src_count])
               {
                    case    0x08:                          //退格键键值
                    {
                        if(dest_count>0)
                        {
                            dest_count --;
                        }
                        src_count ++;
                    }break;
                    case    0x1B:
                    {
                        if(src[src_count+1]==0x5B)
                        {
                            if(src[src_count+2]==0x41 || src[src_count+2]==0x42)
                            {
                                src_count +=3;              //上移和下移键键值
                            }
                            else if(src[src_count+2]==0x43)
                            {
                                dest_count++;               //右移键键值
                                src_count+=3;
                            }
                            else if(src[src_count+2]==0x44)
                            {
                                if(dest_count >0)           //左移键键值
                                {
                                    dest_count --;
                                }
                               src_count +=3;
                            }
                            else
                            {
                                src_count +=3;
                            }
                        }
                        else
                        {
                            src_count ++;
                        }
                    }break;
                    default:
                    {
                        src_count++;
                    }break;
               }
           }
        }
       dest[dest_count++]=src[src_count++];
        dest[dest_count++]=src[src_count++];
        return dest_count;
    }

    6.2参数分析

          接收到的命令中可能带有参数,我们需要知道参数的数目,还需要把字符型的参数转换成整形数并保存到参数缓冲区(这是因为命令回调函数需要这两个参数)。这个工作由函数cmd_arg_analyze()实现,代码如下所示:

    /**
    * 命令参数分析函数,以空格作为一个参数结束,支持输入十六进制数(如:0x15),支持输入负数(如-15)
    * @param rec_buf   命令参数缓存区
    * @param len       命令的最大可能长度
    * @return -1:       参数个数过多,其它:参数个数
    */
    static int32_t cmd_arg_analyze(char *rec_buf,unsigned int len)
    {
       uint32_t i;
       uint32_t blank_space_flag=0;    //空格标志
       uint32_t arg_num=0;             //参数数目
       uint32_t index[ARG_NUM];        //有效参数首个数字的数组索引
       
        /*先做一遍分析,找出参数的数目,以及参数段的首个数字所在rec_buf数组中的下标*/
        for(i=0;i<len;i++)
        {
           if(rec_buf[i]==0x20)        //为空格
           {
               blank_space_flag=1;              
               continue;
           }
            else if(rec_buf[i]==0x0D)   //换行
           {
               break;
           }
           else
           {
               if(blank_space_flag==1)
               {
                    blank_space_flag=0; 
                    if(arg_num < ARG_NUM)
                    {
                       index[arg_num]=i;
                        arg_num++;         
                    }
                    else
                    {
                        return -1;      //参数个数太多
                    }
               }
           }
        }
       
        for(i=0;i<arg_num;i++)
        {
            cmd_analyze.cmd_arg[i]=string_to_dec((unsigned char *)(rec_buf+index[i]),len-index[i]);
        }
        return arg_num;
    }

          在这个函数cmd_arg_analyze()中,调用了字符转整形函数string_to_dec()。我们只支持整形参数,这里给出一个字符转整形函数的简单实现,可以识别负号和十六进制的前缀’0x’。在这个函数中调用了三个C库函数,分别是isdigit()、isxdigit()和tolower(),因此需要包含头文件#include <ctype.h>。函数string_to_dec()实现代码如下:

    /*字符串转10/16进制数*/
    static int32_t string_to_dec(uint8_t *buf,uint32_t len)
    {
       uint32_t i=0;
       uint32_t base=10;       //基数
       int32_t  neg=1;         //表示正负,1=正数
       int32_t  result=0;
       
        if((buf[0]=='0')&&(buf[1]=='x'))
        {
           base=16;
           neg=1;
           i=2;
        }
        else if(buf[0]=='-')
        {
           base=10;
           neg=-1;
           i=1;
        }
        for(;i<len;i++)
        {
           if(buf[i]==0x20 || buf[i]==0x0D)    //为空格
           {
               break;
           }
           
           result *= base;
           if(isdigit(buf[i]))                 //是否为0~9
           {
               result += buf[i]-'0';
           }
           else if(isxdigit(buf[i]))           //是否为a~f或者A~F
           {
                result+=tolower(buf[i])-87;
           }
           else
           {
               result += buf[i]-'0';
           }                                        
        }
       result *= neg;
       
        return result ;
    }

    6.3定义命令回调函数

          我们举两个例子:第一个是不带参数的例子,输入命令后,函数返回一个“Helloworld!”字符串;第二个是带参数的例子,我们输入命令和参数后,函数返回每一个参数值。我们在讲数据结构的时候特别提到过命令回调函数的原型,这里要根据这个函数原型来声明命令回调函数。

    6.3.1不带参数的命令回调函数举例

    /*打印字符串:Hello world!*/
    void printf_hello(int32_t argc,void *cmd_arg)
    {
       MY_DEBUGF(CMD_LINE_DEBUG,("Hello world!\n"));
    }

    6.3.2带参数的命令行回调函数举例

    /*打印每个参数*/
    void handle_arg(int32_t argc,void * cmd_arg)
    {
       uint32_t i;
       int32_t  *arg=(int32_t *)cmd_arg;
       
        if(argc==0)
        {
           MY_DEBUGF(CMD_LINE_DEBUG,("无参数\n"));
        }
        else
        {
           for(i=0;i<argc;i++)
           {
               MY_DEBUGF(CMD_LINE_DEBUG,("第%d个参数:%d\n",i+1,arg[i]));
           }
        }
    }

    6.4定义命令表

          在讲数据结构的时候,我们定义了与命令有关的数据结构。每条命令需要包括命名名、最大参数、命令回调函数、帮助等信息,这里要将每条命令组织成列表的形式。

    /*命令表*/
    const cmd_list_struct cmd_list[]={
    /*   命令    参数数目    处理函数        帮助信息                         */   
    {"hello",   0,      printf_hello,   "hello                      -打印HelloWorld!"},
    {"arg",     8,      handle_arg,      "arg<arg1> <arg2> ...      -测试用,打印输入的参数"},
    };

          如果要定义自己的命令,只需要按照6.3节的格式编写命令回调函数,然后将命令名、参数数目、回调函数和帮助信息按照本节格式加入到命令表中即可。

    6.5命令行分析任务实现

          有了上面的基础,命令行分析任务实现起来就非常轻松了,源码如下:

    /*命令行分析任务*/
    void vTaskCmdAnalyze( void *pvParameters )
    {
       uint32_t i;
       int32_t rec_arg_num;
        char cmd_buf[CMD_LEN];      
       
        while(1)
        {
           uint32_t rec_num;
           
           ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
        rec_num=get_true_char_stream(cmd_analyze.processed_buf,cmd_analyze.rec_buf);
           
           /*从接收数据中提取命令*/
           for(i=0;i<CMD_LEN;i++)
           {
               if((i>0)&&((cmd_analyze.processed_buf[i]==' ')||(cmd_analyze.processed_buf[i]==0x0D)))
               {
                    cmd_buf[i]='\0';        //字符串结束符
                    break;
               }
               else
               {
                    cmd_buf[i]=cmd_analyze.processed_buf[i];
               }
           }
           
           rec_arg_num=cmd_arg_analyze(&cmd_analyze.processed_buf[i],rec_num);
           
           for(i=0;i<sizeof(cmd_list)/sizeof(cmd_list[0]);i++)
           {
               if(!strcmp(cmd_buf,cmd_list[i].cmd_name))       //字符串相等
               {
                    if(rec_arg_num<0 || rec_arg_num>cmd_list[i].max_args)
                    {
                        MY_DEBUGF(CMD_LINE_DEBUG,("参数数目过多!\n"));
                    }
                    else
                    {
                        cmd_list[i].handle(rec_arg_num,(void *)cmd_analyze.cmd_arg);
                    }
                    break;
               }
               
           }
           if(i>=sizeof(cmd_list)/sizeof(cmd_list[0]))
           {
               MY_DEBUGF(CMD_LINE_DEBUG,("不支持的指令!\n"));
           }
        }
    }

    7.使用的串口工具

          推荐使用SecureCRT软件,这是我觉得最适合命令行交互的串口工具。此外,这个软件非常强大,除了支持串口,还支持SSH、Telnet等。对于串口,SecureCRT工具还支持文件发送协议:Xmodem、Ymodem和Zmodem。这在使用串口远程升级时很有用,可以用来发送新的程序二进制文件。我曾经使用Ymodem做过远程升级,以后有时间再详细介绍SecureCRT的Ymodem功能细节。

          要用于本文介绍的命令行解释器,要对SecureCRT软件做一些设置。

    7.1设置串口参数

          选择Serial功能、设置端口、波特率、校验等,特别要注意的是不要勾选任何流控制选项,如图2-1所示。


    图2-1:设置串口参数

    7.2设置新行模式

           依次点击菜单栏的“选项”---“会话选项”,在弹出的“会话选项”界面中,点击左边树形菜单的“终端”---“仿真”---“模式”,在右边的仿真模式区域选中“换行”和“新行模式”,如图2-2所示。


    图2-2:设置新行模式

     

    7.3设置本地回显

           依次点击菜单栏的“选项”---“会话选项”,在弹出的“会话选项”界面中,点击左边树形菜单的“终端”---“仿真”---“高级”,在右边的“高级仿真”区域,选中“本地回显”,如图2-3所示。


    图2-3:设置本地回显

    8.测试

           我们通过6.3节和6.4接定义了两个命令,第一条命令的名字为”hello”,这是一个无参数命令,直接输出字符串”Hello world!”。第二条命令的名字为”arg”,是一个带参数命令,输出每个参数的值。下面对这两个命令进行测试。

    8.1无参数命令测试

           设置好SecureCRT软件,输入字符”hello”后,按下回车键,设备会返回字符串”Hello world!”。如图8-1所示。


    图8-1:无参数命令测试

    8.2带参数命令测试

           设置好SecureCRT软件,输入字符”arg 1 2 -3 0x0a”后,按下回车键,设备会返回每个参数值。如图8-2所示。


    图8-2:带参数命令测试

    展开全文
  • 利用 C# 实现任务通知窗口

    千次阅读 2008-05-05 19:20:00
    想必大部分网友都使用过QQ、MSN等聊天程序,它们的界面都相当华丽,尤其是当网友上线以及消息提示时会有一个浮动的窗体从屏幕的右下方缓慢升起,既美观... 简介 QQ和MSN的任务通知窗口很人性化,它可以在不丢失主窗

      想必大部分网友都使用过QQ、MSN等聊天程序,它们的界面都相当华丽,尤其是当网友上线以及消息提示时会有一个浮动的窗体从屏幕的右下方缓慢升起,既美观又人性化,作为程序员在享受的同时我们也不禁要问:这到底是怎么实现的呢?本文就利用Visual Studio .Net C# 2005以及。Net框架绘图技术来实现这种任务栏通知窗口。

      简介

      QQ和MSN的任务栏通知窗口很人性化,它可以在不丢失主窗体焦点的前提下显示一个具备皮肤Skin的通知窗体,当它显示一段时间后会自动消失,所以用户根本不用干预它。这样的通知窗体和一般的具备标题栏、系统图标和按钮的窗体没有太大的区别,窗体表面其实就是画上去的一张位图而已,而窗体的浮动则会复杂一点,我们会用到。Net框架的双重缓冲区绘图技术(参见作者编译文章“Windows 窗体的。Net框架绘图技术”)来保证移动窗体时所显示的内容平滑且不闪烁,以及使用P/Invoke平台调用进行对Win32API函数的调用来完成不获得焦点的窗体显示和非标题栏窗体拖动。两种位图的皮肤运行时的界面如下:

     
      

      背景知识

      通知窗口就是将一般的窗体附加上一层皮肤,这里所谓的皮肤就是一张位图图片,该位图图片通过窗体的OnPaintbackground事件被绘制到窗体表面,在附加位图之前需要调整窗体的可视属性,由于绘制操作是针对于窗体客户区域的,所谓客户区域就是指窗体标题栏下方以及窗体边框以内的所有区域,所以需要将窗体的边框和外观属性 FormBorderStyle调整为:None,这样所绘制的图像就会填充整个窗体。

      首先,我们会用到Region对象,Region对象可以精确的描绘出任意形状的轮廓范围,通过一个位图图像创建Region对象后再将其传递给窗体的Region属性就可以使窗体按照Region所定义的轮廓显示出来。作为皮肤使用的位图文件可以通过任何图像编辑软件诸如:Photeshop 来创建和编辑,只是注意一点,需要将图片的背景色调成特定颜色以便程序绘制时将其清除,我们在这里使用的背景色为粉红色。为了能够让Region对象按照图像中感兴趣的内容边框来创建窗体,我们还需要使用GraphicsPath类将图像轮廓按照一定路径标注下来,稍后便按照该路径创建Region对象。然后通过窗体的绘图事件将位图的内容显示在窗体表面,我们没有直接使用OnPaintbackground事件而是重载了该方法,这样做的好处就是一些低层的绘制操作还继续交由。Net框架运行时来处理,我们只考虑实际需要的绘制操作即可。在OnPaintbackground方法中我们启用了双重缓冲区绘图技术,所谓该技术就是指先在内存中的一块画布上把将要显示的图像显示出来或进行处理,等到操作完成再将该画布上所显示的图像放置到窗体表面,这样的机制可以非常有效的降低闪烁的出现,使图像显示更加平滑。通知窗体从屏幕的右下方进行升起停留一段时间后再慢慢回落,这里需要用到返回屏幕区域的大小范围的。Net框架方法 Screen.GetWorkingArea(WorkAreaRectangle),通过一定算法计算出通知窗体显示前的初始位置。最后,我们将要显示的文本按照一定格式和Rectangle对象所指定的区域范围绘制到窗体表面。通知窗体的关闭操作是通过设定一个区域,当用户用鼠标单击时检测单击坐标是否在该区域内,若在区域内就可以执行隐藏通知窗体的代码。

      我们注意了,当QQ和MSN的通知窗口显示时其主窗体的焦点没有丢失,也就是说程序没有将自身的焦点转移到显示的通知窗体上。经过测试,我们无论怎么样调用。Net框架提供的窗体显示例程譬如:Form.Show都无法保证主窗体的焦点不丢失,在VC环境下我们可以使用Win32API的 ShowWindows函数来完成复杂的窗体显示操作,但是。Net框架根本没有提供类似的方法,那么我们能否通过。Net框架调用该API函数来显示窗体呢?幸好。Net框架提供了P/Invoke平台调用,利用平台调用这种服务,托管代码就可以调用在动态链接库中实现的非托管函数,并可以封送其参数,我们可以轻松的显示但不获得焦点的窗体。程序中用到的Windows API以及常量的定义都保存在WinUser.h头文件中,其对应的动态链接库文件就是user32.dll,使用。Net框架提供的 DllImportAttribute类对导入的函数进行定义,然后就可以非常方便的在程序中调用该函数了。

      由于我们将通知窗体的标题栏隐藏了,所以对窗体拖动操作还需要我们自己动手进行处理。本文介绍了如何更加高效的进行拖动窗体操作,有些网友在对于非标题栏拖动窗体编程时偏向组合使用鼠标事件来进行,这样做的本质没有任何不妥,但是频繁的事件响应和处理反而使程序性能有所降低。我们将继续使用 Win32API的底层处理方法来解决该问题,就是向窗体发送标题栏被单击的消息,模拟实际的拖动操作。  我们会通过2个计时器来完成窗体的显示、停留和隐藏,通过设置速度变量可以改变窗口显示和隐藏的速度。

      程序实现

      启动Visual Studio .Net 2005,创建C# Windows 窗体应用程序,将解决方案命名为TaskbarForm,包含的项目名也为TaskbarForm,首先创建程序的主窗体Form1,在上面添加两个 Button控件,一个用于显示通知窗体,另一个则终止程序。然后在解决方案管理器中右击项目,单击“添加 – Windows 窗体”,我们把新创建的窗体命名为TaskbarForm.

      在类TaskbarForm定义的下方,我们创建用于显示的字符串和其颜色的变量,再定义几个Rectangle对象的变量用于放置标题、提示内容以及可以拖动窗体的区域和关闭按钮的区域。然后,我们需要保存窗体在浮动时的高度以便计算移动后的新高度,intervalValue变量用来确定窗体显示和隐藏的速度。进行平台调用时我们需要提前定义好常量的值用来传递给函数,WM_NCLBUTTONDOWN和HT_CAPTION常量用于拖动窗体,他们的值都保存在WinUser.h头文件中,所对应的动态链接库名为:user32.dll.我们用到的Win32API为: SendMessage、ReleaseCapture和ShowWindow,通过使用DllImportAttribute可以导入相应的函数并在程序中重新进行定义,如下:

    [DllImportAttribute("user32.dll")]
      
    public static extern int SendMessage(IntPtr hWnd, int Msg,
                                 
    int wParam, int lParam);
      
    //发送消息//winuser.h 中有函数原型定义
      [DllImportAttribute("user32.dll")]
      
    public static extern bool ReleaseCapture(); //释放鼠标捕捉winuser.h
      [DllImportAttribute("user32.dll")] //winuser.h
      private static extern Boolean ShowWindow(IntPtr hWnd, Int32 nCmdShow);

      SendMessage向消息循环发送标题栏被按下的消息来模拟窗体的拖动,ShowWindow用来将特定句柄的窗体显示出来,注意第二个参数nCmdShow,它表示窗体应该怎样显示出来,而我们需要窗体不获得焦点显示出来,SW_SHOWNOACTIVATE可以满足我们要求,继续在WinUser.h文件中搜索找到该常量对应的值为4,于是我们就可以这样调用来显示窗体了:

      ShowWindow(this.Handle, 4);我们创建了一个自定义函数ShowForm用来封装上面的ShowWindow用来是显示窗体,同时传递了所用到的几个Rectangle矩形区域对象,最后调用ShowWindows函数将窗体显示出来,代码片段如下:

     public void ShowForm(string ftitletext, string fcontenttext,
        Rectangle fRegionofFormTitle, Rectangle fRegionofFormTitlebar,
        Rectangle fRegionofFormContent, Rectangle fRegionofCloseBtn)
       {
       titleText 
    = ftitletext;
       contentText 
    = fcontenttext;
       WorkAreaRectangle 
    = Screen.GetWorkingArea(WorkAreaRectangle);
       
    this.Top = WorkAreaRectangle.Height + this.Height;
       FormBorderStyle 
    = FormBorderStyle.None;
       WindowState 
    = FormWindowState.Normal;
       
    this.SetBounds(WorkAreaRectangle.Width - this.Width,
       WorkAreaRectangle.Height 
    - currentTop, this.Width, this.Height);
       CurrentState 
    = 1;
       timer1.Enabled 
    = true;
       TitleRectangle 
    = fRegionofFormTitle;
       TitlebarRectangle 
    = fRegionofFormTitlebar;
       ContentRectangle 
    = fRegionofFormContent;
       CloseBtnRectangle 
    = fRegionofCloseBtn;
      
       ShowWindow(
    this.Handle, 4); //#define SW_SHOWNOACTIVATE 4
      }


      CurrentState变量表示窗体的状态是显示中、停留中还是隐藏中,两个计时器根据窗体不同状态对窗体的位置进行更改,我们会使用SetBounds来执行该操作:

      this.SetBounds(WorkAreaRectangle.Width - this.Width, WorkAreaRectangle.Height - currentTop, this.Width, this.Height);

      当窗体需要升起时将窗体的Top属性值不断减少,而窗体回落时将Top属性值增加并超过屏幕的高度窗体就消失了,虽然原理很简单但仍需精确控制。

      SetBackgroundBitmap函数首先将窗体背景图像保存到BackgroundBitmap变量中,然后根据该位图图像轮廓和透明色创建Region,BitmapToRegion就用于完成Bitmap到Region的转换,程序再将这个Region付值给窗体的Region属性以完成不规则窗体的创建。

    public void SetBackgroundBitmap(Image image, Color transparencyColor)
       {
       BackgroundBitmap 
    = new Bitmap(image);
       Width 
    = BackgroundBitmap.Width;
       Height 
    = BackgroundBitmap.Height;
       Region 
    = BitmapToRegion(BackgroundBitmap, transparencyColor);
       }
      
       
    public Region BitmapToRegion(Bitmap bitmap, Color transparencyColor)
       {
       
    if (bitmap == null)
       
    throw new ArgumentNullException("Bitmap""Bitmap cannot be null!");
      
       
    int height = bitmap.Height;
       
    int width = bitmap.Width;
       GraphicsPath path 
    = new GraphicsPath();
       
    for (int j = 0; j < height; j++)
       
    for (int i = 0; i < width; i++)
       {
       
    if (bitmap.GetPixel(i, j) == transparencyColor)
       
    continue;
       
    int x0 = i;
       
    while ((i < width) && (bitmap.GetPixel(i, j) != transparencyColor))
       i
    ++;
       path.AddRectangle(
    new Rectangle(x0, j, i - x0, 1));
       }
       Region region 
    = new Region(path);
       path.Dispose();
       
    return region;
      }

      通知窗体背景以及文字的绘制在重载的OnPaintBackground方法中完成,而且利用了双重缓冲区技术来进行绘制操作,代码如下:

    protected override void OnPaintBackground(PaintEventArgs e)
       {
       Graphics grfx 
    = e.Graphics;
       grfx.PageUnit 
    = GraphicsUnit.Pixel;
       Graphics offScreenGraphics;
       Bitmap offscreenBitmap;
       offscreenBitmap 
    = new Bitmap(BackgroundBitmap.Width,
                           BackgroundBitmap.Height);
       offScreenGraphics 
    = Graphics.FromImage(offscreenBitmap);
       
    if (BackgroundBitmap != null)
       {
       offScreenGraphics.DrawImage(BackgroundBitmap, 
    00,
       BackgroundBitmap.Width,
       BackgroundBitmap.Height);
       }
       DrawText(offScreenGraphics);
       grfx.DrawImage(offscreenBitmap, 
    00);
       } 

      上述代码首先返回窗体绘制表面的Graphics并保存在变量grfx中,然后创建一个内存Graphics对象 offScreenGraphics和内存位图对象offscreenBitmap,将内存位图对象的引用付值给offScreenGraphics,这样所有对offScreenGraphics的绘制操作也都同时作用于offscreenBitmap,这时就将需要绘制到通知窗体表面的背景图像 BackgroundBitmap绘制到内存的Graphics对象上,DrawText函数根据需要显示文字的大小和范围调用 Graphics.DrawString将文字显示在窗体的特定区域。最后,调用Graphics.DrawImage将内存中已经绘制完成的图像显示到通知窗体表面。

      我们还需要捕获窗体的鼠标操作,有三个操作在这里进行,1、处理拖动窗体操作,2、处理通知窗体的关闭操作,3、内容区域的单击操作。三个操作都需要检测鼠标的当前位置与每个Rectangle区域的包含关系,只要单击落在特定区域我们就进行相应的处理,代码如下:

     private void TaskbarForm_MouseDown(object sender, MouseEventArgs e)
       {
       
    if (e.Button == MouseButtons.Left)
       {
       
    if (TitlebarRectangle.Contains(e.Location)) //单击标题栏时拖动
       {
       ReleaseCapture(); 
    //释放鼠标捕捉
       SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0);
       
    //发送左键点击的消息至该窗体(标题栏)
       }
       
    if (CloseBtnRectangle.Contains(e.Location)) //单击Close按钮关闭
       {
       
    this.Hide();
       currentTop 
    = 1;
       }
       
    if (ContentRectangle.Contains(e.Location )) //单击内容区域
       {
       System.Diagnostics.Process.Start(
    "http://www.Rithia.com");
       }
       }
      } 

      结论

      该程序可以很好的进行通知窗体的显示、停留和隐藏操作,并且具备简单的换肤机制,在利用了双重缓冲区绘图技术后,可以保证窗体的绘制平滑且没有闪烁。
    展开全文
  • java定时任务框架Quartz(简单调用)

    千次阅读 2019-04-16 00:06:24
    Quartz是一个强大任务调度框架,应用场景例如 餐厅系统会在每周四晚上的22点自动审核并生成报表 人事系统会在每天早晨8点给有待办的人员自动发送Email提醒 一、简单使用(重复执行) 1.引入quartz框架pom依赖 &...

    Quartz是一个强大任务调度框架,应用场景例如

    • 餐厅系统会在每周四晚上的22点自动审核并生成报表
    • 人事系统会在每天早晨8点给有待办的人员自动发送Email提醒

    一、简单使用(重复执行)

    1.引入quartz框架pom依赖

    <dependency>
    	<groupId>org.quartz-scheduler</groupId>
    	<artifactId>quartz</artifactId>
    	<version>2.3.0</version>
    </dependency>

    2.创建HelloJob实现Job接口

    public class HelloJob implements Job{
    	private static final SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		Date now = new Date();
    		String currentTime = sdf.format(now);
    		System.out.println("执行时间为:"+currentTime);
    	}
    }
    

    3.创建HelloScheduler触发任务

    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		//创建jobDetail绑定HelloJob
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
    						.withIdentity("myJob","myGroup").build();
    		//创建触发器trigger每个2秒执行一次,一直执行
    		Trigger trigger = TriggerBuilder.newTrigger().withIdentity("mtTrigger", "myGroup").startNow()
    						.withSchedule(SimpleScheduleBuilder.simpleSchedule()
    						.withIntervalInSeconds(2).repeatForever()).build();
    		//创建调度者工厂
    		SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    		//创建调度者
    		Scheduler scheduler = schedulerFactory.getScheduler();
    		//启动调度器
    		scheduler.start();
    		//设置调度任务
    		scheduler.scheduleJob(jobDetail, trigger);
    	}
    }

    执行结果:

    执行时间为:2019-04-15 23:45:41
    23:45:43.388 [DefaultQuartzScheduler_QuartzSchedulerThread] DEBUG org.quartz.simpl.PropertySettingJobFactory - Producing instance of Job 'myGroup.myJob', class=com.xuxu.quartz.HelloJob
    23:45:43.388 [DefaultQuartzScheduler_Worker-9] DEBUG org.quartz.core.JobRunShell - Calling execute on job myGroup.myJob
    23:45:43.388 [DefaultQuartzScheduler_QuartzSchedulerThread] DEBUG org.quartz.core.QuartzSchedulerThread - batch acquisition of 1 triggers
    执行时间为:2019-04-15 23:45:43
    23:45:45.387 [DefaultQuartzScheduler_QuartzSchedulerThread] DEBUG org.quartz.simpl.PropertySettingJobFactory - Producing instance of Job 'myGroup.myJob', class=com.xuxu.quartz.HelloJob
    23:45:45.387 [DefaultQuartzScheduler_QuartzSchedulerThread] DEBUG org.quartz.core.QuartzSchedulerThread - batch acquisition of 1 triggers
    23:45:45.391 [DefaultQuartzScheduler_Worker-10] DEBUG org.quartz.core.JobRunShell - Calling execute on job myGroup.myJob
    执行时间为:2019-04-15 23:45:45

    二、定时执行使用cron表达式确定时间

    1同上引入pom依赖

    2创建HelloJob实现job接口,任务执行时输出时间

    public class HelloJob implements Job{
    	private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	@Override
    	public void execute(JobExecutionContext arg0) throws JobExecutionException {
    		Date now = new Date();
    		String currentDate = sdf.format(now);
    		System.out.println("现在时间是:"+currentDate+":开始执行任务生成表格,或者发送邮件");
    	}
    }

    3创建触发类CronScheduler

    public class CronScheduler {
    	public static void main(String[] args) throws Exception {
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
    				.withIdentity("myJob").build();
    		Trigger trigger = TriggerBuilder.newTrigger()
    				.withIdentity("cronTrigger")
    				//cron表达式 这里定义的是4月16日早上9点21分开始执行
    				.withSchedule(CronScheduleBuilder.cronSchedule("0 21 9 16 4 ? *"))
    				.build();
    		SchedulerFactory factory = new StdSchedulerFactory();
    		//创建调度器
    		Scheduler scheduler = factory.getScheduler();
    		//启动调度器
    		scheduler.start();
    		//jobDetail和trigger加入调度
    		scheduler.scheduleJob(jobDetail, trigger);
    	}
    }

    这里通过cron表达式确定时间规则

    一般我们会使用cron生成器,地址是http://cron.qqe2.com/

    执行结果如下

    
    现在时间是:2019-04-16 09:21:00:开始执行任务生成表格,或者发送邮件

    Quartz的3大API

    Job

    JobDetail & Job & JobDataMap

    JobDetail是任务的定义,而Job是任务的执行逻辑。在JobDetail里会引用一个Job Class定义。每一个JobDetail都会有一个JobDataMap。JobDataMap本质就是一个Map的扩展类,只是提供了一些更便捷的方法,比如getString()之类的。

    public class CronScheduler {
    	public static void main(String[] args) throws Exception {
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
    				//添加jobname,jobgroup
    				.withIdentity("myJob","myGroup")
    				//jobDataMap信息
    				.usingJobData("message","this is a message")
    				.build();
    		Trigger trigger = TriggerBuilder.newTrigger()
    				.withIdentity("cronTrigger")
    				//cron表达式 这里定义的是4月16日早上9点21分开始执行
    				.withSchedule(CronScheduleBuilder.cronSchedule("0 00 10 16 4 ? *"))
    				.build();
    		SchedulerFactory factory = new StdSchedulerFactory();
    		//创建调度器
    		Scheduler scheduler = factory.getScheduler();
    		//启动调度器
    		scheduler.start();
    		//jobDetail和trigger加入调度
    		scheduler.scheduleJob(jobDetail, trigger);
    	}
    }
    public class HelloJob implements Job{
    	private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	@Override
    	public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
    		Date now = new Date();
    		String currentDate = sdf.format(now);
    		JobDetail jobDetail = jobExecutionContext.getJobDetail();
    		JobDataMap jobDataMap = jobDetail.getJobDataMap();
    		JobKey jobKey = jobDetail.getKey();
    		String jobName = jobKey.getName();
    		String group = jobKey.getGroup();
    		String message = (String) jobDataMap.get("message");
    		System.out.println("现在时间是:"+currentDate+":开始执行任务生成表格,或者发送邮件");
    		System.out.println("jobName---"+jobName);
    		System.out.println("group---"+group);
    		System.out.println("message---"+message);
    	}
    }
    现在时间是:2019-04-16 10:00:00:开始执行任务生成表格,或者发送邮件
    jobName---myJob
    group---myGroup
    message---this is a message

    Tigger

    1.startTime和endTime

    有时候我们希望一个定时任务在一定的时间内是每天执行,比如2017年11月24日到2017年12月15日之间执行,这时候我们就要使用startTime和endTime来限定事件范围了。例子中我们把时间规定在几秒钟之内运行,方便查看效果。

    public class HelloJob implements Job{
    	private static final SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		Date now = new Date();
    		String currentTime = sdf.format(now);
    		System.out.println("执行时间为:"+currentTime);
    	}
    }
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		//创建jobDetail绑定HelloJob
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
    						.withIdentity("myJob","myGroup").build();
    		//设定开始时间,结束时间确定范围
    		Date triggerStartTime = new Date();
    		//3秒后开始执行
    		triggerStartTime.setTime(triggerStartTime.getTime()+3000);
    		Date triggerEndTime = new Date();
    		//10秒后结束执行
    		triggerEndTime.setTime(triggerEndTime.getTime()+10000);
    		//创建触发器trigger每个2秒执行一次,一直执行
    		Trigger trigger = TriggerBuilder.newTrigger().withIdentity("mtTrigger", "myGroup")
    						.startAt(triggerStartTime)
    						.endAt(triggerEndTime)
    						.withSchedule(SimpleScheduleBuilder.simpleSchedule()
    						.withIntervalInSeconds(2).repeatForever()).build();
    		//创建调度者工厂
    		SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    		//创建调度者
    		Scheduler scheduler = schedulerFactory.getScheduler();
    		//启动调度器
    		scheduler.start();
    		//设置调度任务
    		scheduler.scheduleJob(jobDetail, trigger);
    	}
    }

    3秒后执行,10秒内结束执行

    如下

    执行时间为:2019-04-16 10:36:09
    执行时间为:2019-04-16 10:36:11
    执行时间为:2019-04-16 10:36:13
    执行时间为:2019-04-16 10:36:15

    2.BaseCalndar

    此calendar不是java.util.Calendar,calendar是为了补充Trigger的时间,可以排除或加入一下特定的时间。Quartz 的 Calender 专门用于屏闭一个时间区间,使 Trigger 在这个区间中不被触发。

    1. AnnualCalendar:排除每一年中指定的一天或者多少天 ,精度是天
    2. CronCalendar:使用表达式排除某些时间段不执行,精度取决于Cron表达式,最大精度到秒
    3. DailyCalendar:指定的时间范围内的每一天不执行,指定每天的时间段,格式是HH:MM[:SS[:mmm]]。也就是最大精度可以到毫秒。
    4. HolidayCalendar:排除节假日,精度到天
    5. MonthlyCalendar:排除月份中的数天,可选值为1-31。精度是天
    6. WeeklyCalendar:排除星期中的一天或多天,可选值比如为java.util.Calendar.SUNDAY,精度是天。

    这里使用CronCalendar排除

    public class HelloJob implements Job{
    	private static final SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		Date now = new Date();
    		String currentTime = sdf.format(now);
    		System.out.println("执行时间为:"+currentTime);
    	}
    }
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException, ParseException {
    		//创建jobDetail绑定HelloJob
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
    						.withIdentity("myJob","myGroup").build();
    		//创建触发器trigger每个2秒执行一次,一直执行
    		Trigger trigger = TriggerBuilder.newTrigger().withIdentity("mtTrigger", "myGroup")
    				.withSchedule(SimpleScheduleBuilder.simpleSchedule()
    						.withIntervalInSeconds(2).repeatForever())
    				//将calendar排除规则绑定到触发器
    				.modifiedByCalendar("myCalendar")
    				.build();
    		//创建调度者工厂
    		SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    		//创建调度者
    		Scheduler scheduler = schedulerFactory.getScheduler();
    		CronCalendar calendar = new CronCalendar("* * 0-12,18-23 ? * *");
    		//向Scheduler注册日历
    		scheduler.addCalendar("myCalendar", calendar, false, false);
    		//启动调度器
    		scheduler.start();
    		//设置调度任务
    		scheduler.scheduleJob(jobDetail, trigger);
    	}
    }
    11:39:12.270 [DefaultQuartzScheduler_QuartzSchedulerThread] DEBUG org.quartz.core.QuartzSchedulerThread - batch acquisition of 0 triggers
    11:39:12.381 [DefaultQuartzScheduler_QuartzSchedulerThread] DEBUG org.quartz.core.QuartzSchedulerThread - batch acquisition of 0 triggers
    

    上面指定的是0-12 18-23不执行发现12点之前没有执行

     

    Trigger的实现类

    1CalendarIntervalTrigger是一个具体的Trigger,用来触发基于定时重复的JobDetail。

    Trigger将会每隔N个calendar在trigger中定义的时间单元触发一次。这个trigger不适合使用SimpleTrigger完成(例如由于每一个月的时间不是固定的描述),也不适用于CronTrigger(例如每5个月)。

    相较于SimpleTrigger有两个优势:1、更方便,比如每隔1小时执行,你不用自己去计算1小时等于多少毫秒。 2、支持不是固定长度的间隔,比如间隔为月和年。但劣势是精度只能到秒。

    它适合的任务类似于:9:00 开始执行,并且以后每周 9:00 执行一次

    它的属性有:

    • interval 执行间隔
    • intervalUnit 执行间隔的单位(秒,分钟,小时,天,月,年,星期)
    CalendarIntervalScheduleBuilder
         .calendarIntervalSchedule()
         .withIntervalInDays(1)  //每天执行一次
       //.withIntervalInHours(1)
       //.withIntervalInMinutes(1)
       //.withIntervalInMonths(1)
       //.withIntervalInSeconds(1)
       //.withIntervalInWeeks(1)
       //.withIntervalInHours(1)
         .build()

    2DailyTimeIntervalTrigger

    指定每天的某个时间段内,以一定的时间间隔执行任务。并且它可以支持指定星期。

    它适合的任务类似于:指定每天9:00 至 18:00 ,每隔70秒执行一次,并且只要周一至周五执行。

    它的属性有:

    • startTimeOfDay 每天开始时间
    • endTimeOfDay 每天结束时间
    • daysOfWeek 需要执行的星期
    • interval 执行间隔
    • intervalUnit 执行间隔的单位(秒,分钟,小时,天,月,年,星期)
    • repeatCount 重复次数
    public static void main(String[] args) throws SchedulerException {
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //1.创建一个jobDetail的实例,将该实例与HelloJob Class绑定
            JobDetail jobDetail = JobBuilder
                    .newJob(HelloJob.class)
                    .withIdentity("myJob", "group1") //定义name 和 group
                    .build();
    
            //2.创建一个Trigger触发器的实例
            Trigger simpleTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("zhlTrigger")
                    .withSchedule(
                            DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule()
                                    .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(8, 0)) //每天8:00开始
                                    .endingDailyAt(TimeOfDay.hourAndMinuteOfDay(17, 0)) //17:00 结束
                                    .onDaysOfTheWeek(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY) //周一至周五执行
                                    .withIntervalInHours(1) //每间隔1小时执行一次
                                    .withRepeatCount(100) //最多重复100次(实际执行100+1次)
                    )
                    .modifiedByCalendar("holidays")   //将我们设置好的Calander与trigger绑定
                    .build();
    
            //3.创建schedule实例
            StdSchedulerFactory factory = new StdSchedulerFactory();
            Scheduler scheduler = factory.getScheduler();
            System.out.println("现在的时间 :"+sf.format(new Date()));
            System.out.println();
            System.out.println("最近的一次执行时间 :"+sf.format(scheduler.scheduleJob(jobDetail,simpleTrigger))); //scheduler与jobDetail、trigger绑定,并打印出最近一次执行的事件
            scheduler.start();
        }

     

    Scheduler——工厂模式:

    所有的Scheduler实例应该由SchedulerFactory来创建,一般包含:StdSchedulerFactory、DirectSchedulerFactory(参数信息需要在代码中维护故不常用)。

    StdSchedulerFactory使用一组参数来创建和初始化Quartz调度器,配置参数一般存储在quartz.properties文件中,调用getScheduler方法就能创建和初始化调度器对象。

    Scheduler的主要函数:

    Data scheduleJob(JobDetail jobDetail,Trigger trigger);

    void start();——启动Scheduler;

    void standby();——将Scheduler暂时挂起,可以用start()继续执行任务;

    void shutDown()关闭Scheduler且不能被重启;示例代码如下:

     

     

    展开全文
  • 我们在之前有讲过SpringBoot是已经集成了定时任务的,详见:第二十六章:SpringBoot使用@Scheduled创建定时任务,那么我们本章将会采用外置的quartz定时任务框架来完成定时任务的分布式节点持久化,我们为什么要...
  • 利用数据库存储订单、通知任务,构建高性能队列原文地址:http://www.codeproject.com/Articles/110931/Building-High-Performance-Queue-in-Database-for-st作者:chszs,转载需注明。博客主页:...
  • 定时任务简单的3种实现方法(超好用)

    万次阅读 多人点赞 2020-08-18 07:00:00
    这是我的第86篇原创文章作者 | 王磊来源 | Java中文社群(ID:javacn666)转载请联系授权(微信ID:GG_Stone)定时任务在实际的开发中特别常见,比如电商平台 ...
  • 分布式定时任务—xxl-job学习(一):简单demo搭建

    千次阅读 多人点赞 2020-06-19 14:57:13
    分布式定时任务—xxl-job学习(一):简单demo搭建一、xxl-job简介1.1 xxl-job特性介绍1.2 官方仓库+文档地址二、简单搭建一个xxljob_demo2.1 搭建调度中心2.1.1 初始化“调度数据库”2.1.2 配置部署“调度中心”xxl-...
  • Windows操作系统任务栏右下角的通知区域主要用来放置系统的通知图标,并对鼠标输入进行响应。同时,用户程序也可以通过系统外壳函数进行操作,放置自己的图标,并根据鼠标操作进行响应。那么,怎样进行此区域的编程...
  • 使用Quartz实现定时任务(包含管理界面)

    万次阅读 多人点赞 2019-01-01 18:43:34
    ")来实现的,至于监控方面的,没有,就是通过在定时任务代码里面打一些日志,特别重要的定时任务,失败了额外发个邮件通知下,人工补偿。然后他又问了下现在需要重构定时任务,你有没有什么想法?然后我就简单的...
  • Quartz,水晶、石英,一个简单朴素有美丽的名字,在Java程序界,Quartz大名鼎鼎,很多Java应用几乎都集成或构建了一个定时任务调度系统,Quartz是一个定时任务调度框架。 何为定时任务调度框架?简而言之,它可以...
  • 最近在做一个线程多任务的断点排队下载的功能,网上确实有很多这样的demo。但是呢我发现大部分网上的demo都是很些不完整的要么就是有缺陷的,可能是我还没找到。今天我给大家带来的一个功能完整的并且可以多界面...
  • 简单线程队列 -- 工作的时候遇到劣质打印机。给打印机发消息,打印机就会打印,如果在打印机还在打印的时候,就 再发消息打印,就会出现消息丢失。所以需要给上一个任务一些处理的间隔时间. 线程的消息队列...
  • 1 MapReduce任务的基础知识 这一章,整体的介绍MapReduce任务。读完这章,你能编写和执行单机模式的MapReduce任务程序。 这章中的样例程序假设你已经完成了第一章的设置。你可以在一个专用的本地模式配置下,使用一...
  • Android基础入门教程——3.7 AnsyncTask异步任务

    万次阅读 多人点赞 2015-07-24 09:14:26
    Android基础入门教程——3.7 AnsyncTask异步任务 本节引言: 1.相关概念 1)什么是多线程: 2)同步与异步的概念: 3) Android为很么要引入异步任务 2.AsyncTask全解析: 1)为什么要用AsyncTask? 2)AsyncTask的...
  • 定时任务调度

    千次阅读 2017-06-02 18:00:26
    cron4j特点:最大的特点就是小巧,简单,功能说实话没什么可说的,就是模仿unix的crontab,门槛非常低,编程非常简单. 可以执行一些简单的定时调度功能,太复杂的还是用quartz比较好。定时任务:public class CronJob ...
  • 多种方式实现Android定时任务,哪一款是你的FEEL?

    万次阅读 热门讨论 2016-11-25 18:08:18
    Android实现定时任务
  • 最近的项目里面涉及到一些Java设计模式,在此简单谈一下自己的看法,以下实例一部分参考同行,大部分自己设计。1.单例模式 如果一个类始终只能创建一个实例,则这个类成为单例类,这种设计模式称为单例模式。class...
  • 分布式任务调度框架技术调研

    千次阅读 2017-08-25 15:23:23
    研究的目的定时任务问题一直是我们组项目的主要问题来源,很多问题的最终定位是由于定时任务异常停止导致的,例如:六马的...可监控定时任务出现故障的时候可以第一时间得到通知;(监控系统) 试用分布式定时任务,解
  • 分布式任务调度

    万次阅读 2018-10-01 22:31:50
    什么是定时任务? 指定时间去执行任务 Java实现定时任务方式 1.Thread public class Demo01 { static long count = 0; public static void main(String[] args) { Runnable runnable = new Runnable() { ...
  • 利用Azkaban来完成大数据的任务调度

    千次阅读 2018-01-03 15:05:01
    任务完成或失败通知管理员 这样,我们就可以利用azkaban来进行任务调度,主要应用场景就是离线计算了。 在上面,我们已经知道了,大数据离线计算相关内容是存在一种依赖关系的,最简单的例子是先要ETL,然后...
  • Android的多任务之路

    千次阅读 2011-08-24 20:01:30
    但同时,移动设备的内存使用却很有限,以至于系统会降低性能或者当它需要比可用更多的RAM时,很快就启动失败,而台式电脑,可以交换(指空间),相比起来就很简单的启动(运行)缓慢,来用页面RAM交换空间。...
  • Quartz可以用来创建简单或复杂的日程安排执行几十,几百,甚至是十万的作业数 - 作业被定义为标准的Java组件,可以执行几乎任何东西,可以编程让它们执行。 Quartz调度包括许多企业级功能,如JTA事务...
  • redis 延时任务 看一篇成高手系列2

    千次阅读 2018-05-31 09:15:24
    引言在开发中,往往会遇到一些关于延时...一共有如下几点区别定时任务有明确的触发时间,延时任务没有定时任务有执行周期,而延时任务在某事件触发后一段时间内执行,没有执行周期定时任务一般执行的是批处理操作...
  •  首先,先简单的介绍一下什么叫多任务系统?任务、进程、线程分别是什么?它们之间的区别是什么?,从而可以宏观的了解一下这三者,然后再针对每一个仔细的讲解。  什么叫多任务系统?多任务系统指可以同一时间内...
  • 浏览器的多线程与js引擎的线程

    千次阅读 2018-04-10 14:53:43
    我们这里将进程比喻为工厂的车间,它代表CPU所能处理的单个任务。任一时刻,CPU总是运行一个进程,其他进程处于非运行状态。 线程 在早期的操作系统中并没有线程的概念,进程是能拥有资源和独立运
  • Windows7的超级任务栏比起常规的windows任务栏主要做了下列改进 1、任务栏中的任务图标化,连开始菜单的按钮都显得跟任务栏中的图标差不多样式; 2、任务栏放弃了实时运行的概念,任务栏中开始变得像桌面,你可以把...
  • 多线程之Task(任务

    万次阅读 多人点赞 2018-11-12 15:44:30
    任务和线程的区别: 1、任务是架构在线程之上的,也就是说任务最终还是要抛给线程去执行。 2、任务跟线程不是一对一的关系,比如开10个任务并不是说会开10个线程,这一点任务有点类似线程池,但是任务相比线程池...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,069
精华内容 66,027
关键字:

任务通知单简单格式