各process都有各自独立的地址空间，并且是专有的，因此一个process不能通过指针访问另一个process中的地址空间。而属于同一process的各thread，它们共享同一process的地址空间，因此一个thread可以通过指针访问另一个thread中的地址。这样我们可以在应用中自己定义消息队列，并对消息队列的访问进行管理，简化程序并提高性能。

在multi-thread应用中，我们可以使用消息对列来在不同thread之间进行消息传递，并降低各thread之间的藕合。

它们之间的关系如下：

生产者：向消息队列中放数据的线程。

消费者：从消息队列中取出数据的线程。

 
 生产者 ----> 消息队列 ----->消费者

如果应用规定消息队列的最大长度。在对队列进行控制时，应该当消息队列满时，可能要让生产者进行等待，直到消息队列中有新的位置可以放入新的消息。当消息队列为空时，应该让消费者进行等待，知道有新的消息被加到消息队列中。

在该模型中有两点需要注意：

1．不同生产者，消费者同时并发操作消息队列时，对各操作的串行化。这个问题可以通过对队列的操作进行加锁来实现。它的实现可以参考另一篇随笔《C++同步锁管理的一种方法》。

2．在消息队列为空或满时，应用程序的处理。

这可以在C++中采用Monitor.在Monitor中对某种条件进行监控。

Monitor 对象可以采取的动作：

(1)、等待操作 wait(long timeout = INFINITE), 缺省情况下无限等待下去。

(2)、发信号操作 signal(long count = 1), 缺省情况下激活一个正在消息队列上进行等代的线程。

对于Monitor的实现，可以很简单地用下列两种方式实现：

1、采用ACE中的ACE_Event, ACE_Thread_Semphore实现。

2、采用 ICE的Cond实现， 在Linux上，Cond实际上是通过pthread_cond_t来实现的。

    typedef T element_type;

    T* get() const
    {
        return _ptr;
    }
   
   //重载->操作符，返回所指对象的指针.

    T* operator->() const
    {
        if(!_ptr)
        {
            //
            // We don't throw directly NullHandleException here to
            // keep the code size of this method to a minimun (the
            // assembly code for throwing an exception is much bigger
            // than just a function call). This maximises the chances
            // of inlining by compiler optimization.
            //
            throwNullHandleException(__FILE__, __LINE__);
        }

        return _ptr;
    }

//  通过智能指针获取所指对象的引用.

    T& operator*() const
    {
        if(!_ptr)
        {
            //
            // We don't throw directly NullHandleException here to
            // keep the code size of this method to a minimun (the
            // assembly code for throwing an exception is much bigger
            // than just a function call). This maximises the chances
            // of inlining by compiler optimization.
            //
            throwNullHandleException(__FILE__, __LINE__);
        }

        return *_ptr;
    }

    operator bool() const
    {
        return _ptr ? true : false;
    }

    void swap(HandleBase& other)
    {
        std::swap(_ptr, other._ptr);
    }

    T* _ptr;

private:

    void throwNullHandleException(const char *, int) const;
};

......

// 智能指针类定义

template<typename T>
class Handle : public HandleBase<T>
{
public:

    Handle(T* p = 0)               //智能指针的构造函数
    {
        this->_ptr = p;

        if(this->_ptr)
        {
            this->_ptr->__incRef();         //在构造函数中增加所指对象的引用计数
        }
    }

    template<typename Y>                  //拷贝构造函数
    Handle(const Handle<Y>& r)
    {
        this->_ptr = r._ptr;

        if(this->_ptr)
        {
            this->_ptr->__incRef();   //在构造函数中增加所指对象的引用计数
        }
    }

    Handle(const Handle& r)         //拷贝构造函数
    {
        this->_ptr = r._ptr;

        if(this->_ptr)
        {
            this->_ptr->__incRef();    //在构造函数中增加所指对象的引用计数
        }
    }

    ~Handle()
    {
        if(this->_ptr)
        {
            this->_ptr->__decRef();      //在析构函数中减少所指对象的引用计数
        }
    }

// 重载=操作符, 要注意所有权 (即，对原实例的处理).

    Handle& operator=(T* p)         
    {
        if(this->_ptr != p)
        {
            if(p)
            {
                p->__incRef();      //增加新指对象的引用计数
            }

            T* ptr = this->_ptr;
            this->_ptr = p;

            if(ptr)
            {
                ptr->__decRef();   //减少原来所指对象的引用计数
            }
        }
        return *this;
    }

    template<typename Y>
    Handle& operator=(const Handle<Y>& r)
    {
        if(this->_ptr != r._ptr)
        {
            if(r._ptr)
            {
                r._ptr->__incRef();   //增加新指对象的引用计数
            }

            T* ptr = this->_ptr;
            this->_ptr = r._ptr;

            if(ptr)
            {
                ptr->__decRef();      //减少原来所指对象的引用计数
            }
        }
        return *this;
    }

    Handle& operator=(const Handle& r)
    {
        if(this->_ptr != r._ptr)
        {
            if(r._ptr)
            {
                r._ptr->__incRef();            //增加新指对象的引用计数
            }

            T* ptr = this->_ptr;
            this->_ptr = r._ptr;

            if(ptr)
            {
                ptr->__decRef();            //减少原来所指对象的引用计数
            }
        }
        return *this;
    }

 跟智能指针配合使用的对象．要能够跟指针智能配合使用，这些对象应该是从下列类的派生类的实例．
class SimpleShared
{
public:

    SimpleShared();
    SimpleShared(const SimpleShared&);

    virtual ~SimpleShared()
    {
    }

    SimpleShared& operator=(const SimpleShared&)
    {
        return *this;
    }

    void __incRef()
    {
        assert(_ref >= 0);
        ++_ref;
    }

    void __decRef()
    {
        assert(_ref > 0);
        if(--_ref == 0)               // 如果引用计数为0,则摧毁对象本身．
        {
            if(!_noDelete)
            {
                _noDelete = true;
                delete this;
            }
        }
    }

    int __getRef() const
    {
        return _ref;
    }

    void __setNoDelete(bool b)
    {
        _noDelete = b;
    }

private:

    int _ref;
    bool _noDelete;
};

class Shared
{
public:

    Shared();
    Shared(const Shared&);

    virtual ~Shared()
    {
    }

    Shared& operator=(const Shared&)
    {
        return *this;
    }

    virtual void __incRef();
    virtual void __decRef();
    virtual int __getRef() const;
    virtual void __setNoDelete(bool);

protected:

#if defined(_WIN32)
    LONG _ref;
#elif defined(ICE_HAS_ATOMIC_FUNCTIONS)
    volatile int _ref;
#else
    int _ref;
    Mutex _mutex;
#endif
    bool _noDelete;
};