对ACE锁、条件变量、信号量在windows和linux平台下的测试
Windows版本
1 ACE_Thread_Mutex
场景1：
4836 ACE_Thread_Mutex::acquire ret 0 [202049422-202049422].
1504 ACE_Thread_Mutex::acquire ret 0 [202049422-202049522].
4836 ACE_Thread_Mutex::release ret 0 [202049522-202049523].
1504 ACE_Thread_Mutex::release ret 0 [202049725-202049725].
上面日志的字段为：“线程id 调用函数 ret 返回值 [调用开始时间-调用返回时间]”。
两个线程分别在同一个锁上调用acquire和release，4836号线程先取到锁，导致1504阻塞在锁上，4836号线程释放锁后，1504号线程成功取得锁并再次释放。
场景2：
1964 ACE_Thread_Mutex::acquire ret 0 [205149805-205149805].
1964 ACE_Thread_Mutex::release ret 0 [205149995-205149995].
1964 ACE_Thread_Mutex::release ret 0 [205149995-205149995].
1964 ACE_Thread_Mutex::acquire ret -858993460 [205149995-0].
同一个线程在多释放锁一次后，再获取锁将不能获取到，即必须先acquire才release。（返回值ret=-858993460 即还未被赋值，且函数返回时间0表示一直没有返回）
场景3：
4692 ACE_Thread_Mutex::acquire ret 0 [259482795-259482795].
4692 ACE_Thread_Mutex::acquire ret 0 [259482795-259482795].
4692 ACE_Thread_Mutex::release ret 0 [259482998-259482998].
4692 ACE_Thread_Mutex::release ret 0 [259482999-259482999].
4692 ACE_Thread_Mutex::acquire ret 0 [259482999-259482999].
同一个线程可以递归获取锁，对应作两次release操作后锁能重新获取。
场景4：
3732 ACE_Thread_Mutex::acquire ret 0 [259529881-259529881].
3732 ACE_Thread_Mutex::acquire ret 0 [259529881-259529881].
3732 ACE_Thread_Mutex::release ret 0 [259530076-259530076].
3732 ACE_Thread_Mutex::acquire ret 0 [259530076-259530076].
同一个线程可以递归获取锁，对应只作一次release操作后锁也能重新获取。
2 ACE_Recurisive_Thread_Mutex
场景1：
3736 ACE_Recursive_Thread_Mutex::acquire ret 0 [260300181-260300181].
972 ACE_Recursive_Thread_Mutex::acquire ret 0 [260300181-260300278].
3736 ACE_Recursive_Thread_Mutex::release ret 0 [260300278-260300278].
972 ACE_Recursive_Thread_Mutex::release ret 0 [260300481-260300481].
两个线程被正确互斥。
场景2：
2704 ACE_Recursive_Thread_Mutex::acquire ret 0 [261788858-261788858].
2704 ACE_Recursive_Thread_Mutex::release ret 0 [261788858-261788858].
2704 ACE_Recursive_Thread_Mutex::release ret 0 [261788858-261788858].
2704 ACE_Recursive_Thread_Mutex::acquire ret -858993460 [261788858-0].
同一个线程在多释放锁一次后，再获取锁将不能获取到，即必须先acquire才release。
场景3：
5796 ACE_Recursive_Thread_Mutex::acquire ret 0 [261849550-261849550].
5796 ACE_Recursive_Thread_Mutex::acquire ret 0 [261849550-261849550].
5796 ACE_Recursive_Thread_Mutex::release ret 0 [261849550-261849550].
5796 ACE_Recursive_Thread_Mutex::release ret 0 [261849550-261849550].
5796 ACE_Recursive_Thread_Mutex::acquire ret 0 [261849550-261849550].
同一个线程可以递归获取锁，对应作两次release操作后锁能重新获取。
场景4：
2360 ACE_Recursive_Thread_Mutex::acquire ret 0 [261909041-261909041].
2360 ACE_Recursive_Thread_Mutex::acquire ret 0 [261909041-261909041].
2360 ACE_Recursive_Thread_Mutex::release ret 0 [261909041-261909041].
2360 ACE_Recursive_Thread_Mutex::acquire ret 0 [261909041-261909041].
同一个线程可以递归获取锁，对应只作一次release操作后锁也能重新获取。
场景5：
1288 ACE_Recursive_Thread_Mutex::acquire ret 0 [262687754-262687754].
1288 ACE_Recursive_Thread_Mutex::acquire ret 0 [262687754-262687754].
1288 ACE_Recursive_Thread_Mutex::release ret 0 [262687754-262687754].
4632 ACE_Recursive_Thread_Mutex::acquire ret -858993460 [262687949-0].
线程1获取了两次锁，只释放一次，线程2就不能再获取到锁。
3 ACE_RW_Thread_Mutex
场景1：
5152 ACE_RW_Thread_Mutex::acquire_read ret 0 [266218165-266218165].
5644 ACE_RW_Thread_Mutex::acquire_read ret 0 [266218165-266218165].
5644 ACE_RW_Thread_Mutex::release ret 0 [266218265-266218265].
5152 ACE_RW_Thread_Mutex::release ret 0 [266218364-266218364].
两个线程同时获取到了读锁。
场景2：
4252 ACE_RW_Thread_Mutex::acquire_read ret 0 [267329773-267329773].
1944 ACE_RW_Thread_Mutex::acquire_write ret 0 [267329873-267329973].
4252 ACE_RW_Thread_Mutex::release ret 0 [267329973-267329973].
1944 ACE_RW_Thread_Mutex::release ret 0 [267330073-267330073].
一个线程先取到了读锁，另一个线程需要等读锁释放后才能取到写锁。
场景3：
4872 ACE_RW_Thread_Mutex::acquire_write ret 0 [267685974-267685974].
2688 ACE_RW_Thread_Mutex::acquire_read ret 0 [267686077-267686174].
4872 ACE_RW_Thread_Mutex::release ret 0 [267686174-267686174].
2688 ACE_RW_Thread_Mutex::release ret 0 [267686275-267686275].
一个线程先取到了写锁，另一个线程需要等写锁释放后才能取到读锁。
场景4：
3736 ACE_RW_Thread_Mutex::acquire_write ret 0 [267891134-267891134].
3736 ACE_RW_Thread_Mutex::acquire_write ret -858993460 [267891134-0].
一个线程递归获取写锁，第二次获取失败。
场景5：
3444 ACE_RW_Thread_Mutex::acquire_write ret 0 [288615252-288615252].
3444 ACE_RW_Thread_Mutex::release ret 0 [288615252-288615252].
3444 ACE_RW_Thread_Mutex::release ret -1 [288615252-288615252].
3444 ACE_RW_Thread_Mutex::acquire_write ret 0 [288615252-288615252].
同一个线程在多释放锁一次后，第二次释放锁将失败，后面可以再次获取锁。
场景6：
5868 ACE_RW_Thread_Mutex::acquire_read ret 0 [268028166-268028166].
5868 ACE_RW_Thread_Mutex::acquire_read ret 0 [268028166-268028166].
5868 ACE_RW_Thread_Mutex::release ret 0 [268028166-268028166].
5868 ACE_RW_Thread_Mutex::release ret 0 [268028166-268028166].
一个线程递归获取读锁，都能获取成功。
场景7：
1392 ACE_RW_Thread_Mutex::acquire_read ret 0 [268151603-268151604].
1392 ACE_RW_Thread_Mutex::acquire_read ret 0 [268151604-268151604].
1392 ACE_RW_Thread_Mutex::release ret 0 [268151604-268151604].
1392 ACE_RW_Thread_Mutex::acquire_write ret -858993460 [268151604-0].
一个线程获取两次读锁，但只释放一次，下次不能再获取写锁。
场景8：
5976 ACE_RW_Thread_Mutex::acquire_read ret 0 [268271297-268271297].
5976 ACE_RW_Thread_Mutex::acquire_read ret 0 [268271297-268271297].
5976 ACE_RW_Thread_Mutex::release ret 0 [268271297-268271297].
5976 ACE_RW_Thread_Mutex::release ret 0 [268271297-268271297].
5976 ACE_RW_Thread_Mutex::acquire_write ret 0 [268271297-268271297].
一个线程获取两次读锁，同时也释放两次，下次可以再获取写锁。
场景9：
6060 ACE_RW_Thread_Mutex::acquire_read ret 0 [269059556-269059556].
6060 ACE_RW_Thread_Mutex::release ret 0 [269059556-269059556].
6060 ACE_RW_Thread_Mutex::release ret -1 [269059556-269059556].
6060 ACE_RW_Thread_Mutex::acquire_write ret 0 [269059556-269059556].
一个线程获取了一次读锁，并作两次释放，第二次释放返回失败，后面可以再次获取写锁。
场景10：
5776 ACE_RW_Thread_Mutex::acquire_read ret 0 [268663665-268663665].
5464 ACE_RW_Thread_Mutex::acquire_write ret -858993460 [268663766-0].
1392 ACE_RW_Thread_Mutex::acquire_read ret -858993460 [268663865-0].
一个线程获取了读锁，第二个线程再获取写锁失败，这时第三个线程再获取读锁也失败。
场景11：
4604 ACE_RW_Thread_Mutex::acquire_read ret 0 [268828615-268828615].
5096 ACE_RW_Thread_Mutex::acquire_read ret 0 [268828715-268828715].
5096 ACE_RW_Thread_Mutex::release ret 0 [268828715-268828715].
4540 ACE_RW_Thread_Mutex::acquire_write ret -858993460 [268828815-0].
第一个线程先获取到读锁，第二个线程可以再次获取读锁并成功释放，第三个线程阻塞在写锁获取上。
4 ACE_Condition
场景1：
284 ACE_Condition
2392 ACE_Condition
第一个线程等待，直到第二个线程signal后返回。
场景2：
3360 ACE_Condition
1392 ACE_Condition
第一个线程先signal，第二个线程再wait将不会退出。
场景3：
1980 ACE_Condition
2364 ACE_Condition
1980 ACE_Condition
第一个线程先signal，第二个线程wait后不能退出，直到第一个线程再次signal。
场景4：
284 ACE_Condition
2228 ACE_Condition
3156 ACE_Condition
两个线程进入wait，一个线程signal后只有一个线程wait成功返回。
场景5：
4712 ACE_Condition
5564 ACE_Condition
4900 ACE_Condition
两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。
场景6：
4024 ACE_Thread_Mutex::acquire ret 0 [280876758-280876758].
4024 ACE_Thread_Mutex::acquire ret 0 [280876758-280876758].
4024 ACE_Condition
2344 ACE_Thread_Mutex::acquire ret -858993460 [280876958-0].
第一个线程递归获取了锁，并进入wait，这时候第二个线程无法在获取锁从而不能再调用signal，最终wait不能返回。
5 ACE_Condition
场景1：
4564 ACE_Condition
4288 ACE_Condition
线程一进入wait等待，线程二signal后，线程一wait退出。
场景2：
4812 ACE_Condition
5060 ACE_Condition
4672 ACE_Condition
两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。
场景3：
1252 ACE_Condition
3732 ACE_Condition
第一个线程先signal，第二个线程再wait将不会退出。
场景4：
3844 ACE_Recursive_Thread_Mutex::acquire ret 0 [279037760-279037760].
3844 ACE_Recursive_Thread_Mutex::acquire ret 0 [279037760-279037760].
3844 ACE_Condition
2344 ACE_Recursive_Thread_Mutex::acquire ret 0 [279037959-279037959].
2344 ACE_Condition
2344 ACE_Recursive_Thread_Mutex::release ret 0 [279037959-279037959].
3844 ACE_Recursive_Thread_Mutex::release ret 0 [279037959-279037959].
3844 ACE_Recursive_Thread_Mutex::release ret 0 [279037959-279037959].
wait线程递归获取了锁，signal线程能再度获取递归锁并调用signal唤醒wait线程。
注意：最后三个release第一个必定是signal线程的release退出后，wait线程才从wait函数退出并调用了两次release。
场景5：
5872 ACE_Recursive_Thread_Mutex::acquire ret 0 [280468179-280468179].
5872 ACE_Condition
1928 ACE_Recursive_Thread_Mutex::acquire ret 0 [280468379-280468379].
1928 ACE_Recursive_Thread_Mutex::acquire ret 0 [280468379-280468379].
1928 ACE_Condition
1928 ACE_Recursive_Thread_Mutex::release ret 0 [280468379-280468379].
1928 ACE_Recursive_Thread_Mutex::release ret 0 [280468580-280468580].
5872 ACE_Recursive_Thread_Mutex::release ret 0 [280468580-280468580].
第一个线程进入wait，signal线程先递归获取了锁再执行signal唤醒wait线程。
注意：wait线程的退出时间和signal线程第二个release函数退出时间相同，即等到递归锁完全释放后wait才退出。
6 ACE_Thread_Semaphore
场景1：
4164 ACE_Thread_Semaphore::acquire ret 0 [281586930-281586930].
4164 ACE_Thread_Semaphore::acquire ret -858993460 [281586930-0].
初始化信号量个数为1，第一次获取成功，第二次获取失败。
场景2：
4444 ACE_Thread_Semaphore::acquire ret 0 [281660164-281660164].
4444 ACE_Thread_Semaphore::acquire ret 0 [281660164-281660164].
初始化信号量个数为2，两次都获取成功。
场景3：
4248 ACE_Thread_Semaphore::release ret 0 [281777040-281777040].
4248 ACE_Thread_Semaphore::acquire ret 0 [281777040-281777040].
初始化信号量个数为1，先释放后获取可以成功。
场景4：
4248 ACE_Thread_Semaphore::release ret 0 [281777040-281777040].
4248 ACE_Thread_Semaphore::acquire ret 0 [281777040-281777040].
初始化信号量个数为0，先释放后获取可以成功。
场景5：
5632 ACE_Thread_Semaphore::acquire ret -858993460 [281980817-0].
初始化信号量个数为0，获取失败。
场景6：
860 ACE_Thread_Semaphore::acquire ret 0 [282219122-282219122].
860 ACE_Thread_Semaphore::acquire ret 0 [282219122-282219321].
2808 ACE_Thread_Semaphore::release ret 0 [282219321-282219321].
初始化信号量个数为1，第一次获取直接成功，第二次获取需要等到另一个线程release后才成功。
linux版本
7 ACE_Thread_Mutex
场景1：
-1208547632 ACE_Thread_Mutex::acquire ret 0 [62491626-62491626].
-1219040368 ACE_Thread_Mutex::acquire ret 0 [62491626-62491826].
-1208547632 ACE_Thread_Mutex::release ret 0 [62491826-62491826].
-1219040368 ACE_Thread_Mutex::release ret 0 [62491927-62491927].
上面日志的字段为：“线程id 调用函数 返回值 [调用开始时间-调用结束时间]”。
两个线程分别在同一个锁上调用acquire和release，4836号线程先取到锁，导致1504阻塞在锁上，4836号线程释放锁后，1504号线程成功取得锁并再次释放。
场景2：
-1208252720 ACE_Thread_Mutex::acquire ret 0 [62398698-62398698].
-1208252720 ACE_Thread_Mutex::release ret 0 [62398698-62398698].
-1208252720 ACE_Thread_Mutex::release ret 0 [62398698-62398698].
-1208252720 ACE_Thread_Mutex::acquire ret 0 [62398698-62398698].
同一个线程在多释放锁一次后，再获取锁也能获取到。
注意：和windows版本表现不一样。
场景3：
-1208895792 ACE_Thread_Mutex::acquire ret 0 [62300935-62300935].
-1208895792 ACE_Thread_Mutex::acquire ret 5513204 [62300935-0].
同一个线程不能递归获取锁。
注意：和windows版本表现不一样。
8 ACE_Recurisive_Thread_Mutex
场景1：
-1208457520 ACE_Recursive_Thread_Mutex::acquire ret 0 [62216406-62216406].
-1218950256 ACE_Recursive_Thread_Mutex::acquire ret 0 [62216406-62216507].
-1208457520 ACE_Recursive_Thread_Mutex::release ret 0 [62216507-62216507].
-1218950256 ACE_Recursive_Thread_Mutex::release ret 0 [62216608-62216608].
两个线程被正确互斥。
场景2：
-1208678704 ACE_Recursive_Thread_Mutex::acquire ret 0 [62024570-62024570].
-1208678704 ACE_Recursive_Thread_Mutex::release ret 0 [62024570-62024570].
-1208678704 ACE_Recursive_Thread_Mutex::release ret -1 [62024570-62024570].
-1208678704 ACE_Recursive_Thread_Mutex::acquire ret 0 [62024570-62024570].
同一个线程在多释放锁一次后，第二次不能成功释放，后面可以再次获取锁。
注意：和windows版本表现不一样。
场景3：
-1208686896 ACE_Recursive_Thread_Mutex::acquire ret 0 [61983266-61983266].
-1208686896 ACE_Recursive_Thread_Mutex::acquire ret 0 [61983266-61983266].
-1208686896 ACE_Recursive_Thread_Mutex::release ret 0 [61983266-61983266].
-1208686896 ACE_Recursive_Thread_Mutex::release ret 0 [61983266-61983266].
-1208686896 ACE_Recursive_Thread_Mutex::acquire ret 0 [61983266-61983266].
同一个线程可以递归获取锁，对应作两次release操作后锁能重新获取。
场景4：
-1209051440 ACE_Recursive_Thread_Mutex::acquire ret 0 [61913407-61913407].
-1209051440 ACE_Recursive_Thread_Mutex::acquire ret 0 [61913407-61913407].
-1209051440 ACE_Recursive_Thread_Mutex::release ret 0 [61913407-61913407].
-1209051440 ACE_Recursive_Thread_Mutex::acquire ret 0 [61913407-61913407].
同一个线程可以递归获取锁，对应只作一次release操作后锁也能重新获取。
场景5：
-1208592688 ACE_Recursive_Thread_Mutex::acquire ret 0 [61754929-61754929].
-1208592688 ACE_Recursive_Thread_Mutex::acquire ret 0 [61754929-61754929].
-1208592688 ACE_Recursive_Thread_Mutex::release ret 0 [61754929-61754929].
-1219085424 ACE_Recursive_Thread_Mutex::acquire ret 200000000 [61755130-0].
线程1获取了两次锁，只释放一次，线程2就不能再获取到锁。
9 ACE_RW_Thread_Mutex
场景1：
-1208420656 ACE_RW_Thread_Mutex::acquire_read ret 0 [60848949-60848949].
-1218913392 ACE_RW_Thread_Mutex::acquire_read ret 0 [60848949-60848949].
-1208420656 ACE_RW_Thread_Mutex::release ret 0 [60849150-60849150].
-1218913392 ACE_RW_Thread_Mutex::release ret 0 [60849150-60849150].
两个线程同时获取到了读锁。
场景2：
-1209006384 ACE_RW_Thread_Mutex::acquire_read ret 0 [60719383-60719383].
-1219499120 ACE_RW_Thread_Mutex::acquire_write ret 0 [60719485-60719585].
-1209006384 ACE_RW_Thread_Mutex::release ret 0 [60719585-60719585].
-1219499120 ACE_RW_Thread_Mutex::release ret 0 [60719585-60719585].
一个线程先取到了读锁，另一个线程需要等读锁释放后才能取到写锁。
场景3：
-1208191280 ACE_RW_Thread_Mutex::acquire_write ret 0 [60780507-60780507].
-1218684016 ACE_RW_Thread_Mutex::acquire_read ret 0 [60780608-60780708].
-1208191280 ACE_RW_Thread_Mutex::release ret 0 [60780708-60780708].
-1218684016 ACE_RW_Thread_Mutex::release ret 0 [60780708-60780708].
一个线程先取到了写锁，另一个线程需要等写锁释放后才能取到读锁。
场景4：
-1208965424 ACE_RW_Thread_Mutex::acquire_write ret 0 [59775905-59775905].
-1208965424 ACE_RW_Thread_Mutex::acquire_write ret -1 [59775905-59775905].
-1208965424 ACE_RW_Thread_Mutex::release ret 0 [59775905-59775905].
-1208965424 ACE_RW_Thread_Mutex::acquire_write ret 0 [59775905-59775905].
一个线程递归获取写锁，第二次获取失败，但第二次获取写锁不会阻塞，后面只需要realease一次即可。
注意：windows下第二次获取写锁将直接阻塞。
场景5：
-1208863024 ACE_RW_Thread_Mutex::acquire_write ret 0 [60440595-60440595].
-1208863024 ACE_RW_Thread_Mutex::release ret 0 [60440595-60440595].
-1208863024 ACE_RW_Thread_Mutex::release ret 0 [60440595-60440595].
-1208863024 ACE_RW_Thread_Mutex::acquire_write ret 11030516 [60440595-0].
同一个线程在多释放锁一次后，再获取锁将不能获取到，即必须先acquire才release。
注意：windows下第二次释放会失败，但可以再次获取写锁。
场景6：
-1208559920 ACE_RW_Thread_Mutex::acquire_read ret 0 [59642253-59642253].
-1208559920 ACE_RW_Thread_Mutex::acquire_read ret 0 [59642253-59642253].
-1208559920 ACE_RW_Thread_Mutex::release ret 0 [59642253-59642253].
-1208559920 ACE_RW_Thread_Mutex::release ret 0 [59642253-59642253].
一个线程递归获取读锁，都能获取成功。
场景7：
-1208457520 ACE_RW_Thread_Mutex::acquire_read ret 0 [59682609-59682609].
-1208457520 ACE_RW_Thread_Mutex::acquire_read ret 0 [59682609-59682609].
-1208457520 ACE_RW_Thread_Mutex::release ret 0 [59682609-59682609].
-1208457520 ACE_RW_Thread_Mutex::acquire_write ret 7036916 [59682609-0].
一个线程获取两次读锁，但只释放一次，下次不能再获取写锁。
场景8：
-1208559920 ACE_RW_Thread_Mutex::acquire_read ret 0 [59642253-59642253].
-1208559920 ACE_RW_Thread_Mutex::acquire_read ret 0 [59642253-59642253].
-1208559920 ACE_RW_Thread_Mutex::release ret 0 [59642253-59642253].
-1208559920 ACE_RW_Thread_Mutex::release ret 0 [59642253-59642253].
-1208559920 ACE_RW_Thread_Mutex::acquire_write ret 0 [59642253-59642253].
一个线程获取两次读锁，同时也释放两次，下次可以再获取写锁。
场景9：
-1208617264 ACE_RW_Thread_Mutex::acquire_write ret 0 [58699428-58699428].
-1208617264 ACE_RW_Thread_Mutex::release ret 0 [58699428-58699428].
-1208617264 ACE_RW_Thread_Mutex::release ret 0 [58699428-58699428].
-1208617264 ACE_RW_Thread_Mutex::acquire_write ret 11030516 [58699428-0].
一个线程获取了一次读锁，并作两次释放，第二次释放返回成功，后面再次获取写锁失败。
注意：这里和windows版本不同，windows下第二次释放失败，但后面可以获取到写锁。
场景10：
-1208813872 ACE_RW_Thread_Mutex::acquire_read ret 0 [59325916-59325916].
-1219306608 ACE_RW_Thread_Mutex::acquire_write ret 100000000 [59326018-0].
-1229796464 ACE_RW_Thread_Mutex::acquire_read ret 0 [59326118-59326118].
-1229796464 ACE_RW_Thread_Mutex::release ret 0 [59326118-59326118].
第一个线程获取了读锁，第二个线程再获取写锁失败，第三个线程再获取读锁可以成功。
注意：windows下第三个线程不能获取到读锁。
场景11：
-1208080688 ACE_RW_Thread_Mutex::acquire_read ret 0 [59025363-59025363].
-1229063280 ACE_RW_Thread_Mutex::acquire_read ret 0 [59025464-59025464].
-1229063280 ACE_RW_Thread_Mutex::release ret 0 [59025464-59025464].
-1218573424 ACE_RW_Thread_Mutex::acquire_write ret 200000000 [59025564-0].
第一个线程先获取到读锁，第二个线程可以再次获取读锁并成功释放，第三个线程阻塞在写锁获取上。
10 ACE_Condition
场景1：
-1208281392 ACE_Condition
-1218774128 ACE_Condition
第一个线程等待，直到第二个线程signal后返回。
场景2：
-1208437040 ACE_Condition
-1218929776 ACE_Condition
第一个线程先signal，第二个线程再wait将不会退出。
场景3：
-1208121648 ACE_Condition
-1218614384 ACE_Condition
-1208121648 ACE_Condition
第一个线程先signal，第二个线程wait后不能退出，直到第一个线程再次signal。
场景4：
-1219454064 ACE_Condition
-1229943920 ACE_Condition
-1208961328 ACE_Condition
两个线程进入wait，一个线程signal后只有一个线程wait成功返回。
场景5：
-1219527792 ACE_Condition
-1230017648 ACE_Condition
-1209035056 ACE_Condition
两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。
11 ACE_Condition
场景1：
-1209071920 ACE_Condition
-1219564656 ACE_Condition
线程一进入wait等待，线程二signal后，线程一wait退出。
场景2：
-1219138672 ACE_Condition
-1229628528 ACE_Condition
-1208645936 ACE_Condition
两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。
场景3：
-1218626672 ACE_Condition
-1208133936 ACE_Condition
第一个线程先signal，第二个线程再wait将不会退出。
场景4：
-1208621360 ACE_Recursive_Thread_Mutex::acquire ret 0 [58239202-58239202].
-1208621360 ACE_Recursive_Thread_Mutex::acquire ret 0 [58239202-58239202].
-1208621360 ACE_Condition
-1219114096 ACE_Recursive_Thread_Mutex::acquire ret 100000000 [58239303-0].
wait线程递归获取了锁后，wait操作不能正常退出，之后的signal线程再度获取递归锁失败。
注意：linux版本这种情况下出现了死锁，但在windows下没有出现。
场景5：
-1209063728 ACE_Recursive_Thread_Mutex::acquire ret 0 [58526267-58526267].
-1209063728 ACE_Condition
-1219556464 ACE_Recursive_Thread_Mutex::acquire ret 0 [58526368-58526368].
-1219556464 ACE_Recursive_Thread_Mutex::acquire ret 0 [58526368-58526369].
-1219556464 ACE_Condition
-1219556464 ACE_Recursive_Thread_Mutex::release ret 0 [58526369-58526369].
-1219556464 ACE_Recursive_Thread_Mutex::release ret 0 [58526570-58526570].
-1209063728 ACE_Recursive_Thread_Mutex::release ret 0 [58526570-58526570].
第一个线程进入wait，signal线程先递归获取了锁再执行signal唤醒wait线程。
注意：wait线程的退出时间和signal线程第二个release函数退出时间相同，即等到递归锁完全释放后wait才退出。
12 ACE_Thread_Semaphore
场景1：
-1208437040 ACE_Thread_Semaphore::acquire ret 0 [55641633-55641633].
-1208437040 ACE_Thread_Semaphore::acquire ret 0 [55641633-0].
初始化信号量个数为1，第一次获取成功，第二次获取失败。
场景2：
-1208318256 ACE_Thread_Semaphore::acquire ret 0 [55602791-55602791].
-1208318256 ACE_Thread_Semaphore::acquire ret 0 [55602791-55602791].
初始化信号量个数为2，两次都获取成功。
场景3：
-1209076016 ACE_Thread_Semaphore::release ret 0 [55541009-55541009].
-1209076016 ACE_Thread_Semaphore::acquire ret 0 [55541009-55541009].
初始化信号量个数为1，先释放后获取可以成功。
场景4：
-1208158512 ACE_Thread_Semaphore::release ret 0 [55466317-55466317].
-1208158512 ACE_Thread_Semaphore::acquire ret 0 [55466317-55466317].
初始化信号量个数为0，先释放后获取可以成功。
场景5：
-1208273200 ACE_Thread_Semaphore::acquire ret 0 [55318871-0].
初始化信号量个数为0，获取失败。
场景6：
-1218729072 ACE_Thread_Semaphore::acquire ret 0 [55113235-55113235].
-1218729072 ACE_Thread_Semaphore::acquire ret 0 [55113235-55113437].
-1208236336 ACE_Thread_Semaphore::release ret 0 [55113437-55113437].
初始化信号量个数为1，第一次获取直接成功，第二次获取需要等到另一个线程release后才成功。