【深入了解cocos2d-x 3.x】定时器(scheduler)的使用和原理探究(2)
上篇说到定时器的用法。这篇主要分析它的实现原理。
1.哈希链表
typedef struct UT_hash_handle { struct UT_hash_table *tbl; void *prev; /* prev element in app order */ void *next; /* next element in app order */ struct UT_hash_handle *hh_prev; /* previous hh in bucket order */ struct UT_hash_handle *hh_next; /* next hh in bucket order */ void *key; /* ptr to enclosing struct's key */ unsigned keylen; /* enclosing struct's key len */ unsigned hashv; /* result of hash-fcn(key) */ } UT_hash_handle;
这个结构体主要实现的是一个双向链表,详细实现哈希验证的还要看UT_hash_table 结构体
typedef struct UT_hash_table { UT_hash_bucket *buckets; unsigned num_buckets, log2_num_buckets; unsigned num_items; struct UT_hash_handle *tail; /* tail hh in app order, for fast append */ ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */ /* in an ideal situation (all buckets used equally), no bucket would have * more than ceil(#items/#buckets) items. that's the ideal chain length. */ unsigned ideal_chain_maxlen; /* nonideal_items is the number of items in the hash whose chain position * exceeds the ideal chain maxlen. these items pay the penalty for an uneven * hash distribution; reaching them in a chain traversal takes >ideal steps */ unsigned nonideal_items; /* ineffective expands occur when a bucket doubling was performed, but * afterward, more than half the items in the hash had nonideal chain * positions. If this happens on two consecutive expansions we inhibit any * further expansion, as it's not helping; this happens when the hash * function isn't a good fit for the key domain. When expansion is inhibited * the hash will still work, albeit no longer in constant time. */ unsigned ineff_expands, noexpand; uint32_t signature; /* used only to find hash tables in external analysis */ #ifdef HASH_BLOOM uint32_t bloom_sig; /* used only to test bloom exists in external analysis */ uint8_t *bloom_bv; char bloom_nbits; #endif } UT_hash_table;
然后看看与哈希链表相关的宏定义,使用这些宏能非常方便的插入链表。删除链表,查找链表。
/** * 查找元素 * head:哈希链表的头指针 * findptr:要查找的元素指针 * out:查找结果 */ HASH_FIND_PTR(head,findptr,out) /** * 加入元素 * head:哈希链表的头指针 * ptrfield:要加入的元素指针 * add:要加入的哈希链表元素 */ HASH_ADD_PTR(head,ptrfield,add) /** * 替换元素 * head:哈希链表的头指针 * ptrfield:要替换的元素指针 * add:要替换的哈希链表元素 */ HASH_REPLACE_PTR(head,ptrfield,add) /** * 删除 * head:哈希链表的头指针 * delptr:要删除的元素指针 */ HASH_DEL(head,delptr)
// 不同优先级的update定时器的双向链表 typedef struct _listEntry { struct _listEntry *prev, *next; ccSchedulerFunc callback; void *target; int priority; bool paused; bool markedForDeletion; // selector will no longer be called and entry will be removed at end of the next tick } tListEntry; //内置的update定时器 typedef struct _hashUpdateEntry { tListEntry **list; // Which list does it belong to ? tListEntry *entry; // entry in the list void *target; ccSchedulerFunc callback; UT_hash_handle hh; } tHashUpdateEntry; // 自己定义定时器 typedef struct _hashSelectorEntry { ccArray *timers; void *target; int timerIndex; Timer *currentTimer; bool currentTimerSalvaged; bool paused; UT_hash_handle hh; } tHashTimerEntry;
以上就是相关的哈希链表的知识。接下来从定义定时器的函数Node::schedule中一步一步的分析定时器是怎样增加到哈希链表中的。
2.怎样定义自己定义定时器
/** * 定义一个自己定义的定时器 * selector:回调函数 * interval:反复间隔时间。反复运行间隔的时间。假设传入0,则表示每帧调用 * repeat:反复运行次数,假设传入CC_REPEAT_FOREVER则表示无限循环 * delay:延时秒数。延迟delay秒開始运行第一次回调 */ void schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay); /** * 使用lambda函数定义一个自己定义定时器 * callback:lambda函数 * interval:反复间隔时间。反复运行间隔的时间,假设传入0,则表示每帧调用 * repeat:反复运行次数。假设传入CC_REPEAT_FOREVER则表示无限循环 * delay:延时秒数。延迟delay秒開始运行第一次回调 * key:lambda函数的Key,用于取消定时器 * @lua NA */ void schedule(const std::function<void(float)>& callback, float interval, unsigned int repeat, float delay, const std::string &key);
本文从传统的定义定时器的方法入手,也就是第一个方法。
接下来看看这种方法的实现:
void Node::schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay) { CCASSERT( selector, "Argument must be non-nil"); CCASSERT( interval >=0, "Argument must be positive"); _scheduler->schedule(selector, this, interval , repeat, delay, !_running); }
看到事实上还是调用_scheduler的schedule方法。那么_scheduler又是个什么鬼?
Scheduler *_scheduler; ///< scheduler used to schedule timers and updates查看定义能够知道是一个Scheduler 的指针。可是这个指针从哪里来?在构造函数中有真相
Node::Node(void) { // set default scheduler and actionManager _director = Director::getInstance(); _scheduler = _director->getScheduler(); _scheduler->retain(); }
是从导演类中引用的。这一块临时我们无论。接下来深入到_scheduler->schedule函数中分析。例如以下是函数的详细实现
void Scheduler::schedule(SEL_SCHEDULE selector, Ref *target, float interval, unsigned int repeat, float delay, bool paused) { CCASSERT(target, "Argument target must be non-nullptr"); //定义而且查找链表元素 tHashTimerEntry *element = nullptr; HASH_FIND_PTR(_hashForTimers, &target, element); //没找到 if (! element) { //创建一个链表元素 element = (tHashTimerEntry *)calloc(sizeof(*element), 1); element->target = target; //加入到哈希链表中 HASH_ADD_PTR(_hashForTimers, target, element); // Is this the 1st element ?Then set the pause level to all the selectors of this target element->paused = paused; } else { CCASSERT(element->paused == paused, ""); } //检查这个元素的定时器数组,假设数组为空 则new 10个数组出来备用 if (element->timers == nullptr) { element->timers = ccArrayNew(10); } else { //循环查找定时器数组,看看是不是以前定义过同样的定时器。假设定义过,则仅仅须要改动定时器的间隔时间 for (int i = 0; i < element->timers->num; ++i) { TimerTargetSelector *timer = dynamic_cast<TimerTargetSelector*>(element->timers->arr[i]); if (timer && selector == timer->getSelector()) { CCLOG("CCScheduler#scheduleSelector. Selector already scheduled. Updating interval from: %.4f to %.4f", timer->getInterval(), interval); timer->setInterval(interval); return; } } //扩展1个定时器数组 ccArrayEnsureExtraCapacity(element->timers, 1); } //创建一个定时器,而且将定时器加入到当前链表指针的定时器数组中 TimerTargetSelector *timer = new (std::nothrow) TimerTargetSelector(); timer->initWithSelector(this, selector, target, interval, repeat, delay); ccArrayAppendObject(element->timers, timer); timer->release(); }
这一段代码详细分析了怎样将自己定义定时器增加到链表中。而且在链表中的存储结构是怎么样的。接下来看看内置的Update定时器。
3.怎样定义Update定时器
Update定时器的开启方法有两个。各自是:/** * 开启自带的update方法,这种方法会每帧运行一次,默认优先级为0,而且在全部自己定义方法运行之前运行 */ void scheduleUpdate(void); /** * 开启自带的update方法。这种方法会每帧运行一次。设定的优先级越小,越优先运行 */ void scheduleUpdateWithPriority(int priority);第一个方法实际上是直接调用第二个方法。而且把优先级设置为0,我们直接看第二个方法就能够了。
void Node::scheduleUpdateWithPriority(int priority) { _scheduler->scheduleUpdate(this, priority, !_running); }详细调用还是要进入到_scheduler->scheduleUpdate。
/** Schedules the 'update' selector for a given target with a given priority. The 'update' selector will be called every frame. The lower the priority, the earlier it is called. @since v3.0 @lua NA */ template <class T> void scheduleUpdate(T *target, int priority, bool paused) { this->schedulePerFrame([target](float dt){ target->update(dt); }, target, priority, paused); }
能够看到这里主要还是调用了一个schedulePerFrame函数,而且传入了一个lambda函数。这个函数实际上调用的是target->update,接下来走进schedulePerFrame看看它的实现:
void Scheduler::schedulePerFrame(const ccSchedulerFunc& callback, void *target, int priority, bool paused) { //定义而且查找链表元素 tHashUpdateEntry *hashElement = nullptr; HASH_FIND_PTR(_hashForUpdates, &target, hashElement); //假设找到,就直接改优先级 if (hashElement) { // 检查优先级是否改变 if ((*hashElement->list)->priority != priority) { //检查是否被锁定 if (_updateHashLocked) { CCLOG("warning: you CANNOT change update priority in scheduled function"); hashElement->entry->markedForDeletion = false; hashElement->entry->paused = paused; return; } else { // 在这里先停止到update。后面会加回来 unscheduleUpdate(target); } } else { hashElement->entry->markedForDeletion = false; hashElement->entry->paused = paused; return; } } // 优先级为0,增加到_updates0List链表中,而且增加到_hashForUpdates表中 if (priority == 0) { appendIn(&_updates0List, callback, target, paused); } // 优先级小于0,增加到_updatesNegList链表中。而且增加到_hashForUpdates表中 else if (priority < 0) { priorityIn(&_updatesNegList, callback, target, priority, paused); } // 优先级大于0,增加到_updatesPosList链表中,而且增加到_hashForUpdates表中 else { // priority > 0 priorityIn(&_updatesPosList, callback, target, priority, paused); } }在这里看上去逻辑还是非常清晰的,有两个函数要重点分析一下。各自是
void Scheduler::appendIn(_listEntry **list, const ccSchedulerFunc& callback, void *target, bool paused) void Scheduler::priorityIn(tListEntry **list, const ccSchedulerFunc& callback, void *target, int priority, bool paused)
第一个用于加入默认优先级。第二个函数用于加入指定优先级的。首先看加入默认优先级的。
void Scheduler::appendIn(_listEntry **list, const ccSchedulerFunc& callback, void *target, bool paused) { //创建一个链表元素 tListEntry *listElement = new tListEntry(); listElement->callback = callback; listElement->target = target; listElement->paused = paused; listElement->priority = 0; listElement->markedForDeletion = false; //加入到双向链表中 DL_APPEND(*list, listElement); //创建一个哈希链表元素 tHashUpdateEntry *hashElement = (tHashUpdateEntry *)calloc(sizeof(*hashElement), 1); hashElement->target = target; hashElement->list = list; hashElement->entry = listElement; //加入到哈希链表中 HASH_ADD_PTR(_hashForUpdates, target, hashElement); }
接下来看还有一个函数
void Scheduler::priorityIn(tListEntry **list, const ccSchedulerFunc& callback, void *target, int priority, bool paused) { //同上一个函数 tListEntry *listElement = new tListEntry(); listElement->callback = callback; listElement->target = target; listElement->priority = priority; listElement->paused = paused; listElement->next = listElement->prev = nullptr; listElement->markedForDeletion = false; //假设链表为空 if (! *list) { DL_APPEND(*list, listElement); } else { bool added = false; //保证链表有序 for (tListEntry *element = *list; element; element = element->next) { // 假设优先级小于当前元素的优先级,就在这个元素前面插入 if (priority < element->priority) { if (element == *list) { DL_PREPEND(*list, listElement); } else { listElement->next = element; listElement->prev = element->prev; element->prev->next = listElement; element->prev = listElement; } added = true; break; } } //假设新增加的优先级最低,则增加到链表的最后 if (! added) { DL_APPEND(*list, listElement); } } //同上一个函数 tHashUpdateEntry *hashElement = (tHashUpdateEntry *)calloc(sizeof(*hashElement), 1); hashElement->target = target; hashElement->list = list; hashElement->entry = listElement; HASH_ADD_PTR(_hashForUpdates, target, hashElement); }
本文简单的分析了哈希链表以及定时器的存储和加入,下一篇文章将分析定时器是怎样运转起来的。