ACE多线程编程（一）

使用ACE进行多线程编程的内容相对较多，分多篇总结。

本文中主要介绍线程的创建、互斥体和线程间通信。

1、线程的创建

使用ACE进行多线程编程比较简单，只需：

1. 从ACE_Task_Base创建子类；
2. 重新实现svc()虚方法，这个函数是新线程的进入点。新线程从svc函数开始执行，函数返回，则新线程也结束；
3. 调用ACE_Task_Base::activate()方法启动新线程；
4. 调用ACE_Task_Base::wait()方法等待新线程结束。调用wait方法的父线程将阻塞，一直等待所有子线程结束。

注：如果父线程没有等待子线程，而是提前退出，则子线程也将被迫终止。

2、互斥体

ACE提供了一系列的互斥体，互斥体提供了简单的acquire()和release()接口。在多线程的互斥保护中，我们可以使用ACE_Thread_Mutex互斥体。

举一个简单的例子，多个线程使用同一个socket发送数据，为了防止交叉写，我们需要使用互斥体，示例代码如下：

class MyThread: public ACE_Task_Base {
    public:
        virtual int svc (void) {
            ACE_Time_Value sleep_time(0, 100000);
            while (1) {
                mutex_.acquire (); 

                ACE_OS::sleep (sleep_time);
                // Send data through the global socket
                Send_data (); 
                    
                mutex_.release (); 
            }   
            return 0;
        }   
    private:
        ACE_Thread_Mutex mutex_;
};

3、守卫

如果忘记释放获取的互斥体，会造成死锁。守卫可以简化互斥体的使用。例如下面的代码就会产生死锁：

mutex_.acquire ();

ACE_OS::sleep (sleep_time);

ACE_NEW_RETURN (object, Object, -1);

mutex_.release (); 

在实例化新对象失败时，将直接返回-1，O(∩_∩)O~，此时没有释放互斥体，死锁！

当被锁住的代码中有多个函数返回点时，很容易忘记release，而且这种四处release的代码也很丑陋。这时使用守卫将变得优雅。

3.1、守卫类

守卫类的构造函数和析构函数用于互斥体的获取和释放。在实例化守卫类对象时，构造函数获取互斥体，守卫类对象退出作用域销毁时，将调用析构函数释放互斥体。

上面的代码如果改用守卫类，代码示例如下：

{
    ACE_Guad<ACE_Thread_Mutext> gurad (mutex_);   // 获取互斥体
    ACE_OS::sleep (sleep_time);

    ACE_NEW_RETURN (object, Object, -1);        // 在此处返回也会释放互斥体，不会死锁
} // gurad退出作用域，释放互斥体




ACE提供的守卫类，如下表所示



 
 

   
   ACE 守卫类
  
  
守卫
描述
ACE_Guad<T>
在守卫创建和析构过程中，使用锁类T的acquire()和release()方法。
ACE_Read_Guad<T>
在构造时调用acquire_read()
ACE_Write_Guad<T>
在构造时调用acquire_write()
ACE_TSS_Guad<T>
在堆上分配守卫，，并在线程专有存储中保存它的引用。这样即使线程通过ACE_Thread::exit()显示退出，锁也会被释放。
ACE_TSS_Read_Guad<T>
线程专有的守卫的读版本
ACE_TSS_Write_Guad<T>
线程专有的守卫的写版本

3.2、守卫宏
为了方便的使用守卫类，ACE提供了一组守卫宏。
无返回值守卫宏：

 
 
ACE_GUARD(LockType, GuardName, LockObject)
ACE_WRITE_GUARD(LockType, GuardName, LockObject)
ACE_READ_GUARD(LockType, GuardName, LockObject)
带返回值的守卫宏：在出错时返回ReturnValue

 
 
ACE_GUARD_RETURN (LockType, GuardName, LockObject, ReturnValue)
ACE_WRITE_GUARD_RETURN (LockType, GuardName, LockObject, ReturnValue)
ACE_READ_GUARD_RETURN (LockType, GuardName, LockObject, ReturnValue)

