zthread学习 实例八 任务终止（一）——观赏植物园

   前面的几个例子中，使用了“退出标志”或Cancelable接口以适当的方式来终止一个任务，但某些情况下任务必须突然结束掉，这样终止任务将会所产生一些问题。

 

举例：模拟计数，公园委员会想要了解每天有多少从通过公园的 多个 入口进入了。

首先是一个互斥输出类，避免多个线程输出出现的混乱

[cpp]  view plain copy

1. #ifndef DISPLAY_H  
2. #define DISPLAY_H  
3. #include "zthread/Cancelable.h"  
4. #include "zthread/ZThread.h"  
5. #include <iostream>  
6. #include <sstream>  
7. using namespace ZThread;  
8. using namespace std;  
9. class Display  
10. {  
11. public:  
12.     void OutPut(ostringstream& os)  
13.     {  
14.         Guard<Mutex> g(Lock);  
15.         cout<<os.str();  
16.     }  
17. private:  
18.     Mutex Lock;   
19. };  
20. #endif  

 

模拟程序如下：

[cpp]  view plain copy

1. #include <vld.h>  
2. #include "stdafx.h"  
3. #include "zthread/Thread.h"  
4. #include "zthread/FastMutex.h"  
5. #include "zthread/CountedPtr.h"  
6. #include <iostream>  
7. #include <vector>  
8. #include <ctime>  
9. #include "Display.h"  
10. using namespace ZThread;  
11. using namespace std;  
12. //总计数器  
13. class Count : public Cancelable  
14. {  
15. public:  
16.     Count(): nCount(0), bPaused(false),bCanceld(false){}  
17.       
18.     int increment()  
19.     {  
20.         Guard<FastMutex> g(Lock); //*************  
21.         int temp = nCount;  
22.         if (rand() % 2 == 0)        //放大出错的可能  
23.         {  
24.             Thread::yield();  
25.         }  
26.         return (nCount = ++temp);  
27.     }  
28.     int value()  
29.     {  
30.         Guard<FastMutex> g(Lock);  
31.         return nCount;  
32.     }  
33.       
34.     void cancel()  
35.     {  
36.         Guard<FastMutex> g(Lock);  
37.         bCanceld = true;  
38.     }  
39.     bool isCanceled()  
40.     {  
41.         Guard<FastMutex> g(Lock);  
42.         return bCanceld;  
43.     }  
44.       
45.       
46.     void pause()  
47.     {  
48.         Guard<FastMutex> g(Lock);  
49.         bPaused = true;  
50.     }  
51.     bool isPaused()  
52.     {  
53.         Guard<FastMutex> g(Lock);  
54.         return bPaused;  
55.     }  
56.       
57. private:  
58.     FastMutex   Lock;  
59.     int         nCount;  
60.     bool        bPaused, bCanceld;  
61. };  
62. //门口计数  
63. class Entrance : public Runnable  
64. {  
65. public:  
66.     Entrance(CountedPtr<Count>& ApCount, CountedPtr<Display>& ApDisplay, int idn = 0)  
67.     :pCount(ApCount), pDisplay(ApDisplay), id(idn), bWaittingforCancel(false), Number(0) {}  
68.     void run()  
69.     {  
70.         try  
71.         {  
72.             while (!pCount->isPaused())      //控制总计数器  
73.             {  
74.                 Number++;                   //自身计数器  
75.                 {  
76.                     ostringstream os;  
77.                     //输出总数  
78.                     os << *this << " Total: " << pCount->increment() <<endl;  
79.                     pDisplay->OutPut(os);  
80.                 }  
81.                 Thread::sleep(100);  
82.             }  
83.             bWaittingforCancel = true;      //GetValue()时的阴塞消息  
84.             while (!pCount->isCanceled())      
85.                 Thread::sleep(100);  
86.             ostringstream os;  
87.             os << " Terminating: " << *this <<endl;  
88.             pDisplay->OutPut(os);  
89.         }  
90.         catch (Synchronization_Exception* e)  
91.         {  
92.             cerr << " Exception: "<< e->what() <<endl;   
93.         }  
94.     }  
95.       
96.     int GetValue()  
97.     {  
98.         while (pCount->isPaused() && !bWaittingforCancel)    //确保当前计数器和总计数器都已经退出  
99.             Thread::sleep(100);  
100.           
101.         return Number;  
102.     }  
103.       
104.     friend ostream& operator<< (ostream& os, const Entrance& e)  
105.     {  
106.         return os << " Entrance "<< e.id << " : " <<e.Number;  
107.     }  
108.       
109. private:  
110.     CountedPtr<Count> pCount;     //共享的总计数器  
111.     CountedPtr<Display>   pDisplay;  
112.       
113.     int Number;  
114.     int id;  
115.       
116.     bool bWaittingforCancel;  
117. };  
118. int _tmain(int argc, _TCHAR* argv[])   
119. {  
120.     srand(time(0));  
121.       
122.     CountedPtr<Count> pCount(new Count);  
123.     vector<Entrance*> v;  
124.       
125.     CountedPtr<Display> pDisplay(new Display);  
126.       
127.     try  
128.     {  
129.         ThreadedExecutor excutor;  
130.           
131.         for (int i = 0; i < 5; i++)  
132.         {  
133.             Entrance* pTask = new Entrance(pCount,pDisplay, i);  
134.             excutor.execute(pTask);  
135.             v.push_back(pTask);  
136.         }  
137.           
138.         cin.get();  
139.         pCount->pause();  
140.           
141.         int nSum = 0;  
142.           
143.         vector<Entrance*>:: iterator it = v.begin();  
144.           
145.         while (it != v.end())       //校对各个门口计数器的和是否和总计数器的结果相同,以此来检验互斥是否是成功  
146.         {  
147.             nSum += (*it)->GetValue();  
148.             it++;  
149.         }  
150.           
151.         ostringstream os;  
152.         os << "Total : " << pCount->value() << endl << "Sum of Entrance : " << nSum << endl;  
153.           
154.         pDisplay->OutPut(os);  
155.           
156.         pCount->cancel();  
157.           
158.         cin.get();  
159.     }  
160.     catch (Synchronization_Exception* e)  
161.     {  
162.         cerr << " Exception: "<< e->what() <<endl;   
163.     }  
164.       
165.     return 0;   
166. }  

 

输出结果：