zhtread c++多线程库的使用2

按照c++ think上面的说明继续看看

写个代码如下:
编程环境(vc 7.1)

1. #include <zthread/runnable.h>
2. #include <zthread/ThreadedExecutor.h>
3. #include <iostream>
4. #pragma comment(lib,"ZThread_Z.lib")
5. 
   
6. class thread : public ZThread::Runnable
7. {
8. public:
9.     thread(int _id): id(_id){}
10.     ~thread(){}
11.     void run()
12.     {
13.          int i =0 ;
14.          while(i++<100)
15.         {
16.               printf("i am thread: %d ./n", id);
17.               _sleep(1200);
18.         }
19.     }
20. private:
21.     int id; 
22. };
23. 
    
24. int _tmain(int argc, _TCHAR* argv[])
25. {
26.       try
27.       {
28.            ZThread::ThreadedExecutor exetor;
29.            for(int i=0;i<10;i++)
30.                exetor.execute(new thread(i));
31.            printf("start /n");
32.       }
33.       catch(ZThread::Synchronization_Exception& e)
34.       {
35.             printf("%s",e.what());
36.       }
37. 
    
38.       _sleep(20000);
39.       return 0;
40. }

这是使用解释器的例子 。他就是使用一个线程管理器来管理所有的线程
ZThread::ThreadedExecutor为每个任务创建一个线程。
注意 Thread还有 cancel();interrupt()，isCanceled();这些成员函数

由于使用 ZThread::ThreadedExecutor会导致过多的开销,所以引入了 PoolExecutor的概念
线程池是一次分配所有线程的 感觉这个很有用的啊

如下:
#include <zthread/runnable.h>
#include <zthread/PoolExecutor.h>
#include <iostream>
#pragma comment(lib,"ZThread_Z.lib")

class thread : public ZThread::Runnable
{
public:
    thread(int _id): id(_id){}
    ~thread(){}
    void run()
    {
         int i =0 ;
         while(i++<100)
        {
              printf("i am thread: %d ./n", id);
              //_sleep(1200);
        }
    }
private:
    int id;
};

int _tmain(int argc, _TCHAR* argv[])
{
      try
      {
          ZThread::PoolExecutor exetor(10);
           for(int i=0;i<10;i++)
          {
               exetor.execute(new thread(i));
               exetor.interrupt();
          }
         
           printf("start /n");
      }
      catch(ZThread::Synchronization_Exception& e)
      {
            printf("%s",e.what());
      }

      _sleep(20000);
      return 0;
}

PoolExecutor没有默认的构造函数
他的成员函数和线程执行器的都一样
他使用一个线程集以并行方式执行线程

下一个就是ConcurrentExecutor
代码如下:

#include <zthread/runnable.h>
#include <zthread/ConcurrentExecutor.h>
#include <iostream>
#pragma comment(lib,"ZThread_Z.lib")

class thread : public ZThread::Runnable
{
public:
    thread(int _id): id(_id){}
    ~thread(){}
    void run()
    {
         int i =0 ;
         while(i++<100)
        {
              printf("i am thread: %d ./n", id);
              //_sleep(1200);
        }
    }
private:
    int id;
};

int _tmain(int argc, _TCHAR* argv[])
{
      try
      {
          ZThread::ConcurrentExecutor exetor;
           for(int i=0;i<10;i++)
          {
               exetor.execute(new thread(i));
               exetor.interrupt();
          }
         
           printf("start /n");
      }
      catch(ZThread::Synchronization_Exception& e)
      {
            printf("%s",e.what());
      }

      _sleep(20000);
      return 0;
}

观察到的和这个执行器的含义一样 是以串行化的次序提交任务的

再来看一下 SynchronousExecutor
该执行器保证每时每刻只有一个线程在运行

最后看一下让步的代码实现


// zthread.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <zthread/runnable.h>
#include <zthread/ThreadedExecutor.h>
#include <iostream>
#pragma comment(lib,"ZThread_Z.lib")

class thread : public ZThread::Runnable
{
public:
    thread(int _id): id(_id){}
    ~thread(){}
    void run()
    {
         int i =0 ;
         while(i++<100)
        {
              printf("i am thread: %d ./n", id); 
              //_sleep(1200);
        }
       ZThread::Thread::yield();
    }
private:
    int id;
};

int _tmain(int argc, _TCHAR* argv[])
{
      try
      {
          ZThread::ThreadedExecutor exetor;
           for(int i=0;i<10;i++)
          {
               exetor.execute(new thread(i));
               exetor.interrupt();
          }
         
           printf("start /n");
      }
      catch(ZThread::Synchronization_Exception& e)
      {
            printf("%s",e.what());
      }

      _sleep(20000);
      return 0;
}


使用让步的原则就是保证线程在做完之后告诉其他线程  自己做完了

在24号前弄完所有的zthread库
-_-!