CppExplore

作者：CppExplore 网址：http://www.cppblog.com/CppExplore/
废话不多说，详细介绍使用线程的优点好处请参考baidu、google。
一、线程使用场景。使用线程的方式大致有两种：
（1）流水线方式。根据业务特点，将一个流程的处理分割成多个线程，形成流水线的处理方式。产生的结果:延长单一流程的处理时间，提高系统整体的吞吐能力。
（2）线程池方式。针对处理时间比较长且没有内蕴状态的线程，使用线程池方式分流消息，加快对线程消息的处理，避免其成为系统瓶颈。
线程使用的关键是 线程消息队列、线程锁、智能指针 的 使用。其中以线程消息队列最为重要。

二、线程消息队列描述。所谓线程消息队列，就是一个普通的循环队列（其它数据结构也未尝不可，具体内容请参考数据结构课本）加上“多生产者－单（多）消费者的PV操作”（详细内容请参考操作系统课本）。流水线方式中的线程是单消费者，线程池方式中的线程是多消费者。
为了后文更好的描述问题，作如下说明：
（1）假定循环队列CircleQueue中,存放的消息指针类型是MyMSG *,入队操作EnQueue,出队操作DeQueue，判断队满IsQueueFull，判断队空IsQueueEmpty。
（2）生产者消费者：生产者线程生产消息(MyMSG *)，放在一个空缓冲区(CircleQueue)中，供消费者线程消费，生产者生产消息(EnQueue)，如果缓冲区满(IsQueueFull)，则被阻塞，消费者消费消息(DeQueue)，如果缓冲区空(IsQueueEmpty)，则被阻塞。线程消息队列就是生产者消费者问题中的缓冲区，而它的生产者是不限定的，任何线程都可以作为生产者向其中进行EnQueue操作，消费线程则可能是一个，也可能是多个。因此对循环队列的任何操作都要加锁，以保证线程安全。
PV操作和锁机制的基础都是信号量。下面列出posix标准中给出的有关信号量的操作:

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t * sem);
int sem_trywait(sem_t * sem);
int sem_post(sem_t * sem);
int sem_getvalue(sem_t * sem, int * sval);
int sem_destroy(sem_t * sem);

各个函数的详细用法，请在linux/unix上查看man。
三、线程消息队列实现。基于以上讨论，下面给出线程消息队列的实现(仅为了说明问题，非标准可运行代码)。

class ThreadQueue
{
    CircleQueue * queue;
    int nFull;
    int nEmpty;
    sem_t lock;
    sem_t fullCond;
    sem_t emptyCond
};
void createThreadQueue()
{
    createCircleQueue(queue);
    nFull=0;
    nEmpty=0;
    sem_ini(&lock,0,1);
    sem_init(&fullCond,0,0);
    sem_init(&emptyCond,0,0);
}
void putq(MyMSG * msg)
{
    sem_wait(&lock);
    if(IsQueueFull(queue))
    {
        nFull++;
        sem_post(&lock);
        sem_wait(&fullCond);
        sem_wait(&lock);
        nFull--;
    }
    EnQueue(queue,msg);
    if(nEmpty>0)
    {
        sem_post(&emptyCond);
    }
    sem_post(&lock);
}
void getq(MyMSG * msg)
{
    sem_wait(&lock);
    if(IsQueueEmpty(queue))
    {
        nEmpty++;
        sem_post(&lock);
        sem_wait(&emptyCond);
        sem_wait(&lock);
        nEmpty--;
    }
    DeQueue(msg);
    if(nFull>0)
    {
        sem_post(&fullCond);
    }
    sem_post(&lock);
}
void destroyThreadQueue()
{
    destroyCircleQueue(queue);
    sem_destroy(&lock);
    sem_destroy(&fullCond);
    sem_destroy(&emptyCond);
}

四、线程消息队列使用说明。将线程和线程消息队列封装在一起，形成带有消息队列的线程，其它线程向该线程的消息队列插入消息，本线程取消息处理，之后再向其它线程的消息队列插入消息，如此形成流水线运行方式。线程的创建可以使用posix的pthread_create函数，或者boost的boost::thread。具体使用请查看相关文档。另ACE中的ACE_Task实现了带有消息队列的线程，可以直接使用。
五、线程锁描述。线程锁，应该都很熟悉，通常的实现以mutex面目示人。假设实现后的操作有：加锁lock,解锁unlock。
所谓线程锁就是同一时间只能有一个线程拥有的锁。当一个线程通过lock获得线程锁以后，在该线程持有该锁的期间，其它进行获取锁操作的线程只能阻塞在lock操作处，但该线程可以继续对锁进行lock操作而不阻塞。
六、线程锁实现

class mutex
{
    sem_t lock;
    sem_t used;
    int nInOwner;
    pthread_t owner;
};
mutex()
{
    sem_init(&lock,0,1);
    sem_init(&used,0,0);
    owner=NULL;
    nInOwner=0;
}
void lock()
{
    pthread_t curThread=pthread_self();
    sem_wait(&lock);
    if(pthread_equal(owner,NULL))
    {
        owner=curThread;
    }
    else if(pthread_equal(curThread,owner)==0)
    {
        sem_post(&lock);
        sem_wait(&used);
        sem_wait(&lock);
        owner=curThread;
    }
    
    nInOwner++;
    sem_post(&lock);
}
void unlock()
{
    sem_wait(&lock);
    if(--nInOwner==0)
    {
        owner=NULL;
        nInOwner=0;
        sem_post(&used);
    }
    sem_post(&lock);
}
~mutex()
{
    sem_destroy(&lock);
    sem_destroy(&used);
}

七、线程锁使用说明。系统设计中应该尽量减少锁的使用。但有的时候无法避免，这时就是mutex登场的时候了。mutex的实现，linux下有pthread_mutex_t，ACE里有ACE_Thread_Mutex，boost里有boost::mutex。为了高效的操作可以进一步实现出其它不同的锁机制，比如常见的读写锁,条件锁，不再多说，有兴趣可以自己去实现，详细可以参考操作系统课本。另linux/ACE/boost中均有实现。
lock和unlock要成对使用，但是很多情况下，一个函数有很多出口，再加上异常的情况，需要针对一个lock写很多unlock，这样不仅容易遗漏unlock，而且代码也变得很丑陋。ACE中提供了Guard封装mutex，使用起来比较方便，使用的时候不需要关心锁的释放，具体请看ACE。
也可以自己实现这种类Guard的功能。代码如下：

class Guard
{
    mutex  *m_mutex;
};
Guard(mutex  *lock):m_mutex(lock)
{
    m_mutex->lock();
}
~Guard()
{
    m_mutex->unlock();
}

使用的时候只需要在函数开始处写std::auto_ptr<Guard> guard(new Guard(lock)) ;这属于智能指针使用的一个小技巧。
八、使用智能指针的需求。在线程池方式中，为了去掉内蕴状态，线程间不得不传递对象指针，这样很难判断指针的生命周期，难以找到释放内存空间的合适位置。智能指针完美解决了这个问题。boost中有boost::shared_ptr,ACE中有ACE_Refcounted_Auto_Ptr。本遍主要讲述线程相关，智能指针不再展开。
九、线程间消息传递框架。
（1）面向过程的消息传递。c语言常用方式。消息以结构体的形式定义。

enum MsgType 
{
    CONCRETE_MSG1=1,
    CONCRETE_MSG2=2
};
struct MyMsg
{
    MsgType type;
    union union_st
    {
        concreteMsg1 *msg1;
        concreteMsg2 *msg2;
    }msg;
};