Cocos2d-x 3.2：定时器的使用和原理探究（2）
本文转载至深入了解Cocos2d-x 3.x：定时器的使用和原理探究（2）
上一篇说到定时器的使用方法，这篇主要分析它的实现原理。
1.哈希链表
Cocos2d-x封装了一个结构体，叫做UT_hash_handle，只要在自定义的结构体中声明这个结构体变量，就实现了哈希链表，并且能使用一系列的哈希链表专用的宏。这个结构体的具体实现如下：
|
1
2
3
4
5
6
7
8
9
10
|
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 结构体：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
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;
|
然后看看与哈希链表相关的宏定义，使用这些宏能很方便的插入链表，删除链表，查找链表。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
/**
* 查找元素
* 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)
|
以上是引擎中实现的哈希链表的相关知识，接下来再看看与定时器相关的哈希链表。定时器的实现中，将一个定时器存储在哈希链表中，那么在scheduler是如何实现以后哈希链表的结构体的呢？如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
// 不同优先级的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.如何定义自定义定时器
首先，上一篇文章中说到了很多个自定义定时器的函数，但是最终会调用的函数只有两个，分别是
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/**
* 定义一个自定义的定时器
* 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);
|
本文从传统的定义定时器的方法入手，也就是第一个方法。接下来看看这个方法的实现：
|
1
2
3
4
5
6
7
|
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又是个什么鬼？
|
1
|
Scheduler *_scheduler;
///< scheduler used to schedule timers and updates
|
查看定义可以知道是一个Scheduler 的指针，但是这个指针从哪里来？在构造函数中有真相
|
1
2
3
4
5
6
7
|
Node::Node(
void
)
{
// set default scheduler and actionManager
_director = Director::getInstance();
_scheduler = _director->getScheduler();
_scheduler->retain();
}
|
是从导演类中引用的。这一块暂时我们不管，接下来深入到_scheduler->schedule函数中分析，如下是函数的具体实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
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定时器的开启方法有两个，分别是：
|
1
2
3
4
5
6
7
8
9
|
/**
* 开启自带的update方法，这个方法会每帧执行一次，默认优先级为0，并且在所有自定义方法执行之前执行
*/
void
scheduleUpdate(
void
);
/**
* 开启自带的update方法，这个方法会每帧执行一次，设定的优先级越小，越优先执行
*/
void
scheduleUpdateWithPriority(
int
priority);
|
第一个方法实际上是直接调用第二个方法，并且把优先级设置为0，我们直接看第二个方法就可以了。
|
1
2
3
4
|
void
Node::scheduleUpdateWithPriority(
int
priority)
{
_scheduler->scheduleUpdate(
this
, priority, !_running);
}
|
具体调用还是要进入到_scheduler->scheduleUpdate。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/** 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看看它的实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
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);
}
}
|
在这里看上去逻辑还是很清晰的，有两个函数要重点分析一下，分别是
|
1
2
|
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)
|
第一个用于添加默认优先级，第二个函数用于添加指定优先级的。首先看添加默认优先级的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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);
}
|
接下来看另一个函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
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);
}
|
本文简单的分析了哈希链表以及定时器的存储和添加，下一篇文章将分析定时器是如何运转起来的。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
