1.定时器  #include "Poco/Timer.h"  #include "Poco/Thread.h"  using Poco::Timer;  using Poco::TimerCallback;  class TimerExample  {  public:  void onTimer(Poco::Timer& timer)  {  std::cout << "onTimer called." << std::endl;  }  };  int main(int argc, char** argv)  {  TimerExample te;  Timer timer(250, 500); // fire after 250ms, repeat every 500ms  timer.start(TimerCallback<TimerExample>(te, &TimerExample::onTimer));  Thread::sleep(5000);  timer.stop();  return 0;  }  

2.管道#include "Poco/Process.h"  #include "Poco/PipeStream.h"  #include "Poco/StreamCopier.h"  #include <fstream>  using Poco::Process;  using Poco::ProcessHandle;  int main(int argc, char** argv)  {  std::string cmd("/bin/ps");  std::vector<std::string> args;  args.push_back("-ax");  Poco::Pipe outPipe;  ProcessHandle ph = Process::launch(cmd, args, 0, &outPipe, 0);  Poco::PipeInputStream istr(outPipe);  std::ofstream ostr("processes.txt");  Poco::StreamCopier::copyStream(istr, ostr);  return 0;  }

3.poco 默认线程池
#include "stdafx.h"
#include "Poco/ThreadPool.h"
#include "Poco/Runnable.h"
#include <iostream>
class HelloRunnable: public Poco::Runnable
{virtual void run(){std::cout << "Hello, bingzhe" << std::endl;}
};
int main(int argc, char** argv)
{HelloRunnable runnable;Poco::ThreadPool::defaultPool().start(runnable);Poco::ThreadPool::defaultPool().joinAll();return 0;
}

4.内存池#include "Poco/MemoryPool.h"  #include <string>  #include <iostream>  using Poco::MemoryPool;  int main(int argc, char** argv)  {  MemoryPool pool(1024); // unlimited number of 1024 byte blocks  // MemoryPool pool(1024, 4, 16); // at most 16 blocks; 4 preallocated  char* buffer = reinterpret_cast<char*>(pool.get());  std::cin.read(buffer, pool.blockSize());  std::streamsize n = std::cin.gcount();  std::string s(buffer, n);  pool.release(buffer);  std::cout << s << std::endl;  return 0;  }  

5.任务  #include "Poco/Task.h"  #include "Poco/TaskManager.h"  #include "Poco/TaskNotification.h"  #include "Poco/Observer.h"  using Poco::Observer;  class SampleTask: public Poco::Task  {  public:  SampleTask(const std::string& name): Task(name)  {}  void runTask()  {  for (int i = 0; i < 100; ++i)  {  setProgress(float(i)/100); // report progress  if (sleep(1000))  break;  }  }  };  class ProgressHandler  {  public:  void onProgress(Poco::TaskProgressNotification* pNf)  {  std::cout << pNf->task()->name()  << " progress: " << pNf->progress() << std::endl;  pNf->release();  }  void onFinished(Poco::TaskFinishedNotification* pNf)  {  std::cout << pNf->task()->name() << " finished." << std::endl;  pNf->release();  }  };  int main(int argc, char** argv)  {  Poco::TaskManager tm;  ProgressHandler pm;  tm.addObserver(  Observer<ProgressHandler, Poco::TaskProgressNotification>  (pm, &ProgressHandler::onProgress)  );  tm.addObserver(  Observer<ProgressHandler, Poco::TaskFinishedNotification>  (pm, &ProgressHandler::onFinished)  );  tm.start(new SampleTask("Task 1")); // tm takes ownership  tm.start(new SampleTask("Task 2"));  tm.joinAll();  return 0;  }  

