live555 源码分析：基础设施
live555 由多个模块组成，其中 UsageEnvironment 、 BasicUsageEnvironment 和 groupsock 分别提供了事件循环，输入输出，基本的数据结构，以及网络 IO 等功能，它们可以看作 live555 的基础设施。对于 live555 的源码分析，就从这些基础设施，基本的数据结构开始。
HashTable
首先来看 HashTable，这是 live555 定义的一个范型关联容器。
UsageEnvironment 的 HashTable
UsageEnvironment 中的 HashTable 类定义了接口，该接口定义如下：
class HashTable {
public:virtual ~HashTable();// The following must be implemented by a particular// implementation (subclass):static HashTable* create(int keyType);virtual void* Add(char const* key, void* value) = 0;// Returns the old value if different, otherwise 0virtual Boolean Remove(char const* key) = 0;virtual void* Lookup(char const* key) const = 0;// Returns 0 if not foundvirtual unsigned numEntries() const = 0;Boolean IsEmpty() const { return numEntries() == 0; }// Used to iterate through the members of the table:class Iterator {public:// The following must be implemented by a particular// implementation (subclass):static Iterator* create(HashTable const& hashTable);virtual ~Iterator();virtual void* next(char const*& key) = 0; // returns 0 if noneprotected:Iterator(); // abstract base class};// A shortcut that can be used to successively remove each of// the entries in the table (e.g., so that their values can be// deleted, if they happen to be pointers to allocated memory).void* RemoveNext();// Returns the first entry in the table.// (This is useful for deleting each entry in the table, if the entry's destructor also removes itself from the table.)void* getFirst(); protected:HashTable(); // abstract base class
};// Warning: The following are deliberately the same as in
// Tcl's hash table implementation
int const STRING_HASH_KEYS = 0;
int const ONE_WORD_HASH_KEYS = 1;尽管 HashTable 要定义为范型关联容器，然而它没有使用 C++ 的模板。HashTable 要求键为一个 C 风格的字符串，即 char const*，而值为一个 void*，以此可以表示各种不同类型的值。就像 C++ 标准库中的许多容器一眼，HashTable 内部还定义了一个迭代器类，用来遍历这个容器。
其它添加、移除、查找元素等操作，与其它的普通容器设计并没有太大的不同。
HashTable 类实现了公共的与具体存储结构无关的两个模板函数 RemoveNext() 和 getFirst()，这两个函数分别用于移除容器中的下一个元素并返回元素的值，及得到容器中的第一个元素，它们的实现如下：
#include "HashTable.hh"HashTable::HashTable() {
}HashTable::~HashTable() {
}HashTable::Iterator::Iterator() {
}HashTable::Iterator::~Iterator() {}void* HashTable::RemoveNext() {Iterator* iter = Iterator::create(*this);char const* key;void* removedValue = iter->next(key);if (removedValue != 0) Remove(key);delete iter;return removedValue;
}void* HashTable::getFirst() {Iterator* iter = Iterator::create(*this);char const* key;void* firstValue = iter->next(key);delete iter;return firstValue;
}这两个函数，都借助于容器的迭代器来实现。Iterator 类的 next(char const*& key) 接收一个传出参数，用于将键返回给调用者。
从接口定义的角度来看 live555 定义的 HashTable。它的 Iterator 类对象是由 Iterator 类的静态方法 create(HashTable const& hashTable) 创建的，但销毁创建的对象的职责却是在调用者这里，这大大破坏了 HashTable 接口的实现的灵活性，比如创建的对象因此而无法做缓存。
HashTable 类及其迭代器类 Iterator 各自定义了一个静态方法 create()。这里使用了桥接的方式，HashTable 的这个方法像一座桥一样，把 HashTable 接口与接口的实现联系了起来。这个类静态函数都在实现接口的类中定义。
HashTable 有两种类型，分别用两个整型值来标识，STRING_HASH_KEYS 和 ONE_WORD_HASH_KEYS。当然，依赖于在 create() 方法中是根据 HashTable 类型创建相同类的对象还是创建不同类的对象，可以将 create() 方法的设计理解为是桥接，或者工厂方法。
BasicUsageEnvironment 的 BasicHashTable
BasicUsageEnvironment 中的 BasicHashTable 提供了一个 HashTable 的实现。BasicHashTable 的定义如下：
// A simple hash table implementation, inspired by the hash table
// implementation used in Tcl 7.6: <http://www.tcl.tk/>#define SMALL_HASH_TABLE_SIZE 4class BasicHashTable: public HashTable {
private:class TableEntry; // forwardpublic:BasicHashTable(int keyType);virtual ~BasicHashTable();// Used to iterate through the members of the table:class Iterator; friend class Iterator; // to make Sun's C++ compiler happyclass Iterator: public HashTable::Iterator {public:Iterator(BasicHashTable const& table);private: // implementation of inherited pure virtual functionsvoid* next(char const*& key); // returns 0 if noneprivate:BasicHashTable const& fTable;unsigned fNextIndex; // index of next bucket to be enumerated after thisTableEntry* fNextEntry; // next entry in the current bucket};private: // implementation of inherited pure virtual functionsvirtual void* Add(char const* key, void* value);// Returns the old value if different, otherwise 0virtual Boolean Remove(char const* key);virtual void* Lookup(char const* key) const;// Returns 0 if not foundvirtual unsigned numEntries() const;private:class TableEntry {public:TableEntry* fNext;char const* key;void* value;};TableEntry* lookupKey(char const* key, unsigned& index) const;// returns entry matching "key", or NULL if noneBoolean keyMatches(char const* key1, char const* key2) const;// used to implement "lookupKey()"TableEntry* insertNewEntry(unsigned index, char const* key);// creates a new entry, and inserts it in the tablevoid assignKey(TableEntry* entry, char const* key);// used to implement "insertNewEntry()"void deleteEntry(unsigned index, TableEntry* entry);void deleteKey(TableEntry* entry);// used to implement "deleteEntry()"void rebuild(); // rebuilds the table as its size increasesunsigned hashIndexFromKey(char const* key) const;// used to implement many of the routines aboveunsigned randomIndex(uintptr_t i) const {return (unsigned)(((i*1103515245) >> fDownShift) & fMask);}private:TableEntry** fBuckets; // pointer to bucket arrayTableEntry* fStaticBuckets[SMALL_HASH_TABLE_SIZE];// used for small tablesunsigned fNumBuckets, fNumEntries, fRebuildSize, fDownShift, fMask;int fKeyType;
};BasicHashTable 定义了一个类 TableEntry，用于表示键-值对。fNext 字段用于指向计算的键的哈希值冲突的不同的键-值对中的下一个。
来看 BasicHashTable 的创建：
BasicHashTable::BasicHashTable(int keyType): fBuckets(fStaticBuckets), fNumBuckets(SMALL_HASH_TABLE_SIZE),fNumEntries(0), fRebuildSize(SMALL_HASH_TABLE_SIZE*REBUILD_MULTIPLIER),fDownShift(28), fMask(0x3), fKeyType(keyType) {for (unsigned i = 0; i < SMALL_HASH_TABLE_SIZE; ++i) {fStaticBuckets[i] = NULL;}
}
. . . . . .
HashTable* HashTable::create(int keyType) {return new BasicHashTable(keyType);
}BasicHashTable 用 TableEntry 指针的数组保存所有的键-值对。在该类对象创建时，一个小的 TableEntry 指针数组 fStaticBuckets 会随着对象的创建而创建，在 BasicHashTable 中元素比较少时，直接在这个数组中保存键值对，以此来优化当元素比较少的性能，降低内存分配的开销。
fBuckets 指向保存键-值对的 TableEntry 指针数组，在对象创建初期，它指向 fStaticBuckets，而在哈希桶扩容时，它指向新分配的 TableEntry 指针数组。对于容器中元素的访问，都通过
fBuckets 来完成。fNumBuckets 用于保存 TableEntry 指针数组的长度。fNumEntries 用于保存容器中键-值对的个数。fRebuildSize 为哈希桶扩容的阈值，即当 BasicHashTable 中保存的键值对超过该值时，哈希桶需要扩容。fDownShift 和 fMask 用于计算哈希值，并把哈希值映射到哈希桶容量范围内。
向 BasicHashTable 中插入元素
可以通过 Add(char const* key, void* value) 向 BasicHashTable 中插入元素，这个函数的定义如下：
void* BasicHashTable::Add(char const* key, void* value) {void* oldValue;unsigned index;TableEntry* entry = lookupKey(key, index);if (entry != NULL) {// There's already an item with this keyoldValue = entry->value;} else {// There's no existing entry; create a new one:entry = insertNewEntry(index, key);oldValue = NULL;}entry->value = value;// If the table has become too large, rebuild it with more buckets:if (fNumEntries >= fRebuildSize) rebuild();return oldValue;
}向 BasicHashTable 中插入元素的过车大致如下：
1. 查找 BasicHashTable 中与要插入的键-值对的键匹配的元素 TableEntry。
2. 若找到，把该元素的旧的值保存在 oldValue 中。
3. 若没有找到，则通过 insertNewEntry(index, key) 创建一个 TableEntry 并加入到哈希桶中，oldValue 被赋值为 NULL。
4. 把要插入的键-值对的值保存进新创建或找到的 TableEntry 中。
5. 如果 BasicHashTable 中的元素个数超出 fRebuildSize 的大小，则对哈希桶扩容。
6. 返回元素的旧的值。
查找 BasicHashTable 中与要插入的键-值对的键匹配的元素 TableEntry 的过程如下：
BasicHashTable::TableEntry* BasicHashTable
::lookupKey(char const* key, unsigned& index) const {TableEntry* entry;index = hashIndexFromKey(key);for (entry = fBuckets[index]; entry != NULL; entry = entry->fNext) {if (keyMatches(key, entry->key)) break;}return entry;
}Boolean BasicHashTable
::keyMatches(char const* key1, char const* key2) const {// The way we check the keys for a match depends upon their type:if (fKeyType == STRING_HASH_KEYS) {return (strcmp(key1, key2) == 0);} else if (fKeyType == ONE_WORD_HASH_KEYS) {return (key1 == key2);} else {unsigned* k1 = (unsigned*)key1;unsigned* k2 = (unsigned*)key2;for (int i = 0; i < fKeyType; ++i) {if (k1[i] != k2[i]) return False; // keys differ}return True;}
}
. . . . . .
unsigned BasicHashTable::hashIndexFromKey(char const* key) const {unsigned result = 0;if (fKeyType == STRING_HASH_KEYS) {while (1) {char c = *key++;if (c == 0) break;result += (result<<3) + (unsigned)c;}result &= fMask;} else if (fKeyType == ONE_WORD_HASH_KEYS) {result = randomIndex((uintptr_t)key);} else {unsigned* k = (unsigned*)key;uintptr_t sum = 0;for (int i = 0; i < fKeyType; ++i) {sum += k[i];}result = randomIndex(sum);}return result;
}lookupKey() 首先通过 hashIndexFromKey(key) 根据键值对的键计算哈希值，并把该值映射到哈希桶容量范围内，得到索引。然后根据得到的索引，查找与传入的键匹配的元素。
这里可以更加清晰地看到，不同类型的 HashTable 之间的区别主要在于对待键的方式不同。STRING_HASH_KEYS 型的 HashTable，其键为传入的字符串指针指向的字符串的内容，而
ONE_WORD_HASH_KEYS 型的 HashTable，其键则为传入的字符串指针本身。
计算最终的哈希值，并把该值映射到哈希桶容量范围内，得到索引的过程如下：
unsigned randomIndex(uintptr_t i) const {return (unsigned)(((i*1103515245) >> fDownShift) & fMask);}insertNewEntry(index, key) 创建一个 TableEntry 并加入到哈希桶中的过程如下：
BasicHashTable::TableEntry* BasicHashTable
::insertNewEntry(unsigned index, char const* key) {TableEntry* entry = new TableEntry();entry->fNext = fBuckets[index];fBuckets[index] = entry;++fNumEntries;assignKey(entry, key);return entry;
}void BasicHashTable::assignKey(TableEntry* entry, char const* key) {// The way we assign the key depends upon its type:if (fKeyType == STRING_HASH_KEYS) {entry->key = strDup(key);} else if (fKeyType == ONE_WORD_HASH_KEYS) {entry->key = key;} else if (fKeyType > 0) {unsigned* keyFrom = (unsigned*)key;unsigned* keyTo = new unsigned[fKeyType];for (int i = 0; i < fKeyType; ++i) keyTo[i] = keyFrom[i];entry->key = (char const*)keyTo;}
}可见插入的过程主要为，
1. 创建 TableEntry 对象，并把它插入到键所对应的 TableEntry 指针数组中的 TableEntry 元素链的头部。
2. 增加容器中元素个数的计数。
3. 为 TableEntry 分配传入的键。
依据 HashTable 类型的不同，分配键的方式也不同。
1. 对于 STRING_HASH_KEYS 型的 HashTable，需要将传入的字符串指针指向的字符串的内容复制一份，赋值给 TableEntry 的 key。
2. 对于 ONE_WORD_HASH_KEYS 型的 HashTable，需要将传入的字符串指针本身，赋值给 TableEntry 的 key。
3. 对于 fKeyType 大于 0 的情况，需要将传入的字符串指针指向的字符串的内容的前 (sizeof(unsigned) * fKeyType) 个字节复制一份，赋值给 TableEntry 的 key。这种代码真是看得人胆颤心惊，万一传入的 key 字符串长度小于 (sizeof(unsigned) * fKeyType) 个字节呢？。。。
对比 keyMatches() 和 assignKey() 函数的实现，不难发现，当 HashTable 类型 fKeyType 大于0，且不是 ONE_WORD_HASH_KEYS 时，要求作为哈希表中键值对的键的字符串的长度固定为 (sizeof(unsigned) * fKeyType) 个字节。
然后来看，BasicHashTable 中对哈希桶扩容的过程：
void BasicHashTable::rebuild() {// Remember the existing table size:unsigned oldSize = fNumBuckets;TableEntry** oldBuckets = fBuckets;// Create the new sized table:fNumBuckets *= 4;fBuckets = new TableEntry*[fNumBuckets];for (unsigned i = 0; i < fNumBuckets; ++i) {fBuckets[i] = NULL;}fRebuildSize *= 4;fDownShift -= 2;fMask = (fMask<<2)|0x3;// Rehash the existing entries into the new table:for (TableEntry** oldChainPtr = oldBuckets; oldSize > 0;--oldSize, ++oldChainPtr) {for (TableEntry* hPtr = *oldChainPtr; hPtr != NULL;hPtr = *oldChainPtr) {*oldChainPtr = hPtr->fNext;unsigned index = hashIndexFromKey(hPtr->key);hPtr->fNext = fBuckets[index];fBuckets[index] = hPtr;}}// Free the old bucket array, if it was dynamically allocated:if (oldBuckets != fStaticBuckets) delete[] oldBuckets;
}在这里就是，
1. 为 fBuckets 分配一块新的内存，容量为原来的4倍。
2. 适当更新 fNumBuckets，fRebuildSize，fDownShift 和 fMask 等。
3. 将老的 fBuckets 中的元素，依据元素的 key 和新的哈希桶的容量，搬到新的 fBuckets 中。
4. 根据需要释放老的 fBuckets 的内存。
在 BasicHashTable 中查找元素
然后来看在 BasicHashTable 中查找元素的过程：
void* BasicHashTable::Lookup(char const* key) const {unsigned index;TableEntry* entry = lookupKey(key, index);if (entry == NULL) return NULL; // no such entryreturn entry->value;
}这个过程主要是根据 key，通过 lookupKey() 查找到对应的元素 TableEntry，然后返回其 value。
移除 BasicHashTable 中的元素
来看移除 BasicHashTable 中的元素的过程：
Boolean BasicHashTable::Remove(char const* key) {unsigned index;TableEntry* entry = lookupKey(key, index);if (entry == NULL) return False; // no such entrydeleteEntry(index, entry);return True;
}
. . . . . .
void BasicHashTable::deleteEntry(unsigned index, TableEntry* entry) {TableEntry** ep = &fBuckets[index];Boolean foundIt = False;while (*ep != NULL) {if (*ep == entry) {foundIt = True;*ep = entry->fNext;break;}ep = &((*ep)->fNext);}if (!foundIt) { // shouldn't happen
#ifdef DEBUGfprintf(stderr, "BasicHashTable[%p]::deleteEntry(%d,%p): internal error - not found (first entry %p", this, index, entry, fBuckets[index]);if (fBuckets[index] != NULL) fprintf(stderr, ", next entry %p", fBuckets[index]->fNext);fprintf(stderr, ")\n");
#endif}--fNumEntries;deleteKey(entry);delete entry;
}void BasicHashTable::deleteKey(TableEntry* entry) {// The way we delete the key depends upon its type:if (fKeyType == ONE_WORD_HASH_KEYS) {entry->key = NULL;} else {delete[] (char*)entry->key;entry->key = NULL;}
}移除 BasicHashTable 中的元素的过程，也是免不了要先找到元素在 BasicHashTable 中的 TableEntry 的，找到之后，通过 deleteEntry() 移除元素。
在 deleteEntry() 中，先把元素从 BasicHashTable 中移除出去，然后通过 deleteKey() 释放 key 占用的内存，随后释放 TableEntry 本身占用的内存。这里把 TableEntry 从 BasicHashTable 中移除出去采用了下面这种方法：
TableEntry** ep = &fBuckets[index];Boolean foundIt = False;while (*ep != NULL) {if (*ep == entry) {foundIt = True;*ep = entry->fNext;break;}ep = &((*ep)->fNext);}通过二级指针，遍历链表一趟，就将元素移除出去了。记得这是这中场景下 Linus 大神鼓励的一种写法。从链表中删除一个元素，用好几个临时变量，或者加许多判断的方法，都弱爆了。
通过 Iterator 遍历 BasicHashTable
可以使用 BasicHashTable 中定义的 Iterator 来遍历它。过程如下：
BasicHashTable::Iterator::Iterator(BasicHashTable const& table): fTable(table), fNextIndex(0), fNextEntry(NULL) {
}void* BasicHashTable::Iterator::next(char const*& key) {while (fNextEntry == NULL) {if (fNextIndex >= fTable.fNumBuckets) return NULL;fNextEntry = fTable.fBuckets[fNextIndex++];}BasicHashTable::TableEntry* entry = fNextEntry;fNextEntry = entry->fNext;key = entry->key;return entry->value;
}
. . . . . .
HashTable::Iterator* HashTable::Iterator::create(HashTable const& hashTable) {// "hashTable" is assumed to be a BasicHashTablereturn new BasicHashTable::Iterator((BasicHashTable const&)hashTable);
}BasicHashTable 的 fBuckets 中的每个元素都保存一个 TableEntry 的链表。在这里会逐个链表地遍历。
live555 定义的 HashTable 的内容就是这些了。
UsageEnvironment
live555 中，UsageEnvironment 类扮演一个简单的控制器的角色。UsageEnvironment 模块中，UsageEnvironment 类的定义如下：
class TaskScheduler; // forward// An abstract base class, subclassed for each use of the libraryclass UsageEnvironment {
public:Boolean reclaim();// returns True iff we were actually able to delete our object// task scheduler:TaskScheduler& taskScheduler() const {return fScheduler;}// result message handling:typedef char const* MsgString;virtual MsgString getResultMsg() const = 0;virtual void setResultMsg(MsgString msg) = 0;virtual void setResultMsg(MsgString msg1, MsgString msg2) = 0;virtual void setResultMsg(MsgString msg1, MsgString msg2, MsgString msg3) = 0;virtual void setResultErrMsg(MsgString msg, int err = 0) = 0;// like setResultMsg(), except that an 'errno' message is appended. (If "err == 0", the "getErrno()" code is used instead.)virtual void appendToResultMsg(MsgString msg) = 0;virtual void reportBackgroundError() = 0;// used to report a (previously set) error message within// a background eventvirtual void internalError(); // used to 'handle' a 'should not occur'-type error condition within the library.// 'errno'virtual int getErrno() const = 0;// 'console' output:virtual UsageEnvironment& operator<<(char const* str) = 0;virtual UsageEnvironment& operator<<(int i) = 0;virtual UsageEnvironment& operator<<(unsigned u) = 0;virtual UsageEnvironment& operator<<(double d) = 0;virtual UsageEnvironment& operator<<(void* p) = 0;// a pointer to additional, optional, client-specific statevoid* liveMediaPriv;void* groupsockPriv;protected:UsageEnvironment(TaskScheduler& scheduler); // abstract base classvirtual ~UsageEnvironment(); // we are deleted only by reclaim()private:TaskScheduler& fScheduler;
};UsageEnvironment 类持有 TaskScheduler 的引用，并提供文本的输出操作，用于输出信息，其它还提供了获取 errno 的操作，在发生内部错误时的处理程序 internalError()，以及销毁自身的操作。UsageEnvironment 类本身实现了如下这几个函数：
Boolean UsageEnvironment::reclaim() {
// We delete ourselves only if we have no remainining state:if (liveMediaPriv == NULL && groupsockPriv == NULL) {delete this;return True;}return False;
}UsageEnvironment::UsageEnvironment(TaskScheduler& scheduler)
: liveMediaPriv(NULL), groupsockPriv(NULL), fScheduler(scheduler) {
}UsageEnvironment::~UsageEnvironment() {
}// By default, we handle 'should not occur'-type library errors by calling abort(). Subclasses can redefine this, if desired.
// (If your runtime library doesn't define the "abort()" function, then define your own (e.g., that does nothing).)
void UsageEnvironment::internalError() {abort();
}这些函数都比较简单，这里不再赘述。
UsageEnvironment 是一个接口类，BasicUsageEnvironment 模块中，通过两个类 BasicUsageEnvironment 和 BasicUsageEnvironment0，提供了它的一个实现。BasicUsageEnvironment0 类提供了那组直接操作字符串的函数的实现，该类的定义如下：
class BasicUsageEnvironment0: public UsageEnvironment {
public:// redefined virtual functions:virtual MsgString getResultMsg() const;virtual void setResultMsg(MsgString msg);virtual void setResultMsg(MsgString msg1,MsgString msg2);virtual void setResultMsg(MsgString msg1,MsgString msg2,MsgString msg3);virtual void setResultErrMsg(MsgString msg, int err = 0);virtual void appendToResultMsg(MsgString msg);virtual void reportBackgroundError();protected:BasicUsageEnvironment0(TaskScheduler& taskScheduler);virtual ~BasicUsageEnvironment0();private:void reset();char fResultMsgBuffer[RESULT_MSG_BUFFER_MAX];unsigned fCurBufferSize;unsigned fBufferMaxSize;
};这个类定义了一个缓冲区，大小为 RESULT_MSG_BUFFER_MAX。类的实现如下：
BasicUsageEnvironment0::BasicUsageEnvironment0(TaskScheduler& taskScheduler): UsageEnvironment(taskScheduler),fBufferMaxSize(RESULT_MSG_BUFFER_MAX) {reset();
}BasicUsageEnvironment0::~BasicUsageEnvironment0() {
}void BasicUsageEnvironment0::reset() {fCurBufferSize = 0;fResultMsgBuffer[fCurBufferSize] = '\0';
}// Implementation of virtual functions:char const* BasicUsageEnvironment0::getResultMsg() const {return fResultMsgBuffer;
}void BasicUsageEnvironment0::setResultMsg(MsgString msg) {reset();appendToResultMsg(msg);
}void BasicUsageEnvironment0::setResultMsg(MsgString msg1, MsgString msg2) {setResultMsg(msg1);appendToResultMsg(msg2);
}void BasicUsageEnvironment0::setResultMsg(MsgString msg1, MsgString msg2,MsgString msg3) {setResultMsg(msg1, msg2);appendToResultMsg(msg3);
}void BasicUsageEnvironment0::setResultErrMsg(MsgString msg, int err) {setResultMsg(msg);if (err == 0) err = getErrno();
. . . . . .appendToResultMsg(strerror(err));
#endif
}void BasicUsageEnvironment0::appendToResultMsg(MsgString msg) {char* curPtr = &fResultMsgBuffer[fCurBufferSize];unsigned spaceAvailable = fBufferMaxSize - fCurBufferSize;unsigned msgLength = strlen(msg);// Copy only enough of "msg" as will fit:if (msgLength > spaceAvailable-1) {msgLength = spaceAvailable-1;}memmove(curPtr, (char*)msg, msgLength);fCurBufferSize += msgLength;fResultMsgBuffer[fCurBufferSize] = '\0';
}void BasicUsageEnvironment0::reportBackgroundError() {fputs(getResultMsg(), stderr);
}这组函数提供了把传入的字符串，加进缓冲区，以及把缓冲区中的内容输出到标准输出的功能。
BasicUsageEnvironment 类则提供了那组用于输出基本数据类型的操作符。这个类的定义如下：
class BasicUsageEnvironment: public BasicUsageEnvironment0 {
public:static BasicUsageEnvironment* createNew(TaskScheduler& taskScheduler);// redefined virtual functions:virtual int getErrno() const;virtual UsageEnvironment& operator<<(char const* str);virtual UsageEnvironment& operator<<(int i);virtual UsageEnvironment& operator<<(unsigned u);virtual UsageEnvironment& operator<<(double d);virtual UsageEnvironment& operator<<(void* p);protected:BasicUsageEnvironment(TaskScheduler& taskScheduler);// called only by "createNew()" (or subclass constructors)virtual ~BasicUsageEnvironment();
};定义比较简单。然后来看它的实现：
BasicUsageEnvironment::BasicUsageEnvironment(TaskScheduler& taskScheduler)
: BasicUsageEnvironment0(taskScheduler) {
. . . . . .
}BasicUsageEnvironment::~BasicUsageEnvironment() {
}BasicUsageEnvironment*
BasicUsageEnvironment::createNew(TaskScheduler& taskScheduler) {return new BasicUsageEnvironment(taskScheduler);
}int BasicUsageEnvironment::getErrno() const {
#if defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_WCE)return WSAGetLastError();
#elsereturn errno;
#endif
}UsageEnvironment& BasicUsageEnvironment::operator<<(char const* str) {if (str == NULL) str = "(NULL)"; // sanity checkfprintf(stderr, "%s", str);return *this;
}UsageEnvironment& BasicUsageEnvironment::operator<<(int i) {fprintf(stderr, "%d", i);return *this;
}UsageEnvironment& BasicUsageEnvironment::operator<<(unsigned u) {fprintf(stderr, "%u", u);return *this;
}UsageEnvironment& BasicUsageEnvironment::operator<<(double d) {fprintf(stderr, "%f", d);return *this;
}UsageEnvironment& BasicUsageEnvironment::operator<<(void* p) {fprintf(stderr, "%p", p);return *this;
}BasicUsageEnvironment 类还提供了一个静态的创建对象的函数 createNew() 用来创建 BasicUsageEnvironment 的对象。对于那些输出操作符的实现，都比较直接。
感觉 live555 这组 I/O 函数的实现并不是太好，C++ 标准库对这些接口都有着良好的实现，但 live555 似乎并没有要引入 C++ 标准库的打算。
TaskScheduler
TaskScheduler 是 live555 中的任务调度器，它实现了 live555 的事件循环。UsageEnvironment 模块中，TaskScheduler 类的定义如下：
typedef void TaskFunc(void* clientData);
typedef void* TaskToken;
typedef u_int32_t EventTriggerId;class TaskScheduler {public:virtual ~TaskScheduler();virtual TaskToken scheduleDelayedTask(int64_t microseconds, TaskFunc* proc,void* clientData) = 0;// Schedules a task to occur (after a delay) when we next// reach a scheduling point.// (Does not delay if "microseconds" <= 0)// Returns a token that can be used in a subsequent call to// unscheduleDelayedTask() or rescheduleDelayedTask()// (but only if the task has not yet occurred).virtual void unscheduleDelayedTask(TaskToken& prevTask) = 0;// (Has no effect if "prevTask" == NULL)// Sets "prevTask" to NULL afterwards.// Note: This MUST NOT be called if the scheduled task has already occurred.virtual void rescheduleDelayedTask(TaskToken& task,int64_t microseconds, TaskFunc* proc,void* clientData);// Combines "unscheduleDelayedTask()" with "scheduleDelayedTask()"// (setting "task" to the new task token).// Note: This MUST NOT be called if the scheduled task has already occurred.// For handling socket operations in the background (from the event loop):typedef void BackgroundHandlerProc(void* clientData, int mask);// Possible bits to set in "mask". (These are deliberately defined// the same as those in Tcl, to make a Tcl-based subclass easy.)#define SOCKET_READABLE (1<<1)#define SOCKET_WRITABLE (1<<2)#define SOCKET_EXCEPTION (1<<3)virtual void setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc* handlerProc, void* clientData) = 0;void disableBackgroundHandling(int socketNum) { setBackgroundHandling(socketNum, 0, NULL, NULL); }virtual void moveSocketHandling(int oldSocketNum, int newSocketNum) = 0;// Changes any socket handling for "oldSocketNum" so that occurs with "newSocketNum" instead.virtual void doEventLoop(char volatile* watchVariable = NULL) = 0;// Causes further execution to take place within the event loop.// Delayed tasks, background I/O handling, and other events are handled, sequentially (as a single thread of control).// (If "watchVariable" is not NULL, then we return from this routine when *watchVariable != 0)virtual EventTriggerId createEventTrigger(TaskFunc* eventHandlerProc) = 0;// Creates a 'trigger' for an event, which - if it occurs - will be handled (from the event loop) using "eventHandlerProc".// (Returns 0 iff no such trigger can be created (e.g., because of implementation limits on the number of triggers).)virtual void deleteEventTrigger(EventTriggerId eventTriggerId) = 0;virtual void triggerEvent(EventTriggerId eventTriggerId, void* clientData = NULL) = 0;// Causes the (previously-registered) handler function for the specified event to be handled (from the event loop).// The handler function is called with "clientData" as parameter.// Note: This function (unlike other library functions) may be called from an external thread// - to signal an external event. (However, "triggerEvent()" should not be called with the// same 'event trigger id' from different threads.)// The following two functions are deprecated, and are provided for backwards-compatibility only:void turnOnBackgroundReadHandling(int socketNum, BackgroundHandlerProc* handlerProc, void* clientData) {setBackgroundHandling(socketNum, SOCKET_READABLE, handlerProc, clientData);}void turnOffBackgroundReadHandling(int socketNum) { disableBackgroundHandling(socketNum); }virtual void internalError(); // used to 'handle' a 'should not occur'-type error condition within the library.protected:TaskScheduler(); // abstract base class
};TaskScheduler 的接口可以分为如下的几组：
1. 调度定时器任务。这主要包括 scheduleDelayedTask()、unscheduleDelayedTask() 和 rescheduleDelayedTask() 这几个函数，它们分别用于调度一个延迟任务，取消一个延迟任务，以及重新调度一个延迟任务。
2. 后台调度 Socket I/O 处理操作。这主要包括 setBackgroundHandling()、disableBackgroundHandling()、moveSocketHandling()、turnOnBackgroundReadHandling() 和 turnOffBackgroundReadHandling() 这样几个函数，它们用于设置、修改或取消 socket 上特定 I/O 事件的处理程序。
3. 用户事件调度。这主要包括 createEventTrigger()、deleteEventTrigger() 和 triggerEvent() 这样几个函数，它们用于创建、删除及触发一个用户自定义事件。
4. 执行事件循环。这个由 doEventLoop() 函数完成，这个函数通常也是应用程序的主循环。
5. 内部错误处理程序。这个指 internalError() 函数，用于在 TaskScheduler 发生内部错误时，执行一些处理。
TaskScheduler 类本身提供了几个简单函数的实现：
TaskScheduler::TaskScheduler() {
}TaskScheduler::~TaskScheduler() {
}void TaskScheduler::rescheduleDelayedTask(TaskToken& task,int64_t microseconds, TaskFunc* proc,void* clientData) {unscheduleDelayedTask(task);task = scheduleDelayedTask(microseconds, proc, clientData);
}// By default, we handle 'should not occur'-type library errors by calling abort(). Subclasses can redefine this, if desired.
void TaskScheduler::internalError() {abort();
}它们都简单而易于理解，这里不再赘述。
BasicUsageEnvironment 模块中同样提供了，TaskScheduler 接口的实现。与 UsageEnvironment 接口的情况类似，TaskScheduler 类的接口同样由两个类来实现，分别是 BasicTaskScheduler 和 BasicTaskScheduler0，其中
BasicTaskScheduler0 类实现我们前面提到的第 1 组，第 3 组接口，以及 doEventLoop() 的框架，而 BasicTaskScheduler 则用于实现第 2 组接口，并实现 doEventLoop() 的事件循环的循环体。
BasicTaskScheduler0 类定义如下：
class HandlerSet; // forward#define MAX_NUM_EVENT_TRIGGERS 32// An abstract base class, useful for subclassing
// (e.g., to redefine the implementation of socket event handling)
class BasicTaskScheduler0: public TaskScheduler {
public:virtual ~BasicTaskScheduler0();virtual void SingleStep(unsigned maxDelayTime = 0) = 0;// "maxDelayTime" is in microseconds. It allows a subclass to impose a limit// on how long "select()" can delay, in case it wants to also do polling.// 0 (the default value) means: There's no maximum; just look at the delay queuepublic:// Redefined virtual functions:virtual TaskToken scheduleDelayedTask(int64_t microseconds, TaskFunc* proc,void* clientData);virtual void unscheduleDelayedTask(TaskToken& prevTask);virtual void doEventLoop(char volatile* watchVariable);virtual EventTriggerId createEventTrigger(TaskFunc* eventHandlerProc);virtual void deleteEventTrigger(EventTriggerId eventTriggerId);virtual void triggerEvent(EventTriggerId eventTriggerId, void* clientData = NULL);protected:BasicTaskScheduler0();protected:// To implement delayed operations:DelayQueue fDelayQueue;// To implement background reads:HandlerSet* fHandlers;int fLastHandledSocketNum;// To implement event triggers:EventTriggerId volatile fTriggersAwaitingHandling; // implemented as a 32-bit bitmapEventTriggerId fLastUsedTriggerMask; // implemented as a 32-bit bitmapTaskFunc* fTriggeredEventHandlers[MAX_NUM_EVENT_TRIGGERS];void* fTriggeredEventClientDatas[MAX_NUM_EVENT_TRIGGERS];unsigned fLastUsedTriggerNum; // in the range [0,MAX_NUM_EVENT_TRIGGERS)
};BasicTaskScheduler0 类的成员函数，基本上就是继承自 TaskScheduler 类中，它要实现功能的那部分接口，但它新添加了一个虚函数 SingleStep() ，用于让其子类覆写，实现事件循环中的单次迭代。
BasicTaskScheduler0 类的成员变量则是清晰地分为三组：fDelayQueue 用于实现定时器操作；fHandlers 和 fLastHandledSocketNum 用于实现 Socket I/O 事件处理操作；fTriggersAwaitingHandling、fLastUsedTriggerMask、fTriggeredEventHandlers、fTriggeredEventClientDatas 和 fLastUsedTriggerNum 用于实现用户事件。
*对于 fHandlers 和 fLastHandledSocketNum，感觉实际上没有必要在
BasicTaskScheduler0 类中定义。纵观 BasicTaskScheduler0 类的整个实现，除初始化这两个成员变量之外，不存在其它的访问操作。从这两个变量的职责来说，也不在 BasicTaskScheduler0 类的职责范围内。感觉这两个变量实际上放在 BasicTaskScheduler 类中更合适一点。*
BasicTaskScheduler0 类对象创建及销毁过程如下：
BasicTaskScheduler0::BasicTaskScheduler0(): fLastHandledSocketNum(-1), fTriggersAwaitingHandling(0), fLastUsedTriggerMask(1), fLastUsedTriggerNum(MAX_NUM_EVENT_TRIGGERS-1) {fHandlers = new HandlerSet;for (unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {fTriggeredEventHandlers[i] = NULL;fTriggeredEventClientDatas[i] = NULL;}
}BasicTaskScheduler0::~BasicTaskScheduler0() {delete fHandlers;
}在类对象创建的过程中，创建和/或初始化成员对象，对象销毁时，则销毁成员对象。
时间的表示
在 live555 的 BasicUsageEnvironment 模块中，用 Timeval 类来描述时间，并用 DelayInterval 来描述延迟时间。这两个类的定义如下：
class Timeval {
public:time_base_seconds seconds() const {return fTv.tv_sec;}time_base_seconds seconds() {return fTv.tv_sec;}time_base_seconds useconds() const {return fTv.tv_usec;}time_base_seconds useconds() {return fTv.tv_usec;}int operator>=(Timeval const& arg2) const;int operator<=(Timeval const& arg2) const {return arg2 >= *this;}int operator<(Timeval const& arg2) const {return !(*this >= arg2);}int operator>(Timeval const& arg2) const {return arg2 < *this;}int operator==(Timeval const& arg2) const {return *this >= arg2 && arg2 >= *this;}int operator!=(Timeval const& arg2) const {return !(*this == arg2);}void operator+=(class DelayInterval const& arg2);void operator-=(class DelayInterval const& arg2);// returns ZERO iff arg2 >= arg1protected:Timeval(time_base_seconds seconds, time_base_seconds useconds) {fTv.tv_sec = seconds; fTv.tv_usec = useconds;}private:time_base_seconds& secs() {return (time_base_seconds&)fTv.tv_sec;}time_base_seconds& usecs() {return (time_base_seconds&)fTv.tv_usec;}struct timeval fTv;
};
. . . . . .
class DelayInterval: public Timeval {
public:DelayInterval(time_base_seconds seconds, time_base_seconds useconds): Timeval(seconds, useconds) {}
};DelayInterval 类基本上就是 Timeval 类的别名，而之所以重新定义这样一个类，大概主要是为了便于阅读维护吧。Timeval 类用标准库中保存时间的 struct timeval 结构保存时间值，但通过操作符重载，提供了一些方便操作时间值的操作符函数。以成员函数的方式定义的操作符函数的实现如下：
int Timeval::operator>=(const Timeval& arg2) const {return seconds() > arg2.seconds()|| (seconds() == arg2.seconds()&& useconds() >= arg2.useconds());
}void Timeval::operator+=(const DelayInterval& arg2) {secs() += arg2.seconds(); usecs() += arg2.useconds();if (useconds() >= MILLION) {usecs() -= MILLION;++secs();}
}void Timeval::operator-=(const DelayInterval& arg2) {secs() -= arg2.seconds(); usecs() -= arg2.useconds();if ((int)useconds() < 0) {usecs() += MILLION;--secs();}if ((int)seconds() < 0)secs() = usecs() = 0;}这些操作符函数的实现，都比较直观。
除了以成员操作符函数定义的这些操作符之外，还包括如下这些非成员函数的操作符：
#ifndef max
inline Timeval max(Timeval const& arg1, Timeval const& arg2) {return arg1 >= arg2 ? arg1 : arg2;
}
#endif
#ifndef min
inline Timeval min(Timeval const& arg1, Timeval const& arg2) {return arg1 <= arg2 ? arg1 : arg2;
}
#endif
. . . . . .
DelayInterval operator-(const Timeval& arg1, const Timeval& arg2) {time_base_seconds secs = arg1.seconds() - arg2.seconds();time_base_seconds usecs = arg1.useconds() - arg2.useconds();if ((int)usecs < 0) {usecs += MILLION;--secs;}if ((int)secs < 0)return DELAY_ZERO;elsereturn DelayInterval(secs, usecs);
}///// DelayInterval /////DelayInterval operator*(short arg1, const DelayInterval& arg2) {time_base_seconds result_seconds = arg1*arg2.seconds();time_base_seconds result_useconds = arg1*arg2.useconds();time_base_seconds carry = result_useconds/MILLION;result_useconds -= carry*MILLION;result_seconds += carry;return DelayInterval(result_seconds, result_useconds);
}#ifndef INT_MAX
#define INT_MAX 0x7FFFFFFF
#endif
const DelayInterval DELAY_ZERO(0, 0);
const DelayInterval DELAY_SECOND(1, 0);
const DelayInterval DELAY_MINUTE = 60*DELAY_SECOND;
const DelayInterval DELAY_HOUR = 60*DELAY_MINUTE;
const DelayInterval DELAY_DAY = 24*DELAY_HOUR;
const DelayInterval ETERNITY(INT_MAX, MILLION-1);
// used internally to make the implementation work它们的实现也都比较直观。
延迟任务的表示及组织
在 live555 的 BasicUsageEnvironment 模块中，用 DelayQueueEntry 类表示一个延迟任务。该类定义如下：
class DelayQueueEntry {
public:virtual ~DelayQueueEntry();intptr_t token() {return fToken;}protected: // abstract base classDelayQueueEntry(DelayInterval delay);virtual void handleTimeout();private:friend class DelayQueue;DelayQueueEntry* fNext;DelayQueueEntry* fPrev;DelayInterval fDeltaTimeRemaining;intptr_t fToken;static intptr_t tokenCounter;
};延迟任务通过 token 来标识，token 在对象创建时，借助于全局的 tokenCounter 产生。fDeltaTimeRemaining 用于表示延迟任务需要被执行的时间距当前时间的间隔。由 fNext 和 fPrev 不难猜到，在 BasicUsageEnvironment 模块中是以双向链表来组织延迟任务的。handleTimeout() 函数是延迟任务的主体，需要由具体的子类提供实现。
DelayQueueEntry 类的具体实现如下：
intptr_t DelayQueueEntry::tokenCounter = 0;DelayQueueEntry::DelayQueueEntry(DelayInterval delay): fDeltaTimeRemaining(delay) {fNext = fPrev = this;fToken = ++tokenCounter;
}DelayQueueEntry::~DelayQueueEntry() {
}void DelayQueueEntry::handleTimeout() {delete this;
}BasicUsageEnvironment 模块中实际使用 AlarmHandler 来描述延迟任务的，其定义如下：
class AlarmHandler: public DelayQueueEntry {
public:AlarmHandler(TaskFunc* proc, void* clientData, DelayInterval timeToDelay): DelayQueueEntry(timeToDelay), fProc(proc), fClientData(clientData) {}private: // redefined virtual functionsvirtual void handleTimeout() {(*fProc)(fClientData);DelayQueueEntry::handleTimeout();}private:TaskFunc* fProc;void* fClientData;
};BasicUsageEnvironment 模块需要用 DelayQueueEntry 类表示和组织延迟任务，而在接口层，也就是 TaskScheduler 中则是通过 TaskFunc 和用户数据指针来表示延迟任务。AlarmHandler 协助完成接口的结构到实现的结构的转换。
BasicUsageEnvironment 模块使用 DelayQueue 把 DelayQueueEntry 组织为双向链表，该类定义如下：
class DelayQueue: public DelayQueueEntry {
public:DelayQueue();virtual ~DelayQueue();void addEntry(DelayQueueEntry* newEntry); // returns a token for the entryvoid updateEntry(DelayQueueEntry* entry, DelayInterval newDelay);void updateEntry(intptr_t tokenToFind, DelayInterval newDelay);void removeEntry(DelayQueueEntry* entry); // but doesn't delete itDelayQueueEntry* removeEntry(intptr_t tokenToFind); // but doesn't delete itDelayInterval const& timeToNextAlarm();void handleAlarm();private:DelayQueueEntry* head() { return fNext; }DelayQueueEntry* findEntryByToken(intptr_t token);void synchronize(); // bring the 'time remaining' fields up-to-date_EventTime fLastSyncTime;
};首先来看一下 DelayQueue 类对象构造和销毁的过程：
DelayQueue::DelayQueue(): DelayQueueEntry(ETERNITY) {fLastSyncTime = TimeNow();
}DelayQueue::~DelayQueue() {while (fNext != this) {DelayQueueEntry* entryToRemove = fNext;removeEntry(entryToRemove);delete entryToRemove;}
}然后来看一下向链表中添加元素的过程：
void DelayQueue::addEntry(DelayQueueEntry* newEntry) {synchronize();DelayQueueEntry* cur = head();while (newEntry->fDeltaTimeRemaining >= cur->fDeltaTimeRemaining) {newEntry->fDeltaTimeRemaining -= cur->fDeltaTimeRemaining;cur = cur->fNext;}cur->fDeltaTimeRemaining -= newEntry->fDeltaTimeRemaining;// Add "newEntry" to the queue, just before "cur":newEntry->fNext = cur;newEntry->fPrev = cur->fPrev;cur->fPrev = newEntry->fPrev->fNext = newEntry;
}
. . . . . .
void DelayQueue::synchronize() {// First, figure out how much time has elapsed since the last sync:_EventTime timeNow = TimeNow();if (timeNow < fLastSyncTime) {// The system clock has apparently gone back in time; reset our sync time and return:fLastSyncTime = timeNow;return;}DelayInterval timeSinceLastSync = timeNow - fLastSyncTime;fLastSyncTime = timeNow;// Then, adjust the delay queue for any entries whose time is up:DelayQueueEntry* curEntry = head();while (timeSinceLastSync >= curEntry->fDeltaTimeRemaining) {timeSinceLastSync -= curEntry->fDeltaTimeRemaining;curEntry->fDeltaTimeRemaining = DELAY_ZERO;curEntry = curEntry->fNext;}curEntry->fDeltaTimeRemaining -= timeSinceLastSync;
}通过这两个函数，可以更加清楚的看到，在 DelayQueue 中是怎么组织延迟任务的。DelayQueue 因为其本身是一个 DelayQueueEntry，实际上它是一个环形双向链表。它的 fNext 指向这个链表的逻辑上的头部元素，但它本身是这个链表的尾部元素。双向链表中每个元素的 fDeltaTimeRemaining 保存的是这个任务应该被调度执行的时间点，与它前面的那个任务应该被调度执行的时间点之间的差值，当该值为 0 时，也就表示这个任务需要被执行了。这样也就是说， DelayQueue 是一个双向环形的有序链表，顺序按照所需的执行时间排列。
removeEntry() 用于从双向链表中移除一个任务：
void DelayQueue::removeEntry(DelayQueueEntry* entry) {if (entry == NULL || entry->fNext == NULL) return;entry->fNext->fDeltaTimeRemaining += entry->fDeltaTimeRemaining;entry->fPrev->fNext = entry->fNext;entry->fNext->fPrev = entry->fPrev;entry->fNext = entry->fPrev = NULL;// in case we should try to remove it again
}DelayQueueEntry* DelayQueue::removeEntry(intptr_t tokenToFind) {DelayQueueEntry* entry = findEntryByToken(tokenToFind);removeEntry(entry);return entry;
}
. . . . . .
DelayQueueEntry* DelayQueue::findEntryByToken(intptr_t tokenToFind) {DelayQueueEntry* cur = head();while (cur != this) {if (cur->token() == tokenToFind) return cur;cur = cur->fNext;}return NULL;
}removeEntry(DelayQueueEntry* entry) 中，在 entry->fNext == NULL 成立时会直接返回，也是由于 DelayQueue 实际是一个双向环形链表的缘故。
DelayQueue 还提供了用于更新延迟任务执行时间的接口：
void DelayQueue::updateEntry(DelayQueueEntry* entry, DelayInterval newDelay) {if (entry == NULL) return;removeEntry(entry);entry->fDeltaTimeRemaining = newDelay;addEntry(entry);
}void DelayQueue::updateEntry(intptr_t tokenToFind, DelayInterval newDelay) {DelayQueueEntry* entry = findEntryByToken(tokenToFind);updateEntry(entry, newDelay);
}此外，timeToNextAlarm() 用于计算最近的一个任务执行的时间，而 handleAlarm() 则用于执行该任务。
DelayInterval const& DelayQueue::timeToNextAlarm() {if (head()->fDeltaTimeRemaining == DELAY_ZERO) return DELAY_ZERO; // a common casesynchronize();return head()->fDeltaTimeRemaining;
}void DelayQueue::handleAlarm() {if (head()->fDeltaTimeRemaining != DELAY_ZERO) synchronize();if (head()->fDeltaTimeRemaining == DELAY_ZERO) {// This event is due to be handled:DelayQueueEntry* toRemove = head();removeEntry(toRemove); // do this first, in case handler accesses queuetoRemove->handleTimeout();}
}延迟任务调度
看过了 live555 的 BasicUsageEnvironment 模块中时间的表示，以及延迟任务的表示及组织之后，再来看延迟任务的调度。
BasicTaskScheduler0 类通过 scheduleDelayedTask() 和 unscheduleDelayedTask() 函数实现定时器任务调度，它们分别用于调度一个延迟任务及取消一个延迟任务，它们的实现如下：
TaskToken BasicTaskScheduler0::scheduleDelayedTask(int64_t microseconds,TaskFunc* proc,void* clientData) {if (microseconds < 0) microseconds = 0;DelayInterval timeToDelay((long)(microseconds/1000000), (long)(microseconds%1000000));AlarmHandler* alarmHandler = new AlarmHandler(proc, clientData, timeToDelay);fDelayQueue.addEntry(alarmHandler);return (void*)(alarmHandler->token());
}void BasicTaskScheduler0::unscheduleDelayedTask(TaskToken& prevTask) {DelayQueueEntry* alarmHandler = fDelayQueue.removeEntry((intptr_t)prevTask);prevTask = NULL;delete alarmHandler;
}延迟任务调度也就是把延迟任务放进 DelayQueue 中，而取消延迟任务则是，把任务从 DelayQueue 中移除。
后面再来看延迟任务被执行的过程。
用户事件任务调度
用户事件任务调度接口，让调用者可以创建任务，并触发该任务在事件循环中执行。这组接口主要包括这样几个：createEventTrigger()、deleteEventTrigger() 和 triggerEvent()，它们分别用于创建任务，删除任务，及触发任务执行。
这些接口的实现如下：
EventTriggerId BasicTaskScheduler0::createEventTrigger(TaskFunc* eventHandlerProc) {unsigned i = fLastUsedTriggerNum;EventTriggerId mask = fLastUsedTriggerMask;do {i = (i+1)%MAX_NUM_EVENT_TRIGGERS;mask >>= 1;if (mask == 0) mask = 0x80000000;if (fTriggeredEventHandlers[i] == NULL) {// This trigger number is free; use it:fTriggeredEventHandlers[i] = eventHandlerProc;fTriggeredEventClientDatas[i] = NULL; // sanityfLastUsedTriggerMask = mask;fLastUsedTriggerNum = i;return mask;}} while (i != fLastUsedTriggerNum);// All available event triggers are allocated; return 0 instead:return 0;
}void BasicTaskScheduler0::deleteEventTrigger(EventTriggerId eventTriggerId) {fTriggersAwaitingHandling &=~ eventTriggerId;if (eventTriggerId == fLastUsedTriggerMask) { // common-case optimization:fTriggeredEventHandlers[fLastUsedTriggerNum] = NULL;fTriggeredEventClientDatas[fLastUsedTriggerNum] = NULL;} else {// "eventTriggerId" should have just one bit set.// However, we do the reasonable thing if the user happened to 'or' together two or more "EventTriggerId"s:EventTriggerId mask = 0x80000000;for (unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {if ((eventTriggerId&mask) != 0) {fTriggeredEventHandlers[i] = NULL;fTriggeredEventClientDatas[i] = NULL;}mask >>= 1;}}
}void BasicTaskScheduler0::triggerEvent(EventTriggerId eventTriggerId, void* clientData) {// First, record the "clientData". (Note that we allow "eventTriggerId" to be a combination of bits for multiple events.)EventTriggerId mask = 0x80000000;for (unsigned i = 0; i < MAX_NUM_EVENT_TRIGGERS; ++i) {if ((eventTriggerId&mask) != 0) {fTriggeredEventClientDatas[i] = clientData;}mask >>= 1;}// Then, note this event as being ready to be handled.// (Note that because this function (unlike others in the library) can be called from an external thread, we do this last, to// reduce the risk of a race condition.)fTriggersAwaitingHandling |= eventTriggerId;
}BasicTaskScheduler0 的 fTriggeredEventHandlers 和 fTriggeredEventClientDatas 用于保存任务本身，它们分别保存任务主体函数，以及执行任务时传入的用户数据。它们都是数组，每个任务占用一个元素，相同索引处的元素属于同一个任务。数组的长度为 MAX_NUM_EVENT_TRIGGERS，即 32，也就是说最多可以创建的任务的个数为 32。
fTriggersAwaitingHandling 用于记录当前触发了哪些任务。每个任务的触发状态都对应于其中的一个位，当对应的位置 1 时，表示任务被触发，需要执行；反之则不需要执行。比如 fTriggeredEventHandlers 和 fTriggeredEventClientDatas 中索引 0 处的任务的触发状态，对应于 fTriggersAwaitingHandling 的最高位，索引 1 处的任务的触发状态，对应于次高位，依次类推。
创建任务，即是在 fTriggeredEventHandlers 和 fTriggeredEventClientDatas 中为任务找到一个空闲的位置，把任务的主体函数的指针保存起来，返回任务的索引在 fTriggersAwaitingHandling 中的对应位的掩码，作为任务的标识。fLastUsedTriggerNum 用于防止遍历 fTriggeredEventHandlers 查找时的无限循环。
删除任务即是移除任务相关的所有数据，包括复位 fTriggersAwaitingHandling 中的触发状态，以及 fTriggeredEventHandlers 和 fTriggeredEventClientDatas 中任务的主体函数指针和用户数据。
触发事件任务则是置为任务在 fTriggersAwaitingHandling 中对应的位，并设置任务数据。任务的实际执行同样需要在事件循环中执行。
事件循环执行框架
BasicTaskScheduler0 中执行事件循环由 doEventLoop() 函数完成，具体实现如下：
void BasicTaskScheduler0::doEventLoop(char volatile* watchVariable) {// Repeatedly loop, handling readble sockets and timed events:while (1) {if (watchVariable != NULL && *watchVariable != 0) break;SingleStep();}
}主要特别关注的是传入的参数 watchVariable：调用者可以通过这个参数，来在事件循环的外部控制，事件循环何时结束。
Socket I/O 事件描述及其组织
BasicUsageEnvironment 模块中，用 HandlerDescriptor 描述要监听的 socket 上的事件及事件发生时的处理程序，该类定义如下：
class HandlerDescriptor {HandlerDescriptor(HandlerDescriptor* nextHandler);virtual ~HandlerDescriptor();public:int socketNum;int conditionSet;TaskScheduler::BackgroundHandlerProc* handlerProc;void* clientData;private:// Descriptors are linked together in a doubly-linked list:friend class HandlerSet;friend class HandlerIterator;HandlerDescriptor* fNextHandler;HandlerDescriptor* fPrevHandler;
};socketNum 为要监听的 socket，conditionSet 描述要监听的 socket 上的事件，handlerProc 为事件发生时的处理程序，clientData 为传递给事件处理程序的用户数据。而 fNextHandler 和 fPrevHandler 则用于将
HandlerDescriptor 组织起来。不难猜到，BasicUsageEnvironment 模块中 HandlerDescriptor 也是要被组织为双向链表的。
HandlerDescriptor 类的实现如下：
HandlerDescriptor::HandlerDescriptor(HandlerDescriptor* nextHandler): conditionSet(0), handlerProc(NULL) {// Link this descriptor into a doubly-linked list:if (nextHandler == this) { // initializationfNextHandler = fPrevHandler = this;} else {fNextHandler = nextHandler;fPrevHandler = nextHandler->fPrevHandler;nextHandler->fPrevHandler = this;fPrevHandler->fNextHandler = this;}
}HandlerDescriptor::~HandlerDescriptor() {// Unlink this descriptor from a doubly-linked list:fNextHandler->fPrevHandler = fPrevHandler;fPrevHandler->fNextHandler = fNextHandler;
}BasicUsageEnvironment 模块中，使用 HandlerSet 来维护所有的 HandlerDescriptor，这个类的定义如下：
class HandlerSet {
public:HandlerSet();virtual ~HandlerSet();void assignHandler(int socketNum, int conditionSet, TaskScheduler::BackgroundHandlerProc* handlerProc, void* clientData);void clearHandler(int socketNum);void moveHandler(int oldSocketNum, int newSocketNum);private:HandlerDescriptor* lookupHandler(int socketNum);private:friend class HandlerIterator;HandlerDescriptor fHandlers;
};HandlerSet/HandlerDescriptor 的设计与 DelayQueue/DelayQueueEntry 的设计非常相似。HandlerSet 的实现如下：
HandlerSet::HandlerSet(): fHandlers(&fHandlers) {fHandlers.socketNum = -1; // shouldn't ever get looked at, but in case...
}HandlerSet::~HandlerSet() {// Delete each handler descriptor:while (fHandlers.fNextHandler != &fHandlers) {delete fHandlers.fNextHandler; // changes fHandlers->fNextHandler}
}void HandlerSet
::assignHandler(int socketNum, int conditionSet, TaskScheduler::BackgroundHandlerProc* handlerProc, void* clientData) {// First, see if there's already a handler for this socket:HandlerDescriptor* handler = lookupHandler(socketNum);if (handler == NULL) { // No existing handler, so create a new descr:handler = new HandlerDescriptor(fHandlers.fNextHandler);handler->socketNum = socketNum;}handler->conditionSet = conditionSet;handler->handlerProc = handlerProc;handler->clientData = clientData;
}void HandlerSet::clearHandler(int socketNum) {HandlerDescriptor* handler = lookupHandler(socketNum);delete handler;
}void HandlerSet::moveHandler(int oldSocketNum, int newSocketNum) {HandlerDescriptor* handler = lookupHandler(oldSocketNum);if (handler != NULL) {handler->socketNum = newSocketNum;}
}HandlerDescriptor* HandlerSet::lookupHandler(int socketNum) {HandlerDescriptor* handler;HandlerIterator iter(*this);while ((handler = iter.next()) != NULL) {if (handler->socketNum == socketNum) break;}return handler;
}HandlerSet 类似地，被设计为 HandlerDescriptor 的双向循环列表，只是其中的元素的顺序没有意义。
BasicUsageEnvironment 模块还提供了迭代器 HandlerIterator，用于遍历HandlerSet ，其定义及实现如下：
class HandlerIterator {
public:HandlerIterator(HandlerSet& handlerSet);virtual ~HandlerIterator();HandlerDescriptor* next(); // returns NULL if nonevoid reset();private:HandlerSet& fOurSet;HandlerDescriptor* fNextPtr;
};///////////////////////////////////// Implementation
HandlerIterator::HandlerIterator(HandlerSet& handlerSet): fOurSet(handlerSet) {reset();
}HandlerIterator::~HandlerIterator() {
}void HandlerIterator::reset() {fNextPtr = fOurSet.fHandlers.fNextHandler;
}HandlerDescriptor* HandlerIterator::next() {HandlerDescriptor* result = fNextPtr;if (result == &fOurSet.fHandlers) { // no moreresult = NULL;} else {fNextPtr = fNextPtr->fNextHandler;}return result;
}总结一下，可以监听每个 socket 上的事件，并在事件发生时执行处理程序，监听的 socket 上的事件及事件处理程序由 HandlerDescriptor 描述；所有的 HandlerDescriptor 由 HandlerSet 组织为一个双向的循环链表，元素之间的实际顺序没有意义，新加入的元素被放在逻辑上的链表头部。
Socket I/O 事件处理任务调度
Socket I/O 事件处理任务调度都在 BasicTaskScheduler 类中完成，这个类的定义如下：
class BasicTaskScheduler: public BasicTaskScheduler0 {
public:static BasicTaskScheduler* createNew(unsigned maxSchedulerGranularity = 10000/*microseconds*/);virtual ~BasicTaskScheduler();protected:BasicTaskScheduler(unsigned maxSchedulerGranularity);// called only by "createNew()"static void schedulerTickTask(void* clientData);void schedulerTickTask();protected:// Redefined virtual functions:virtual void SingleStep(unsigned maxDelayTime);virtual void setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc* handlerProc, void* clientData);virtual void moveSocketHandling(int oldSocketNum, int newSocketNum);protected:// To implement background reads:HandlerSet* fHandlers;int fLastHandledSocketNum;unsigned fMaxSchedulerGranularity;// To implement background operations:int fMaxNumSockets;fd_set fReadSet;fd_set fWriteSet;fd_set fExceptionSet;
. . . . . .
};fHandlers 用于组织 HandlerDescriptor，fReadSet、fWriteSet、fExceptionSet 和 fMaxNumSockets 主要是为了适配 select() 接口，分别用于描述要监听其可读事件、可写事件、异常事件的 socket 集合，以及要监听的 socket 中 socket number 最大的那个。
Socket I/O 事件处理任务调度，由 setBackgroundHandling() 和 moveSocketHandling() 这两个函数完成，它们的实现如下：
void BasicTaskScheduler::setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc* handlerProc, void* clientData) {if (socketNum < 0) return;
#if !defined(__WIN32__) && !defined(_WIN32) && defined(FD_SETSIZE)if (socketNum >= (int)(FD_SETSIZE)) return;
#endifFD_CLR((unsigned)socketNum, &fReadSet);FD_CLR((unsigned)socketNum, &fWriteSet);FD_CLR((unsigned)socketNum, &fExceptionSet);if (conditionSet == 0) {fHandlers->clearHandler(socketNum);if (socketNum+1 == fMaxNumSockets) {--fMaxNumSockets;}} else {fHandlers->assignHandler(socketNum, conditionSet, handlerProc, clientData);if (socketNum+1 > fMaxNumSockets) {fMaxNumSockets = socketNum+1;}if (conditionSet&SOCKET_READABLE) FD_SET((unsigned)socketNum, &fReadSet);if (conditionSet&SOCKET_WRITABLE) FD_SET((unsigned)socketNum, &fWriteSet);if (conditionSet&SOCKET_EXCEPTION) FD_SET((unsigned)socketNum, &fExceptionSet);}
}void BasicTaskScheduler::moveSocketHandling(int oldSocketNum, int newSocketNum) {if (oldSocketNum < 0 || newSocketNum < 0) return; // sanity check
#if !defined(__WIN32__) && !defined(_WIN32) && defined(FD_SETSIZE)if (oldSocketNum >= (int)(FD_SETSIZE) || newSocketNum >= (int)(FD_SETSIZE)) return; // sanity check
#endifif (FD_ISSET(oldSocketNum, &fReadSet)) {FD_CLR((unsigned)oldSocketNum, &fReadSet); FD_SET((unsigned)newSocketNum, &fReadSet);}if (FD_ISSET(oldSocketNum, &fWriteSet)) {FD_CLR((unsigned)oldSocketNum, &fWriteSet); FD_SET((unsigned)newSocketNum, &fWriteSet);}if (FD_ISSET(oldSocketNum, &fExceptionSet)) {FD_CLR((unsigned)oldSocketNum, &fExceptionSet); FD_SET((unsigned)newSocketNum, &fExceptionSet);}fHandlers->moveHandler(oldSocketNum, newSocketNum);if (oldSocketNum+1 == fMaxNumSockets) {--fMaxNumSockets;}if (newSocketNum+1 > fMaxNumSockets) {fMaxNumSockets = newSocketNum+1;}
}对于 setBackgroundHandling()，当 conditionSet 为非 0 值时，会更新或者新建对特定 socket 的监听；为 0 时，则将清除对该 socket 的监听。 moveSocketHandling() 更新对于 socket 事件的监听。
BasicTaskScheduler 的 SingleStep() 实现事件循环的单次迭代：
void BasicTaskScheduler::SingleStep(unsigned maxDelayTime) {fd_set readSet = fReadSet; // make a copy for this select() callfd_set writeSet = fWriteSet; // dittofd_set exceptionSet = fExceptionSet; // dittoDelayInterval const& timeToDelay = fDelayQueue.timeToNextAlarm();struct timeval tv_timeToDelay;tv_timeToDelay.tv_sec = timeToDelay.seconds();tv_timeToDelay.tv_usec = timeToDelay.useconds();// Very large "tv_sec" values cause select() to fail.// Don't make it any larger than 1 million seconds (11.5 days)const long MAX_TV_SEC = MILLION;if (tv_timeToDelay.tv_sec > MAX_TV_SEC) {tv_timeToDelay.tv_sec = MAX_TV_SEC;}// Also check our "maxDelayTime" parameter (if it's > 0):if (maxDelayTime > 0 &&(tv_timeToDelay.tv_sec > (long)maxDelayTime/MILLION ||(tv_timeToDelay.tv_sec == (long)maxDelayTime/MILLION &&tv_timeToDelay.tv_usec > (long)maxDelayTime%MILLION))) {tv_timeToDelay.tv_sec = maxDelayTime/MILLION;tv_timeToDelay.tv_usec = maxDelayTime%MILLION;}int selectResult = select(fMaxNumSockets, &readSet, &writeSet, &exceptionSet, &tv_timeToDelay);if (selectResult < 0) {
#if defined(__WIN32__) || defined(_WIN32)int err = WSAGetLastError();// For some unknown reason, select() in Windoze sometimes fails with WSAEINVAL if// it was called with no entries set in "readSet". If this happens, ignore it:if (err == WSAEINVAL && readSet.fd_count == 0) {err = EINTR;// To stop this from happening again, create a dummy socket:if (fDummySocketNum >= 0) closeSocket(fDummySocketNum);fDummySocketNum = socket(AF_INET, SOCK_DGRAM, 0);FD_SET((unsigned)fDummySocketNum, &fReadSet);}if (err != EINTR) {
#elseif (errno != EINTR && errno != EAGAIN) {
#endif// Unexpected error - treat this as fatal:
#if !defined(_WIN32_WCE)perror("BasicTaskScheduler::SingleStep(): select() fails");// Because this failure is often "Bad file descriptor" - which is caused by an invalid socket number (i.e., a socket number// that had already been closed) being used in "select()" - we print out the sockets that were being used in "select()",// to assist in debugging:fprintf(stderr, "socket numbers used in the select() call:");for (int i = 0; i < 10000; ++i) {if (FD_ISSET(i, &fReadSet) || FD_ISSET(i, &fWriteSet) || FD_ISSET(i, &fExceptionSet)) {fprintf(stderr, " %d(", i);if (FD_ISSET(i, &fReadSet)) fprintf(stderr, "r");if (FD_ISSET(i, &fWriteSet)) fprintf(stderr, "w");if (FD_ISSET(i, &fExceptionSet)) fprintf(stderr, "e");fprintf(stderr, ")");}}fprintf(stderr, "\n");
#endifinternalError();}}// Call the handler function for one readable socket:HandlerIterator iter(*fHandlers);HandlerDescriptor* handler;// To ensure forward progress through the handlers, begin past the last// socket number that we handled:if (fLastHandledSocketNum >= 0) {while ((handler = iter.next()) != NULL) {if (handler->socketNum == fLastHandledSocketNum) break;}if (handler == NULL) {fLastHandledSocketNum = -1;iter.reset(); // start from the beginning instead}}while ((handler = iter.next()) != NULL) {int sock = handler->socketNum; // aliasint resultConditionSet = 0;if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE;if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE;if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION;if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) {fLastHandledSocketNum = sock;// Note: we set "fLastHandledSocketNum" before calling the handler,// in case the handler calls "doEventLoop()" reentrantly.(*handler->handlerProc)(handler->clientData, resultConditionSet);break;}}if (handler == NULL && fLastHandledSocketNum >= 0) {// We didn't call a handler, but we didn't get to check all of them,// so try again from the beginning:iter.reset();while ((handler = iter.next()) != NULL) {int sock = handler->socketNum; // aliasint resultConditionSet = 0;if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE;if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE;if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION;if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) {fLastHandledSocketNum = sock;// Note: we set "fLastHandledSocketNum" before calling the handler,// in case the handler calls "doEventLoop()" reentrantly.(*handler->handlerProc)(handler->clientData, resultConditionSet);break;}}if (handler == NULL) fLastHandledSocketNum = -1;//because we didn't call a handler}// Also handle any newly-triggered event (Note that we do this *after* calling a socket handler,// in case the triggered event handler modifies The set of readable sockets.)if (fTriggersAwaitingHandling != 0) {if (fTriggersAwaitingHandling == fLastUsedTriggerMask) {// Common-case optimization for a single event trigger:fTriggersAwaitingHandling &=~ fLastUsedTriggerMask;if (fTriggeredEventHandlers[fLastUsedTriggerNum] != NULL) {(*fTriggeredEventHandlers[fLastUsedTriggerNum])(fTriggeredEventClientDatas[fLastUsedTriggerNum]);}} else {// Look for an event trigger that needs handling (making sure that we make forward progress through all possible triggers):unsigned i = fLastUsedTriggerNum;EventTriggerId mask = fLastUsedTriggerMask;do {i = (i+1)%MAX_NUM_EVENT_TRIGGERS;mask >>= 1;if (mask == 0) mask = 0x80000000;if ((fTriggersAwaitingHandling&mask) != 0) {fTriggersAwaitingHandling &=~ mask;if (fTriggeredEventHandlers[i] != NULL) {(*fTriggeredEventHandlers[i])(fTriggeredEventClientDatas[i]);}fLastUsedTriggerMask = mask;fLastUsedTriggerNum = i;break;}} while (i != fLastUsedTriggerNum);}}// Also handle any delayed event that may have come due.fDelayQueue.handleAlarm();
}这个函数有点长，但清晰地分为如下几个部分：
1. 根据定时器任务列表中，距当前时间最近的任务所需执行的时间点以及传入的最大延迟时间，计算 select() 所能够等待地最长时间。
2. 执行 select() 等待 socket 上的时间。
3. select() 超时或某个 socket 上的 I/O 事件到来，首先执行发生 I/O 事件的 socket 的 I/O 事件处理程序。这个函数一次最多执行一个 socket 上的 I/O 处理程序。
4. 执行用户事件处理程序。也是一次最多执行一个。
5. 执行定时器任务，同样是一次最多执行一个。
live555 的基础设施基本上就是这些了。
live555 源码分析系列文章
live555 源码分析：简介
live555 源码分析：基础设施
live555 源码分析：基础设施相关推荐
- live555 源码分析：播放启动
本文分析 live555 中,流媒体播放启动,数据开始通过 RTP/RTCP 传输的过程. 如我们在 live555 源码分析:子会话 SETUP 中看到的,一个流媒体子会话的播放启动,由 Strea ...
- live555 源码分析：子会话 SDP 行生成
如我们在前文 live555 源码分析:ServerMediaSession 中看到的,H264VideoFileServerMediaSubsession 的继承层次体系如下图: 在这个继承层次体系 ...
- live555 源码分析：ServerMediaSession
在 live555 中,用一个 ServerMediaSession 表示流媒体会话,它连接了 RTSPServer 和下层流媒体传输逻辑.ServerMediaSession 和 ServerMed ...
- live555 源码分析：RTSPServer 组件结构
前面几篇文章分析了 live555 中 RTSP 的处理逻辑,RTSP 处理有关组件的处理逻辑有点复杂,本文就再来梳理一下它们之间的关系. live555 中 RTSP 处理有关组件关系如下图: 事件 ...
- live555 源码分析： PLAY 的处理
在 SETUP 请求之后,客户端会发起 PLAY 请求,以请求服务器开始传输音视频数据.在 PLAY 请求执行时,一定是已经执行过 SETUP 请求,建立好了客户端会话,因而会与其它要求客户端会话已经 ...
- live555 源码分析： SETUP 的处理
SETUP 请求在 RTSP 的整个工作流程中,用于建立流媒体会话.本文分析 live555 对 SETUP 请求的处理. 在 RTSPServer::RTSPClientConnection::ha ...
- live555 源码分析： DESCRIBE 的处理
前面在 live555 源码分析:RTSPServer 中分析了 live555 中处理 RTSP 请求的大体流程,并分析了处理起来没有那么复杂的一些方法,如 OPTIONS,GET_PARAMETE ...
- live555 源码分析：MediaSever
位于 live555 项目 mediaServer 目录下的是 "LIVE555 Media Server",它是一个完整的 RTSP 服务器应用程序.它可以把多种媒体文件转为流, ...
- live555 源码分析：RTSPServer
live555 使用 RTSP/RTP/RTCP 协议来实现流媒体的传输,其中使用 RTSP 来建立流媒体会话,并对流媒体会话进行控制.在 live555 中,通过类 RTSPServerSuppor ...
最新文章
- 使用WinSCP在WIndows与树莓派之间传递文件
- cmakelist 定义变量
- 晨读打卡（2018.1）
- mysql 复杂sql 面试_PHP面试之复杂MySQL语句的编写
- Storm【技术文档】-Worker Executor Task的关系
- 一个按钮触发多个a标签，只有一个可以下载，其他的window.open()被浏览器拦截...
- Netty的ChannelFuture和ChannelPromise
- 线程池框架-Executor
- python批量音频转格式_GitHub - shede333/SWConvertVideoToAudio: Python批量转换 视频 为 音频MP3（即提取音频文件）...
- java历save_日历【savejava吧】_百度贴吧
- Confluence 6 配置数字格式
- GBase 8a 报错gbase_forward_result failed to write result for client
- jedate时间插件
- CorelDRAW2021序列号 专业的矢量图像设计软件
- ZC公司员工评分系统——前台排版算法
- 安信可 Telink_825x 环境搭建
- c 语言 随机值的生成器,C 语言随机数生成器的实现分析
- StackMap属性解析
- 【转载】设计之路：如何进行软件需求分析？
- three.js textureLoader加载图片失败
热门文章
- 学计算机所需要的英语单词,学计算机最少要懂的英语单词是什么
- 卡写入保护开关原理_老电工带你解密：插卡取电开关
- Java8函数式编程（5）--中间操作（源码）
- 如何在 Windows 上安装多个 MySQL，实现 MySQL 跨电脑移植使用
- pd.get_dummies()
- 【报错笔记】sturts2程序运行出现错误：Struts has detected an unhandled exception
- 变量的定于[指针/函数指针]
- ubuntu18.04 VirtualBox 开启虚拟机出错 Kernel driver not installed (rc=-1908)
- 人工智能化发展已经到了哪一步？
- 国内传感器市场也许正处在最好的时候