ACE線程安全與同步（Thread Safety and Synchronization）

保護原語
爲了確保一致性，多線程程序必須在共享數據周圍使用保護原語。
Protection Primitives in ACE

Primitive

Description

ACE_Mutex	Wrapper class around the mutual-exclusion mechanism and used to provide a simple, efficient mechanism to serialize access to a shared resource. Similar in functionality to a binary sempahore. Can be used for mutual exclusion among both threads and processes.
ACE_Thread_Mutex	Can be used in place of ACE_Mutex and is specific for synchronization of threads.
ACE_Recursive_Thread_Mutex	Mutex that is recursive, that is, can be acquired multiple times by the same thread. Note that to work correctly, it must be released as many times as it was acquired.
ACE_RW_Mutex	Wrapper class that encapsulates readers/writer locks. These locks are acquired differently for reading and writing, thus enabling multiple readers to read while no one is writing. These locks are nonrecursive.
ACE_RW_Thread_Mutex	Can be used in place of ACE_RW_Mutex and is specific for synchronization of threads.
ACE_Token	Tokens are the richest and heaviest locking primitive available in ACE. The locks are recursive and allow for read and write locking. Also, strict FIFO ordering of acquisition is enforced; all threads that call acquire() enter a FIFO queue and acquire the lock in order.
ACE_Atomic_Op	Template wrapper that allows for safe arithmetic operations on the specified type.
ACE_Guard	Template-based guard class that takes the lock type as a template parameter.
ACE_Read_Guard	Guard that uses acquire_read() on a read/write guard during construction.
ACE_Write_Guard	Guard that uses acquire_write() on a read/write guard during construction.

遞歸互斥體（Recursive Mutexes）
如果某個線程兩次獲取同一個互斥體，線程會阻塞鎖死自己（大多數情況）。
你可以使用遞歸互斥體來（ACE_Recursive_Thread_Mutex）避免這種情況，它允許同一個線程多次獲取互斥體，而不會阻塞自己。
Readers/Writer 鎖（Readers/Writer Locks）
Readers/Writer 鎖（ACE_RW_Mutex）允許多線程同時持有一個鎖進行讀取，但只有一個線程能夠持有這個鎖進行寫入。
只在讀取競爭大大超過寫入競爭時使用它，因爲Readers/Writer 鎖（ACE_RW_Mutex）都比互斥體慢。
原子運算包裝（Atomic Operation Wrapper）
如果機器內存是強序（strongly ordered）的，對一個處理器上的內存所做的修改就會立刻被其它處理器看到，就不需要對全局變量進行同步。
否則，你需要使用同步。
用一個classic producer/consumer problem using busy waiting演示：

#include <ace/Atomic_Op_T.h>
#include <ace/Thread_Mutex.h>
#include <ace/Log_Msg.h>
#include <ace/Task.h>

typedef ACE_Atomic_Op<ACE_Thread_Mutex, unsigned int> SafeUInt;
typedef ACE_Atomic_Op<ACE_Thread_Mutex, int> SafeInt;

static const int Q_SIZE = 100;            //緩衝區大小
static const int MAX_PROD = 1000;        //最大生產數

class Consumer : public ACE_Task_Base
{
private:
    int* buf_;
    SafeUInt& in_;
    SafeUInt& out_;
public:
    Consumer(int *buf, SafeUInt &in, SafeUInt& out)
        : buf_(buf), in_(in), out_(out)
    { }

    int svc(void)
    {
        while (1)
        {
            int item;

            // Busy wait.
            do
            { }
            while (in_.value() - out_.value() == 0);

            item = buf_[out_.value() % Q_SIZE];
            out_++;

            ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("Consumed %d\n"),
                item));

            if (check_termination(item))
                break;
        }

        return 0;
    }

    int check_termination(int item)
    {
        return (item == MAX_PROD);
    }
};

class Producer : public ACE_Task_Base
{
private:
    int* buf_;
    SafeUInt& in_;
    SafeUInt& out_;
public:
    Producer(int* buf, SafeUInt& in, SafeUInt& out)
        : buf_(buf), in_(in), out_(out)
    { }

