用c++封装linux系统调用

#include <pthread.h>

#include <cstdlib>

#include <ctime>

#include <iostream>

using namespace std;



class RWLock {



private :

    pthread_mutex_t cnt_mutex;

    pthread_cond_t rw_cond;

    int rd_cnt, wr_cnt;



    RWLock(const RWLock&);

    RWLock& operator= (const RWLock&);



public :

    RWLock(): rd_cnt(0),wr_cnt(0)

        {

            pthread_mutex_init(&cnt_mutex, NULL);

            pthread_cond_init(&rw_cond, NULL);

        }



    void get_shared_lock()

        {

            pthread_mutex_lock(&cnt_mutex);

            while (wr_cnt >0)

                {

                    pthread_cond_wait(&rw_cond,&cnt_mutex);

                }

            rd_cnt++;

            pthread_mutex_unlock(&cnt_mutex);

        }



    void release_shared_lock()

        {

            pthread_mutex_lock(&cnt_mutex);

            rd_cnt--;

            if (0 == rd_cnt)

                {

                    pthread_cond_signal(&rw_cond);

                }

            pthread_mutex_unlock(&cnt_mutex);

        }



    void get_exclusive_lock()

        {

            pthread_mutex_lock(&cnt_mutex);

            while (rd_cnt+wr_cnt>0)

                {

                    pthread_cond_wait(&rw_cond,&cnt_mutex);

                }

            wr_cnt++;

            pthread_mutex_unlock(&cnt_mutex);

        }



    void release_exclusive_lock()

        {

            pthread_mutex_lock(&cnt_mutex);

            wr_cnt--;

            pthread_cond_broadcast(&rw_cond);

            pthread_mutex_unlock(&cnt_mutex);

        }



    ~RWLock()

        {

            pthread_mutex_destroy(&cnt_mutex);

            pthread_cond_destroy(&rw_cond);

        }

};



class Test

{



private :    

    RWLock lock;

    

    static void* shared_task_handler(void* arg)

        {

            Test* testptr = static_cast<Test*>(arg);



            testptr->lock.get_shared_lock();//得到共享锁

            //do the shared task here

            testptr->lock.release_shared_lock();

        }





    static void * exclusive_task_handler(void * arg)

        {

            Test* testptr = static_cast<Test*>(arg);

            testptr->lock.get_exclusive_lock();

            //do the exclusive task here

            testptr->lock.release_exclusive_lock();

        }



public :

    typedef void* (*ThreadFunc) (void*);



    void start()

        {

            srand(time(NULL));



            const int THREADS_NO=rand()%100;

            pthread_t* threads = new pthread_t[THREADS_NO];



            for(int i=0; i<THREADS_NO; i++)

                {

                    ThreadFunc tmpfunc = rand()%2? shared_task_handler : exclusive_task_handler;

                    if (pthread_create(threads+i,NULL,tmpfunc,this))

                        {

                            cerr << "pthread_create fails" << endl;

                            exit(1);

                        }

                }



            for(int i=0; i<THREADS_NO; i++)

                {

                    pthread_join(threads[i],NULL);

                }



            delete[] threads;

        }

};



int main()

{

    Test tmptest;

    tmptest.start();

}

static_cast < type-id > ( expression )

int i;

float f = 166.71;

i = static_cast<int>(f);

此时结果，i的值为166。

cstdlib是C++里面的一个常用函数库， 等价于C中的<stdlib.h>。

http://blog.chinaunix.net/uid-52437-id-2108727.html