[转]巧妙的C++同步

巧妙的C++同步 

概述
由于C++标准库不支持任何多线程编程实用工具，C++编程人员总是必须从头开始创建用于多线程编程的内容（例如线程和同步对象）。
此外，由于C++编程人员总是忙于从头开始创建同步对象，没办法太多地关注同步问题，从而导致处理多个线程的代码中出现较多的bug。本文将介绍几个多线程编程实用工具和惯例，希望
能对您的多线程编程工作有所帮助。

同步对象
大多数现代多任务操作系统都提供了自己的同步API和对象以便进行多线程编程。但是，作为C++编程人员，我们习惯于将所有内容看作对象，因此必须将这些功能封装到类中，并利用C++管理这些API 和对象。
有关提供这些封装类的内容超出了本文范围（从任何有关C++多线程编程的书中都可以找到相关详细实现），但是，本文还是会列出这些类的几个必要接口并进行进一步讨论。

锁
锁用于防止多个线程同时访问一个共享对象，
因为这样可能会损坏共享对象的状态。

class Lock
{
    public:
        // 获取当前调用线程的锁。
        bool Lockup() const;
        // 释放当前调用线程的锁。
        bool Unlock() const;
};

客户机调用Lock::Lockup()获取共享对象的锁并防止其他线程访问该对象，最后使用完该共享对象后它会调用Lock::Unlock()释放该锁。锁可在多个线程之间共享，一旦某个线程获得该锁，所有其他线程都必须在该锁处阻止，直到所有者释放该锁。

事件
顾名思义，事件用作线程通信的通知。

class Event
{
    public:
        // 等待在指定的时间内发出此事件。
        bool Wait(unsigned long milliseconds) const;
        // 通知等待线程。
        bool Notify() const;
};

一个客户机调用Event::Wait()等待某个事件的发生，该事件会阻止该客户机，直到另一个客户机调用Event::Notify()引发该事件的通知。通常情况下，等待着的客户机和进行通知的客户机处于不同的线程中，这也是它们需要使用此同步对象才能相互通信的原因。

C++ 实现Form
为了让讨论更加清晰和具体，让我们先从下面这个需要同步支持的例子说起：假设有个叫Form 的类，它含有一个储存其他对象传来消息的队列，并且它执行一个独立的进程处理未决消息。
假设多个线程可能会同时尝试将对象发送到表单中，所以我们必须序列化对表单的访问，尤其是序列化对内部事件队列的访问。因此，Form的典型C++实现应类似如下所示：

class Form : public Thread
{
    public:
        // 发送指定信息到这个表单
        void PostMessage(const Message& message)
        {
            this->m_messageQueueLock.Lockup(); //[1]
            this->m_messageQueue.PutMessage(message); //[2]
            this->m_messageQueueLock.Unlock(); //[3]
            this->m_messageEvent.Notify(); //[4]
        }
    private:
        // 处理消息队列中的所有未决消息
        void ProcessMessages()
        {
            this->m_messageEvent.Wait(TIME_INFINITE); //[5]
            MessageQueue messagesToProcess; //[6]
            this->m_messageQueueLock.Lockup(); //[7]
            this->m_messageQueue.Swap(messagesToProcess); //[8]
            this->m_messageQueueLock.Unlock(); //[9]
            for (const Message* pMessage=messagesToProcess.GetMessage(); //[10]
                    pMessage; //[11]
                    pMessage = messagesToProcess.GetMessage()) //[12]
            { //[13]
                this->OnMessage(*pMessage); //[14]
                messagesToProcess.PopMessage(); //[15]
            } //[16]
        }
        // 进程入口
        virtual void OnRun()
        {
            while (this->IsAlive())
            {
                this->ProcessMessages();
            }
        }
        // 为子类处理消息
        virtual bool OnMessage (const Message& message) = 0;
    private:
        MessageQueue m_messageQueue;
        Lock m_messageQueueLock;
        Event m_messageEvent;
};

发现这个实现中的问题了吗？给您1 分钟的时间，看是否能找出2 个以上的问题..
好了，时间到。找出问题所在了吗？在此我列出两个问题：

1>>异常安全问题
严格说来，从异常安全的角度来说，PostMessage()和ProcessMessages()很容易出现问题，可能会永久阻止工作线程。
我们假定现在有一个表单正在处理队列中挂起的消息（第[10]-[15]行）。同时，另一个线程中的对象正在尝试将一条消息发送到消息队列中。它成功获得了队列的锁（第[1]行），但不幸的是PutMessage()因为某种原因抛出了一个异常（第[2]行），从而导致该工作线程直接关闭。由于所有者已经关闭，这个锁就没有机会得到释放，所有其他线程都将永久性地阻止在该锁上。这是多么恐怖的事情！
2>>维护问题
如您所见，为了同步对内部消息队列的多个访问，我们必须为其维护两个额外的同步对象（m_messageQueueLock 和m_messageEvent）。如果您有数十个对象要求进行同步，情况会怎样呢？这会是一个非常严重的维护问题，项目越大问题越严重。
借鉴Java 和C#的经验
与C++不同，Java和C#都在语言和开发包中内置了多线程支持和实用工具。现在我们看看这两种语言是如何处理多线程的，有哪些值得我们借鉴的经验（不要感到羞愧，Java和C#从C++借鉴了太多东西，现在我们只是小小地礼尚往来一下）。
鉴于本文介绍的是有关同步惯例的问题，我们将关注一下Java和C#是如何解决在上一节的结尾的问题的。
现在我们讨论一下Java。所有Java对象都从java.lang.Object派生而来，该对象提供了内置的同步功能，例如锁和事件。
Object 类提供的同步接口如下所示：