    int svc(void)
    {
        SafeInt itemNo = 0;
        while (1)
        {
            // Busy wait.
            do
            { }
            while(in_.value() - out_.value() == Q_SIZE);

            itemNo++;
            buf_[in_.value() % Q_SIZE] = itemNo.value();
            in_++;

            ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("Produced %d \n"),
                itemNo.value()));

            if (check_termination(itemNo.value()))
                break;
        }

        return 0;
    }

    int check_termination(int item)
    {
        return (item == MAX_PROD);
    }
};

int ACE_TMAIN (int, ACE_TCHAR *[])
{
    int shared_buf[Q_SIZE];
    SafeUInt in = 0;
    SafeUInt out = 0;

    Producer producer(shared_buf, in, out);
    Consumer consumer(shared_buf, in, out);

    producer.activate();
    consumer.activate();
    producer.wait();
    consumer.wait();

    return 0;
}

 
令牌管理（Token Management）
是一個框架解決方案，有死鎖檢測特性。
線程同步（Thread Synchronization）
同步是這樣一個過程，通過它你可以控制多個線程的執行次序，從而完成某項任務。
ACE Synchronization Primitives

Primitive

Description

ACE_Condition	A condition variable; allows signaling other threads to indicate event occurrence
ACE_Semaphore	A counting semaphore; can be used as a signaling mechanism and also for synchronization purposes
ACE_Barrier	Blocks all threads of execution until they all reach the barrier line, after which all threads continue
ACE_Event	A simple synchronization object that is used to signal events to other threads

使用信號量（Semaphores）
信號量是非負整型計數，用於協調對多個資源的訪問。
獲取信號量，計數就會減小；
釋放信號量，計數就會增大；
計數到達0----不再有資源----試圖獲取該信號量的線程就會阻塞，直到信號量計數變得大於0位置。
把信號量計數初始化爲某個非負值，表示你擁有的資源數量。
與互斥體的區別：
互斥體假定獲取它的線程也將是釋放它的線程；
信號量相反，一個線程獲取由另一個線程釋放。
////操作系統課程上的例題（生產者和消費者PV操作）：

#include <ace/Log_Msg.h>
#include <ace/Task.h>
#include <ace/Semaphore.h>
#include <ace/Message_Block.h>

class Consumer : public ACE_Task<ACE_MT_SYNCH>
{
private:
    ACE_Semaphore& psema_;
    ACE_Semaphore& csema_;
    int exit_condition_;

public:
    enum { N_THREADS = 5 };

    Consumer(ACE_Semaphore& psema, ACE_Semaphore& csema)
        : psema_(psema), csema_(csema), exit_condition_(0)
    { }

    int svc(void)
    {
        while(!is_closed())
            consume_item();
        return 0;
    }

    void consume_item()
    {
        csema_.acquire();
        if (!is_closed())
        {
            ACE_Message_Block *mb;
            this->getq(mb);
            if (mb->msg_type() == ACE_Message_Block::MB_HANGUP)
            {
                //掛斷消息
                shutdown();
                mb->release();
                return;
            }
            else
            {
                ACE_DEBUG((LM_DEBUG,
                    ACE_TEXT("(%t) Consumed %d\n"),
                    *((int*)mb->rd_ptr())));
                mb->release();
            }
            //psema_值增一，允許生產者繼續執行
            psema_.release();
        }
    }

    void shutdown(void)
    {
        exit_condition_ = 1;
        //喚醒消息隊列上的所有線程
        this->msg_queue()->deactivate();
        //釋放在信號量上等待的所有線程
        csema_.release(N_THREADS);
    }

    int is_closed(void)
    {
        return exit_condition_;
    }
};
class Producer : public ACE_Task_Base
{
public:
    enum { MAX_PROD = 128 };

    Producer(ACE_Semaphore& psema, ACE_Semaphore& csema,
        Consumer &consumer)
        : psema_(psema), csema_(csema), consumer_(consumer)
    { }

    int svc(void)
    {
        for (int i = 0; i <= MAX_PROD; i++)
            produce_item(i);
        hang_up();
        return 0;
    }

