对ACE锁、条件变量、信号量在windows和linux平台下的测试

来源：互联网发布：2016网络作家编辑：程序博客网时间：2024/04/29 01:46

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::acquire ret -858993460 [205149995-0].

同一个线程在多释放锁一次后，再获取锁将不能获取到，即必须先acquire才release。（返回值ret=-858993460 即还未被赋值，且函数返回时间0表示一直没有返回）

场景3：

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::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::acquire ret -858993460 [261788858-0].

同一个线程在多释放锁一次后，再获取锁将不能获取到，即必须先acquire才release。

场景3：

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::acquire ret 0 [261849550-261849550].

同一个线程可以递归获取锁，对应作两次release操作后锁能重新获取。

场景4：

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::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::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::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<ACE_Thread_Mutex>

场景1：

284 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [276300127-276300327].

2392 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [276300327-276300327].

第一个线程等待，直到第二个线程signal后返回。

场景2：

3360 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [276638418-276638418].

1392 ACE_Condition<ACE_Thread_Mutex>::wait ret -858993460 [276638618-0].

第一个线程先signal，第二个线程再wait将不会退出。

场景3：

1980 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [276861342-276861342].

2364 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [276861542-276861742].

1980 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [276861742-276861742].

第一个线程先signal，第二个线程wait后不能退出，直到第一个线程再次signal。

场景4：

284 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [277125132-277125331].

2228 ACE_Condition<ACE_Thread_Mutex>::wait ret -858993460 [277125132-0].

3156 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [277125331-277125331].

两个线程进入wait，一个线程signal后只有一个线程wait成功返回。

场景5：

4712 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [277210055-277210254].

5564 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [277210055-277210254].

4900 ACE_Condition<ACE_Thread_Mutex>::broadcast ret 0 [277210254-277210254].

两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。

场景6：

4024 ACE_Thread_Mutex::acquire ret 0 [280876758-280876758].

4024 ACE_Condition<ACE_Thread_Mutex>::wait ret -858993460 [280876758-0].

2344 ACE_Thread_Mutex::acquire ret -858993460 [280876958-0].

第一个线程递归获取了锁，并进入wait，这时候第二个线程无法在获取锁从而不能再调用signal，最终wait不能返回。

5 ACE_Condition<ACE_Recursive_Thread_Mutex>

场景1：

4564 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [278957229-278957428].

4288 ACE_Condition<ACE_Recursive_Thread_Mutex>::signal ret 0 [278957428-278957428].

线程一进入wait等待，线程二signal后，线程一wait退出。

场景2：

4812 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [279926680-279926880].

5060 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [279926681-279926880].

4672 ACE_Condition<ACE_Recursive_Thread_Mutex>::broadcast ret 0 [279926880-279926880].

两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。

场景3：

1252 ACE_Condition<ACE_Recursive_Thread_Mutex>::signal ret 0 [280029304-280029304].

3732 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret -858993460 [280029504-0].

第一个线程先signal，第二个线程再wait将不会退出。

场景4：

3844 ACE_Recursive_Thread_Mutex::acquire ret 0 [279037760-279037760].

3844 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [279037760-279037959].

2344 ACE_Recursive_Thread_Mutex::acquire ret 0 [279037959-279037959].

2344 ACE_Condition<ACE_Recursive_Thread_Mutex>::signal ret 0 [279037959-279037959].

2344 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<ACE_Recursive_Thread_Mutex>::wait ret 0 [280468179-280468580].

1928 ACE_Recursive_Thread_Mutex::acquire ret 0 [280468379-280468379].

1928 ACE_Condition<ACE_Recursive_Thread_Mutex>::signal ret 0 [280468379-280468379].

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].

初始化信号量个数为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::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::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::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::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::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::release ret 0 [59642253-59642253].

一个线程递归获取读锁，都能获取成功。

场景7：

-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::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::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<ACE_Thread_Mutex>

场景1：

-1208281392 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [56649583-56649686].

-1218774128 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [56649686-56649686].

第一个线程等待，直到第二个线程signal后返回。

场景2：

-1208437040 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [56555353-56555353].

-1218929776 ACE_Condition<ACE_Thread_Mutex>::wait ret 100000000 [56555454-0].

第一个线程先signal，第二个线程再wait将不会退出。

场景3：

-1208121648 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [56244330-56244330].

-1218614384 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [56244431-56244531].

-1208121648 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [56244531-56244531].

第一个线程先signal，第二个线程wait后不能退出，直到第一个线程再次signal。

场景4：

-1219454064 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [56129833-56130035].

-1229943920 ACE_Condition<ACE_Thread_Mutex>::wait ret 11030516 [56129833-0].

-1208961328 ACE_Condition<ACE_Thread_Mutex>::signal ret 0 [56130035-56130035].

两个线程进入wait，一个线程signal后只有一个线程wait成功返回。

场景5：

-1219527792 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [55933393-55933595].

-1230017648 ACE_Condition<ACE_Thread_Mutex>::wait ret 0 [55933393-55933595].

-1209035056 ACE_Condition<ACE_Thread_Mutex>::broadcast ret 0 [55933595-55933595].

两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。

11 ACE_Condition<ACE_Recursive_Thread_Mutex>

场景1：

-1209071920 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [56804692-56804795].

-1219564656 ACE_Condition<ACE_Recursive_Thread_Mutex>::signal ret 0 [56804795-56804795].

线程一进入wait等待，线程二signal后，线程一wait退出。

场景2：

-1219138672 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [57000318-57000520].

-1229628528 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [57000318-57000520].

-1208645936 ACE_Condition<ACE_Recursive_Thread_Mutex>::broadcast ret 0 [57000520-57000520].

两个线程进入wait，一个线程broadcast后，两个wait线程都成功返回。

场景3：

-1218626672 ACE_Condition<ACE_Recursive_Thread_Mutex>::signal ret 0 [58106268-58106268].

-1208133936 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 200000000 [58106470-0].

第一个线程先signal，第二个线程再wait将不会退出。

场景4：

-1208621360 ACE_Recursive_Thread_Mutex::acquire ret 0 [58239202-58239202].

-1208621360 ACE_Condition<ACE_Recursive_Thread_Mutex>::wait ret 0 [58239202-0].

-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<ACE_Recursive_Thread_Mutex>::wait ret 0 [58526267-58526570].

-1219556464 ACE_Recursive_Thread_Mutex::acquire ret 0 [58526368-58526368].

-1219556464 ACE_Recursive_Thread_Mutex::acquire ret 0 [58526368-58526369].

-1219556464 ACE_Condition<ACE_Recursive_Thread_Mutex>::signal ret 0 [58526369-58526369].

-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].

初始化信号量个数为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后才成功。

正常使用下，windows和linux锁表现都比较一致，存在不一致的地方包括读写锁里的场景10和递归条件变量里的场景4，需要特别注意一下。

0 0