Ice 线程与并发 C++

线程

1.Thread类

    1.1概述

          Ice中的基础线程是由ThreadControl类和Thread类来提供的（在IceUtil/IceUtil.h中定义）：

          Thread类是一个抽象基类，拥有一个纯虚方法run。要创建线程，必须特化Thread类，并实现run方法。

      1.2 其成员函数
           1）id：该函数返回每个线程的唯一标识符，类型是ThreadID。在调用start函数之前调用它时，会引发ThreadNotStartedException。

           2）start：这个成员函数启动新创建的线程，会调用run方法。start方法同时负责引用计数的加减。

           3）getThreadControl：这个成员函数返回它所在的线程控制对象。在调用start之前调用它同样会触发异常。

           4）operator== 、operator!=、operator<  这些函数比较两个线程的ID，目的是能降Thread对象用于有序的STL容器。

           5）特别注意：必须在堆上分配Thread对象，才能够释放正确。

2.ThreadControl类

        2.1概述

            start方法返回的是类型为ThreadControl对象，指向发出调用的线程

        2.2其成员函数

            1）ThreadControl：缺省构造器返回一个ThreadControl对象，指向发出调用的线程。

            2）id：该函数返回每个线程的唯一标识符，类型是ThreadID。

            3）join：这个方法挂起发起调用的线程，直到join所针对的线程终止为止。例如：

                   IceUtil::ThreadPtr t = new ReaderThread; // Create a thread
                   IceUtil::ThreadControl tc = t->start(); // Start it
                   tc.join(); // Wait for it

           4）detach

                   这个方法分离一个线程。一旦线程分离，就不能再融合；因此必须保证线程在程序离开main函数之前终止。

           5）isAlive：如果底层的线程还没有退出（run方法还没有完成），该方法就返回真。该方法在实现非阻塞的join时很有用。

           6）sleep：这方法挂起线程，时间长度由Time决定。挂起线程就是让该线程离开CPU，让其他线程占用。

           7）yield：这个方法使得它所针对的线程放弃CPU，让其他线程运行。看了它的代码，发现yield的效果等于Sleep（0）。

           8）operator== 、operator!=、operator<  ：和上面thread一样.

2.实现线程

      代码 举例说明实现线程(未经严格验证)：

//myQueue.h文件

<span style="font-size: 16px;">#ifndef MYQUEUE_H_
#define MYQUEUE_H_

#include<IceUtil/Monitor.h>
#include<IceUtil/Mutex.h>
//#include <vector>
#include <list>
//#include<iostream>
using namespace std;
//using namespace IceUtil;

template <class T>
class Queue : public IceUtil::Monitor<IceUtil::Mutex>
{
public:
    Queue() : _waitingReaders(0),_waitingWriters(0){}

    void put(const T& item)
    {
        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
        while(_q.size()>10)
        {
            try{
                ++_waitingWriters;
                wait();
                --_waitingWriters;
            }catch(...){
                --_waitingWriters;
                throw;
            }
        }
        _q.push_back(item);

        if(_waitingReaders||_waitingWriters)
        {
            notify();
        }
    }

    T get()
    {
        IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);

        while(_q.size() == 0)
        {
            try{

                ++_waitingReaders;
                wait();
                --_waitingReaders;
            }catch (const IceUtil::Exception &e)
            {
                --_waitingReaders;
                throw;
            }
        }
        T item = _q.front();
        _q.pop_front();
        return item;
    }
private:
    list<T> _q;
    short _waitingReaders;
    short _waitingWriters;
};

#endif</span>

#ifndef MYQUEUE_H_
#define MYQUEUE_H_

#include<IceUtil/Monitor.h>
#include<IceUtil/Mutex.h>
//#include <vector>
#include <list>
//#include<iostream>
using namespace std;
//using namespace IceUtil;

template <class T>
class Queue : public IceUtil::Monitor<IceUtil::Mutex>
{
public:
	Queue() : _waitingReaders(0),_waitingWriters(0){}

	void put(const T& item)
	{
		IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
		while(_q.size()>10)
		{
			try{
				++_waitingWriters;
				wait();
				--_waitingWriters;
			}catch(...){
				--_waitingWriters;
				throw;
			}
		}
		_q.push_back(item);
		
		if(_waitingReaders||_waitingWriters)
		{
			notify();
		}
	}

	T get()
	{
		IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);		

		while(_q.size() == 0)
		{
			try{
				
				++_waitingReaders;
				wait();
				--_waitingReaders;
			}catch (const IceUtil::Exception &e)
			{
				--_waitingReaders;
				throw;
			}
		}
		T item = _q.front();
		_q.pop_front();
		return item;
	}
private:
	list<T> _q;
	short _waitingReaders;
	short _waitingWriters;
};

#endif

//myMain.cpp文件

<span style="font-size: 16px;">#include <myQueue.h>
#include<vector>
#include<IceUtil/Thread.h>

Queue<int> q;

class ReaderThread : public IceUtil::Thread
{
    virtual void run()
    {
        for(int i=0 ; i<5 ; ++i)
        {
            cout << "read_value:" << (int)q.get() << endl;
        }
    }
};

class WriterThread : public IceUtil::Thread
{
    virtual void run()
    {
        for(int i=0;i<5;++i)
        {
            q.put(i);
            cout<< "write_value:" << i << endl;
        }
    }
};

int main()
{
    vector<IceUtil::ThreadControl> threads;
    int i;

    for(i=0;i<5;++i)
    {
        IceUtil::ThreadPtr t = new WriterThread;
        threads.push_back(t->start());
    }

    for(i =0;i<5;++i)
    {
        IceUtil::ThreadPtr t = new ReaderThread;
        threads.push_back(t->start());
    }

    for(vector<IceUtil::ThreadControl>::iterator i = threads.begin();
        i != threads.end(); ++i)
    {
        i->join();
    }
    return 0;
}</span>