多线程笔记2
转发，请保持地址：http://blog.csdn.net/stalendp/article/details/9310171
以前学习过Java的多线程设计，出于对java多线程设计的熟悉，我把pthread的多线程方法按照java的习惯封装了一下，并写了几个例子，分享一下。
// ThreadHelper.h
#ifndef threadTest_ThreadHelper_h
#define threadTest_ThreadHelper_h
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
void msleep(unsigned sec) {
usleep(sec*1000);
}
// 参考 http://stackoverflow.com/questions/1151582/pthread-function-from-a-class
class Thread {
protected:
std::string name;
pthread_t mythread;
pthread_mutex_t mymutex;
pthread_cond_t mycond;
protected:
virtual void* run() = 0;
public:
Thread() {
pthread_mutex_init(&mymutex, NULL);
pthread_cond_init(&mycond, NULL);
char msg[50];
sprintf(msg, "%ld", time(NULL));
name = msg;
}
Thread(const char* _name) : name(_name) {
pthread_mutex_init(&mymutex, NULL);
pthread_cond_init(&mycond, NULL);
}
virtual ~Thread() {
pthread_mutex_destroy(&mymutex);
pthread_cond_destroy(&mycond);
}
const char* getName() {
return name.c_str();
}
void start() {
if ( pthread_create( &mythread, NULL, _run, this) ) {
printf("error creating thread.");
abort();
}
}
private:
static void* _run(void* This) {
return ((Thread*) This)->run();
}
};
class Synchronizable {
protected:
pthread_mutex_t mymutex;
pthread_cond_t mycond;
public:
#define LOCK_BEGIN pthread_mutex_lock(&mymutex)
#define LOCK_END pthread_mutex_unlock(&mymutex)
#define WAIT pthread_cond_wait(&mycond, &mymutex)
#define NOTIFY_ALL pthread_cond_broadcast(&mycond);
public:
Synchronizable() {
pthread_mutex_init(&mymutex, NULL);
pthread_cond_init(&mycond, NULL);
}
virtual ~Synchronizable() {
pthread_mutex_destroy(&mymutex);
pthread_cond_destroy(&mycond);
}
};
#endif
然后给出一个生产消费者模式的例子：
#ifndef threadTest_PtProducerConsumer_h
#define threadTest_PtProducerConsumer_h
#include "ThreadHelper.h"
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
#include <string>
#include <vector>
#include <sstream>
// 生产者必须将数据安全地交给消费者。虽然只是这样的问题，但当生产者与消费者
// 在不同的线程上运行时，两者的处理速度差将是最大的问题。当消费者要取数据时
// 生产者还没有建立出数据，或是生产者建立出数据时消费者的状态还没办法接受数据等。
// Producer-Consumer Pattern是在生产者和消费者之间加入一个“桥梁参与者”。
// 以这个桥梁参与者缓冲线程之间的处理速度差。
class Table : Synchronizable {
private:
int tail, head, count;
std::vector<std::string> buffer;
public:
Table(int _count) : tail(0), head(0), count(0) {
buffer.resize(_count);
}
void put(const char* cake) {
LOCK_BEGIN;
while (count >= buffer.size()) {
printf("!!!TABLE IS FULL!!!\n");
WAIT;
}
buffer[tail] = cake;
tail = (tail+1) % buffer.size();
count++;
NOTIFY_ALL;
printf("puts %s -- size %d\n", cake, count);
LOCK_END;
}
const char* take() {
LOCK_BEGIN;
while (count<=0) {
printf("!!!NO MORE CAKES!!!\n");
WAIT;
}
std::string cake = buffer[head];
head = (head+1) % buffer.size();
count--;
NOTIFY_ALL;
printf("takes %s -- size %d\n", cake.c_str(), count);
LOCK_END;
return cake.c_str();
}
};
static int mid;
class MakerThread: public Thread {
private:
Table* table;
public:
MakerThread(const char* _name, Table* _table) : Thread(_name) {
this->table = _table;
srand((unsigned)time(NULL));
}
void* run() {
while (true) {
msleep(rand()%1000);
std::stringstream ss;
ss << "[Cake No." << nextId() << " by " << getName() << "]";
table->put(ss.str().c_str());
}
return NULL;
}
static int nextId() {
return mid++;
}
};
class EaterThread: public Thread {
private:
Table* table;
public:
EaterThread(const char* _name, Table* _table) : Thread(_name) {
this->table = _table;
}
void* run() {
while (true) {
const char* cake = table->take();
// printf("%s\n", cake);
msleep(rand()%1000);
}
return NULL;
}
};
void pcRun() {
Table* table = new Table(3); // 建立可以放置3个蛋糕的桌子
(new MakerThread("MakerThread-1", table))->start();
(new MakerThread("MakerThread-2", table))->start();
(new MakerThread("MakerThread-3", table))->start();
(new EaterThread("EaterThread-1", table))->start();
(new EaterThread("EaterThread-2", table))->start();
(new EaterThread("EaterThread-3", table))->start();
sleep(90);
printf("hello producer consumer");
}
#endif
参考：《Java多线程设计模式详解》
相关文章： http://blog.csdn.net/stalendp/article/details/9253665