守卫宏使用方法如下：

{
    ACE_GURAD_RETURN (ACE_Thread_Mutex, mon, mutex_, -1); // 如果出错，此处返回-1；否则在栈上创建名为mon的ACE_Guard<ACE_Thread_Mutex>实例
    // 临界区代码
}


4、线程间通信
线程通信可划分为两个宽泛的范畴：

 
 
状态变化或事件通知，在这种情况下，只需要对事件的发生进行交流，而不需要在两个线程间传递数据。
消息传递，在这种情况下，两个线程相互传递数据。
4.1、条件变量
条件变量用于通告状态变化或事件发生。条件变量总是和互斥体协同使用。要使用条件变量，必须首先获取互斥体，然后检查所需条件是否为真，如果为真，则执行所需动作，然后释放互斥体。如果所需条件为假，则调用条件变量的wait() 方法，等待系统状态发生变化。一旦系统状态发生变化，造成所需条件为真的线程会向条件变量发出信号，唤醒阻塞在wait()方法的线程。被唤醒的线程再次检查所需条件是否为真，如果为真则执行所需操作，否则，再次等待。
示例代码：

mutex_.acquire ();

while (!condition_ok)
    condition_.wait ();

// Do something within the protection code

mutex_.release ();

4.2、消息队列
消息队列在现程通信中使用的如此广泛，于是ACE提供了带消息队列的ACE_Task模版类。ACE_Task派生自ACE_Task_Base，它自带一个ACE_Message_Queue消息队列，可以方便的在同一个进程的不同线程间通信。
4.2.1、ACE_Message_Block
消息队列中使用的消息块类。ACE_Message_Block是一种高效的数据容器，可以用来高效的存储和共享消息。你可以把消息块当成一种高级的数据缓冲区，支持像引用计数和数据共享这样的特性。关于ACE_Message_Block的使用可以单写一章，这里不详细说，具体使用可以参考文档或代码。
注：消息块含有一个类型字段，使用这个字段，有时会使编程变得简洁。
注：ACE_Message_Block::duplicate ()：浅拷贝，共享数据块，增加引用计数；ACE_Message_Block::clone ()：深度拷贝。


4.2.2、ACE_Message_Queue
这里不详细介绍ACE_Message_Queue。ACE_Task提供了两个新的接口函数getq ()和putq ()，使用起来很方便。
4.2.3、示例代码
下面是一个使用ACE_Task进行主线程和子线程通信的示例：



#include "ace/Task.h"

class MyTask : public ACE_Task<ACE_MT_SYNCH>
{
    public:
        int svc (); 
    private:
        bool canceled;
};

int MyTask::svc ()
{
    ACE_Message_Block *mb;
    ACE_Time_Value wait_for;
    while (!canceled) {
        wait_for = ACE_OS::gettimeofday (); 
        wait_for += 2;
        while (this->getq (mb, &wait_for) != -1) 
        {   
            if (mb->msg_type () == ACE_Message_Block::MB_HANGUP)
            {   
                canceled = true;
                mb->release (); 
                break;
            }   

            ACE_LOG_MSG->log_hexdump (LM_DEBUG, mb->rd_ptr (), mb->length (), "Message Block received");

            mb->release (); 
        }   
    }   

    return 0;
}



int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
    MyTask my_task;

    my_task.activate (); 

    ACE_Message_Block *mb;
    ACE_NEW_RETURN (mb, ACE_Message_Block(1024), -1);
    mb->copy ("Hello", ACE_OS::strlen ("Hello") + 1); 
    my_task.putq (mb);

    ACE_NEW_RETURN (mb, ACE_Message_Block(1024), -1);
    mb->copy (" World", ACE_OS::strlen (" World") + 1);
    my_task.putq (mb);


    ACE_NEW_RETURN (mb, ACE_Message_Block(0, ACE_Message_Block::MB_HANGUP), -1);
    my_task.putq (mb);

    my_task.wait ();
}