class Object {
    public final void wait() throws InterruptedException;
    public final void notify();
};

wait()和notify()方法提供的功能与前面讨论的Event类提供的功能相同。由于所有Java类均派生自Object，所以它们可以随时用作同步对象。非常方便，不是吗？
还有，派生自Object 的所有类（包括Object 本身）都具有一个不可见的内置锁，这个锁不能直接访问，但可通过下面的方式轻松地访问：

synchronized (this.myObject) {
    this.myObject.doSomething1();
    this.myObject.doSomething2();
    this.myObject.doSomething3();
}

这在Java中称为同步块（C#也提供了类似机制）。进入同步块时，在同步对象上就可以自动获得内置锁；离开同步块时则会自动释放该锁。
此外，如果执行同步块时抛出了任何异常，也可以保证在异常传播出去之前自动释放这个不可见的锁。而且，如果某天您决定不再需要同步doSomething3()，只需上移最后的大括号即可从该块中删除doSomething3()。同样非常方便，不是吗？
好了，现在我们看看如何在Java中实现Form（根据Java编码风格，这里没有将每个方法名的首字母大写）：

abstract class Form extends Thread {
    private MessageQueue messageQueue = new MessageQueue();
    public void postMessage(Message message) {
        synchronized (this.messageQueue) {
            　　this.messageQueue.putMessage(message);
            　　this.messageQueue.notify();
        }
    }
    private void processMessages() {
        MessageQueue messagesToProcess =
            new MessageQueue();
        synchronized (this.messageQueue) {
            　　this.messageQueue.wait();
            　　this.messageQueue.swap(messagesToProcess);
        }
        for (Message message =
                　　　　messagesToProcess.getMessage();
                　　　　message != null;
                　　　　message = messagesToProcess.getMessage()) {
            　　this.onMessage(message);
            　　messagesToProcess.popMessage();
        }
    }
    void onRun() {
        while (this.isAlive()) {
            　　this.processMessages();
        }
    }
    abstract boolean onMessage (Message message);
};

干净简洁！这样我们就轻松获得了内置的异常安全保证。
一件多么有意义的事情！
但是等一等，作为C++编程人员，我们从这些同步机制可以学到什么？我们不具有任何C++ 语言支持（就某种程度而言，这并不正确）；我们也不具有STL 库的任何支持。不过幸运的是，我们可以利用C++强大的可扩展性和灵活性来自行构建支持。

C++ 同步惯例
是的，C++是一种强大的面向对象的编程语言，但是不要忘记，它也是一种强大的泛型编程语言。不过，这与同步有什么关系呢？耐心一点，现在我们看一看可以从泛型编程中获得什么好处。

C++ 同步实用程序
首先，我列出所有我们会用来简化同步的实用程序。

template<typename T>
struct SyncObject : public T
{
　　typedef T ObjectType;
　　T& GetObject()
　　{
　　　　return *this;
　　};
　　const T& GetObject() const
　　{
　　　　return *this;
　　};
};
// 将锁功能注入模板参数。
template<typename T>
struct Lockable : public SyncObject<T>, public Lock
{
};
// 将事件功能注入模板参数。
template<typename T>
struct Waitable : public SyncObject<T>, public Event
{
};
#define SYNCHRONIZED
template<typename T>
struct LockableUtil
{
　　typedef T LockableType;
　　typedef typename T::ObjectType ObjectType;
　　explicit LockableUtil(T& lockable) : m_lockable(lockable)
　　{
　　}
　　T& GetLockable()
　　{
　　　　return this->m_lockable;
　　}
　　const T& GetLockable() const
　　{
　　　　return this->m_lockable;
　　}
　　ObjectType& GetObject()
　　{
　　　　return this->m_lockable;
　　}
　　const ObjectType& GetObject() const
　　{
　　　　return this->m_lockable;
　　}
private:
　　T& m_lockable;
};
template<typename T>
struct AutoLock : public LockableUtil<T>
{
　　explicit AutoLock(T& lockable) : LockableUtil<T>(lockable)
　　{
　　　　this->GetLockable().Lockup();
　　}
　　~AutoLock()
　　{
　　　　this->GetLockable().Unlock();
　　}
};

C++ 同步惯例
现在我们使用这些实用工具重新实现Form 类，再看看可从中获得什么好处。

class Form : public Thread
{
    private:
        typedef Lockable< Waitable<MessageQueue> >
            SyncMessageQueue;
    public:
        void PostMessage(const Message& message)
        {
            SYNCHRONIZED
            {
                AutoLock<SyncMessageQueue>
                    lock(this->m_messageQueue);
                this->m_messageQueue.PutMessage(message);
            }
            this->m_messageQueue.Notify();
        }
}

转自：http://blog.chinaunix.net/uid-20395183-id-1951539.html