6.通知
#include "stdafx.h"#include "Poco/NotificationCenter.h"  #include "Poco/Notification.h"  #include "Poco/Observer.h"  #include "Poco/NObserver.h"  #include "Poco/AutoPtr.h"  #include <iostream>  using Poco::NotificationCenter;  using Poco::Notification;  using Poco::Observer;  using Poco::NObserver;  using Poco::AutoPtr;  class BaseNotification: public Notification  {  public: void dosome(){printf("fuck!");}};  class SubNotification: public BaseNotification  {  };  class Target  {  public:  void handleBase(BaseNotification* pNf)  {  std::cout << "handleBase: " << pNf->name() << std::endl;  pNf->dosome();pNf->release(); // we got ownership, so we must release
        }  void handleSub(const AutoPtr<SubNotification>& pNf)  {  std::cout << "handleSub: " << pNf->name() << std::endl;  }  };  int main(int argc, char** argv)  {  NotificationCenter nc;  Target target;  nc.addObserver(  Observer<Target, BaseNotification>(target, &Target::handleBase)  );  nc.addObserver(  NObserver<Target, SubNotification>(target, &Target::handleSub)  );  nc.postNotification(new BaseNotification);  nc.postNotification(new SubNotification);  nc.removeObserver(  Observer<Target, BaseNotification>(target, &Target::handleBase)  );  nc.removeObserver(  NObserver<Target, SubNotification>(target, &Target::handleSub)  );  return 0;  }  

7.线程#include "Poco/Thread.h"  #include "Poco/Runnable.h"  #include <iostream>  class HelloRunnable: public Poco::Runnable  {  virtual void run()  {  std::cout << "Hello, bingzhe!" << std::endl;  }  };  int main(int argc, char** argv)  {  HelloRunnable runnable;  Poco::Thread thread;  thread.start(runnable);  thread.join();  return 0;  }  

8.线程对象#include "Poco/Activity.h"  #include "Poco/Thread.h"  #include <iostream>  using Poco::Thread;  class ActivityExample  {  public:  ActivityExample(): _activity(this,   &ActivityExample::runActivity)  {}  void start()  {  _activity.start();  }  void stop()  {  _activity.stop(); // request stop  _activity.wait(); // wait until activity actually stops
          }  protected:  void runActivity()  {  while (!_activity.isStopped())  {  std::cout << "bingzhe running." << std::endl;  Thread::sleep(200);  }  }  private:  Poco::Activity<ActivityExample> _activity;  };  int main(int argc, char** argv)  {  ActivityExample example;  example.start();  Thread::sleep(2000);  example.stop();  return 0;  }  

9.异步通知#include "stdafx.h"#include "Poco/Notification.h"  #include "Poco/NotificationQueue.h"  #include "Poco/ThreadPool.h"  #include "Poco/Runnable.h"  #include "Poco/AutoPtr.h"  using Poco::Notification;  using Poco::NotificationQueue;  using Poco::ThreadPool;  using Poco::Runnable;  using Poco::AutoPtr;  class WorkNotification: public Notification  {  public:  WorkNotification(int data): _data(data) {}  int data() const  {  return _data;  }  private:  int _data;  };  class Worker: public Runnable  {  public:  Worker(NotificationQueue& queue): _queue(queue) {}  void run()  {  AutoPtr<Notification> pNf(_queue.waitDequeueNotification());  while (pNf)  {  WorkNotification* pWorkNf =  dynamic_cast<WorkNotification*>(pNf.get());  if (pWorkNf)  {  printf("hi!bingzhe");//    Sleep(100);
                }  pNf = _queue.waitDequeueNotification();  }  }  private:  NotificationQueue& _queue;  };  int main(int argc, char** argv)  {  NotificationQueue queue;  Worker worker1(queue); // create worker threads
        Worker worker2(queue);  ThreadPool::defaultPool().start(worker1); // start workers
        ThreadPool::defaultPool().start(worker2);  // create some work  for (int i = 0; i < 100; ++i)  {  queue.enqueueNotification(new WorkNotification(i));  }  while (!queue.empty()) // wait until all work is done  Poco::Thread::sleep(100);  queue.wakeUpAll(); // tell workers they're done
        ThreadPool::defaultPool().joinAll();  return 0;  }