上篇说到定时器的用法。这篇主要分析它的实现原理。
1.哈希链表
cocos2dx封装了一个结构体，叫做UT_hash_handle。仅仅要在自己定义的结构体中声明这个结构体变量。就实现了哈希链表，而且能使用一系列的哈希链表专用的宏。这个结构体的详细实现例如以下：
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);
}本文简单的分析了哈希链表以及定时器的存储和加入，下一篇文章将分析定时器是怎样运转起来的。