    void produce_item(int item)
    {
        psema_.acquire();
        ACE_Message_Block *mb
            = new ACE_Message_Block(sizeof(int),
            ACE_Message_Block::MB_DATA);
        ACE_OS::memcpy(mb->wr_ptr(), &item, sizeof item);
        mb->wr_ptr(sizeof(int));
        this->consumer_.putq(mb);

        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t) Produced %d\n"), item));
        //生產出一個新元素，csema_值增一
        csema_.release();
    }

    void hang_up()
    {
        psema_.acquire();
        ACE_Message_Block *mb =
            new ACE_Message_Block(0, ACE_Message_Block::MB_HANGUP);
        this->consumer_.putq(mb);
        csema_.release();
    }

private:
    ACE_Semaphore& psema_;
    ACE_Semaphore& csema_;
    Consumer& consumer_;
};
int ACE_TMAIN(int, ACE_TCHAR *[])
{
    ACE_Semaphore psem(5);        //隊列中能容納的最大數目爲5
    ACE_Semaphore csem(0);        //在csem的release()之前，消費者完全不能進行消費

    Consumer consumer(psem, csem);
    Producer producer(psem, csem, consumer);

    producer.activate();
    //多個消費者線程
    consumer.activate(THR_NEW_LWP | THR_JOINABLE,
        Consumer::N_THREADS);

    producer.wait();
    consumer.wait();

    return 0;
}

 
使用柵欄（Barriers）
每個線程在到達某種周知的狀態時調用柵欄的wait()，阻塞起來，等待其它所有參與線程調用wait()表明它們也到達了該狀態。
一旦所有線程都到達柵欄，它們就會被解除阻塞，並一起繼續執行。
使用ACE_Barrier，當然你得傳入同步線程的數目。
///讓所有線程的啓動和關閉時間同步

#include <ace/OS.h>
#include <ace/Log_Msg.h>
#include <ace/Task.h>
#include <ace/Barrier.h>

class HA_CommandHandler : public ACE_Task<ACE_MT_SYNCH>
{
private:
    ACE_Barrier& startup_barrier_;
    ACE_Barrier& shutdown_barrier_;
public:
    enum { N_THREADS = 5 };

    HA_CommandHandler(ACE_Barrier& startup_barrier, ACE_Barrier& shutdown_barrier)
        : startup_barrier_(startup_barrier),
        shutdown_barrier_(shutdown_barrier)
    { }

    //隨機初始化時間
    void initialize_handler(void)
    {
        ACE_OS::sleep(ACE_OS::rand() % 10);
    }

    //隨機執行時間
    int handle_command_requests(void)
    {
        ACE_OS::sleep(ACE_OS::rand() % 10);
        return -1;
    }

    int svc(void)
    {
        initialize_handler();
        startup_barrier_.wait();
        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t: %D) Started\n")));

        while(handle_command_requests() > 0)
            ;

        shutdown_barrier_.wait();
        ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%t: %D) Ended\n")));

        return 0;
    }

};
int ACE_TMAIN(int, ACE_TCHAR *[])
{
    ACE_Barrier startup_barrier(HA_CommandHandler::N_THREADS);
    ACE_Barrier shutdown_barrier(HA_CommandHandler::N_THREADS);

    HA_CommandHandler handler(startup_barrier, shutdown_barrier);
    handler.activate(THR_NEW_LWP | THR_JOINABLE,
        HA_CommandHandler::N_THREADS);
    handler.wait();
    return 0;
}

 
線程專有存儲（Thread-Specific Storage）
當你創建線程時，你所創建的全部東西是：一個線程棧、一個信號掩碼和一個任務控制塊。
線程專有存儲（thread-specific storage ，TSS）：能夠存儲專有於某個線程的狀態信息。
使用ACE_TSS模板類，你只需把你想要存儲在TSS中的數據作爲模板參數傳遞給它，然後用operator->()方法在你需要時對數據進行訪問。operator->()會在首次調用時在TSS中創建並存儲數據，ACE_TSS的析構器會確保TSS數據被適當移除和銷燬。

class ClientContext
{
public:
    void *get_attribute(const char *name);
    void set_attribute(const char *name, void *value);

private:
    Map attributeMap_;
};
class HA_CommandHandler : public ACE_Task<ACE_MT_SYNCH>
{
private:
    ACE_TSS<ClientContext> tss_ctx_;
public:
    virtual int svc(void)
    {
        //...
        this->tss_ctx_->get_attribute("attribute1");

        return 0;
    }

};