Unix 环境高级编程---线程创建、同步、

一下代码主要实现了linux下线程创建的基本方法，这些都是使用默认属性的。以后有机会再探讨自定义属性的情况。主要是为了练习三种基本的线程同步方法：互斥、读写锁以及条件变量。

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>

int g_count = 0;
pthread_mutex_t mutex_lock;
pthread_rwlock_t rw_lock;
pthread_cond_t con_val = PTHREAD_COND_INITIALIZER;

typedef enum 
{
    MutexLock = 0,
    RWLock,
    CondLock
}LockType;

typedef struct 
{
    int val;
    LockType type;
}ThreadData;

void PrintThreadId()
{
    pid_t pid;
    pthread_t tid;

    pid = getpid();
    tid = pthread_self();
    
    printf("[%s] process id : %d  thread id : 0x%lx\n",__func__,pid,tid);
}

void CleanUpFun(void *arg)
{

    printf("[%s] clean up : %s \n",__func__,(char *)arg);
}

void AddCount(int tid,LockType type)
{
    if(type == MutexLock)
    {
        printf("[%s] thread  %d MutexLock the count is  : %d\n",__func__,tid,g_count);
        pthread_mutex_lock(&mutex_lock);
        while(g_count < 10)
        {
            usleep(1);
            printf("%d-%d \t",tid,g_count);
            g_count++;
        }
        printf("\n");
        pthread_mutex_unlock(&mutex_lock);
    }

    if(type == RWLock)
    {
        pthread_rwlock_wrlock(&rw_lock);
        printf("[%s] thread  %d RWLock the count is  : %d\n",__func__,tid,g_count);
        while(g_count < 10)
        {
            usleep(1);
            printf("%d-%d \t",tid,g_count);
            g_count++;
        }
        printf("\n");
        pthread_rwlock_unlock(&rw_lock);

    }

    if(type == CondLock)
    {
        printf("[%s] thread  %d CondLock the count is  : %d\n",__func__,tid,g_count);
        pthread_mutex_lock(&mutex_lock);

        g_count = 1217;
        printf("[%s] thread  %d CondLock the count is  : %d\n",__func__,tid,g_count);
        
        pthread_mutex_unlock(&mutex_lock);

        pthread_cond_signal(&con_val);
    }

    
}

void DelCount(int tid,LockType type)
{
    usleep(1);

    if(type == MutexLock)
    {
        pthread_mutex_lock(&mutex_lock);

        printf("[%s] thread  %d MutexLock the count is  : %d\n",__func__,tid,g_count);
        while(g_count > 0)
        {
            usleep(1);
            printf("%d-%d \t",tid,g_count);
            g_count--;
        }
        printf("\n");
        pthread_mutex_unlock(&mutex_lock);
    }

    if(type == RWLock)
    {
        pthread_rwlock_wrlock(&rw_lock);

        printf("[%s] thread  %d RWLock the count is  : %d\n",__func__,tid,g_count);
        while(g_count > 0)
        {
            usleep(1);
            printf("%d-%d \t",tid,g_count);
            g_count--;
        }
        printf("\n");
        pthread_rwlock_unlock(&rw_lock);

    }

    if(type == CondLock)
    {
        pthread_mutex_lock(&mutex_lock);

    //    printf("[%s] thread  %d CondLock the count is  : %d\n",__func__,tid,g_count);

        //while(1)
        {
            pthread_cond_wait(&con_val,&mutex_lock);

            printf("[%s] thread  %d CondLock the count is  : %d\n",__func__,tid,g_count);
        }
        
        pthread_mutex_unlock(&mutex_lock);
    }

}

void PrintCount(int tid,LockType type)
{
    if(type == RWLock)
    {
        pthread_rwlock_rdlock(&rw_lock);

        printf("[%s] thread  %d RWLock the count is  : %d\n",__func__,tid,g_count);

        pthread_rwlock_unlock(&rw_lock);
    }
    else
    {
        

    }


}

void ChangCount(int tid,LockType type)
{

    if((tid == 2) || (tid == 4))
    {
        AddCount(tid,type);
    }
    else if((tid == 1))
    {
        DelCount(tid,type);
    }
    else if(tid == 3)
    {
        PrintCount(tid,type);
    }
    
}


void * ThreadFun(ThreadData *t)
{
    printf("\n----------------------------------------------------------\n");

    int val = 0;
    LockType type = 0;
    val = t->val;
    type = t->type;
    
    printf("[%s] this is thread   %d\n",__func__,val);
    PrintThreadId();

    char buf[1024];
    sprintf(buf,"thread %d first handler ",val);
    pthread_cleanup_push(CleanUpFun,buf);/*push and pop must be coupled*/

    int len = strlen(buf);
    sprintf(buf+len+1,"thread %d second handler ",val);/*Notice !!! */
    pthread_cleanup_push(CleanUpFun,buf+len+1);/*the buf must start from different address , to the cleanupfunc  ,the poniter is the same !!!*/

    ChangCount(val,type);
    
    if(val == 1)
    {
        printf("----------------------------------------------------------\n");
        return ((void *)val);/*clean up func won't run*/
    }
    else
    {
        printf("----------------------------------------------------------\n");
        pthread_exit((void *)val);/*clean up func won run*/
    }
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    
    return ((void *)val);
}

void JoinThread(pthread_t tid)
{
    void * ret;

    int err;

    err = pthread_join(tid,&ret);

    if(err != 0)
    {
        printf("error to join thread %lu\n",tid);
    }

    printf("\n[%s] catch thread  0x%lx , the return val is  %d\n",__func__,tid,(int)ret);
}


void CreateThread(LockType type)
{
    int err;

    ThreadData t1;
    ThreadData t2;
    ThreadData t3;

    t1.val = 1;
    t2.val = 2;
    t3.val = 3;

    pthread_t tid_1;
    pthread_t tid_2;
    pthread_t tid_3;


    if(type == MutexLock)
    {
        /*Mutex lock*/
        t1.type = MutexLock;
        t2.type = MutexLock;
        t3.type = MutexLock;
        
        err = pthread_create(&tid_1,NULL,(void *)ThreadFun,(void *)&t1);
        if(err != 0)
        {
            printf("error to create thread !\n");
        }
        
        err = pthread_create(&tid_2,NULL,(void *)ThreadFun,(void *)&t2);
        if(err != 0)
        {
            printf("error to create thread !\n");
        }    

        JoinThread(tid_1);
        JoinThread(tid_2);

    }
    else if(type == RWLock)
    {
        /*rw lock*/
        t1.type = RWLock;
        t2.type = RWLock;
        t3.type = RWLock;
        
        err = pthread_create(&tid_1,NULL,(void *)ThreadFun,(void *)&t1);
        if(err != 0)
        {
            printf("error to create thread !\n");
        }
        
        err = pthread_create(&tid_2,NULL,(void *)ThreadFun,(void *)&t2);
        if(err != 0)
        {
            printf("error to create thread !\n");
        }    

        err = pthread_create(&tid_3,NULL,(void *)ThreadFun,(void *)&t3);
        if(err != 0)
        {
            printf("error to create thread !\n");
        }    
        JoinThread(tid_1);
        JoinThread(tid_2);
        JoinThread(tid_3);
    }
    else if(type == CondLock)
    {
        t1.type = CondLock;
        err = pthread_create(&tid_1,NULL,(void *)ThreadFun,(void *)&t1);
        if(err != 0)
        {
            printf("error to create thread !\n");
        }

        sleep(1);
        t2.type = CondLock;
        err = pthread_create(&tid_2,NULL,(void *)ThreadFun,(void *)&t2);
        if(err != 0)
        {
            printf("error to create thread !\n");
        }
        JoinThread(tid_1);
        JoinThread(tid_2);
        

    }



}

void InitMutexLock()
{
    if(pthread_mutex_init(&mutex_lock,NULL) != 0)
    {
        printf("[Main] error to init mutex lock\n");
    }
}

void DestoryMutexLock()
{
    if(pthread_mutex_destroy(&mutex_lock) != 0)
    {
        printf("[Main] error to destory mutex lock\n");
    }
}

void DestoryRWLock()
{
    if(pthread_rwlock_destroy(&rw_lock) != 0)
    {
        printf("[Main] error to destroy rw lock \n");
    }
    
}

void InitRWLock()
{
    if(pthread_rwlock_init(&rw_lock,NULL) != 0)
    {
        printf("[Main] error to init rw lock\n");
    }
}

int main(int argc,char **argv)
{
    printf("=====================================mutex lock=====================================\n");

    InitMutexLock();

    CreateThread(MutexLock);

    DestoryMutexLock();

    printf("=====================================rw lock=====================================\n");

    InitRWLock();
    
    CreateThread(RWLock);

    DestoryRWLock();

    printf("=====================================Cond lock=====================================\n");

    InitMutexLock();

    CreateThread(CondLock);

    DestoryMutexLock();
    printf("[Main] quit\n");

    return 0;
}

运行效果如下：

tiger@ubuntu:/mnt/hgfs/e/Lessons/MyExercise/UtilLibs/THREAD$ ./thread
=====================================mutex lock=====================================

----------------------------------------------------------
[ThreadFun] this is thread   2
[PrintThreadId] process id : 10948  thread id : 0xb6f54b70
[AddCount] thread  2 MutexLock the count is  : 0

----------------------------------------------------------
[ThreadFun] this is thread   1
[PrintThreadId] process id : 10948  thread id : 0xb7755b70
2-0     2-1     2-2     2-3     2-4     2-5     2-6     2-7     2-8     2-9 
----------------------------------------------------------
[DelCount] thread  1 MutexLock the count is  : 10
1-10    [CleanUpFun] clean up : thread 2 second handler  
[CleanUpFun] clean up : thread 2 first handler  
1-9     1-8     1-7     1-6     1-5     1-4     1-3     1-2     1-1 
----------------------------------------------------------

[JoinThread] catch thread  0xb7755b70 , the return val is  1

[JoinThread] catch thread  0xb6f54b70 , the return val is  2
=====================================rw lock=====================================

----------------------------------------------------------
[ThreadFun] this is thread   3
[PrintThreadId] process id : 10948  thread id : 0xb6753b70
[PrintCount] thread  3 RWLock the count is  : 0
----------------------------------------------------------
[CleanUpFun] clean up : thread 3 second handler  
[CleanUpFun] clean up : thread 3 first handler  

----------------------------------------------------------
[ThreadFun] this is thread   2
[PrintThreadId] process id : 10948  thread id : 0xb7755b70
[AddCount] thread  2 RWLock the count is  : 0

----------------------------------------------------------
[ThreadFun] this is thread   1
[PrintThreadId] process id : 10948  thread id : 0xb6f54b70
2-0     2-1     2-2     2-3     2-4     2-5     2-6     2-7     2-8     2-9 
----------------------------------------------------------
[CleanUpFun] clean up : thread 2 second handler  
[CleanUpFun] clean up : thread 2 first handler  
[DelCount] thread  1 RWLock the count is  : 10
1-10    1-9     1-8     1-7     1-6     1-5     1-4     1-3     1-2     1-1 
----------------------------------------------------------

[JoinThread] catch thread  0xb6f54b70 , the return val is  1

[JoinThread] catch thread  0xb7755b70 , the return val is  2

[JoinThread] catch thread  0xb6753b70 , the return val is  3
=====================================Cond lock=====================================

----------------------------------------------------------
[ThreadFun] this is thread   1
[PrintThreadId] process id : 10948  thread id : 0xb6753b70

----------------------------------------------------------
[ThreadFun] this is thread   2
[PrintThreadId] process id : 10948  thread id : 0xb7755b70
[AddCount] thread  2 CondLock the count is  : 0
[AddCount] thread  2 CondLock the count is  : 1217
[DelCount] thread  1 CondLock the count is  : 1217
----------------------------------------------------------

[JoinThread] catch thread  0xb6753b70 , the return val is  1
----------------------------------------------------------
[CleanUpFun] clean up : thread 2 second handler  
[CleanUpFun] clean up : thread 2 first handler  

[JoinThread] catch thread  0xb7755b70 , the return val is  2
[Main] quit
tiger@ubuntu:/mnt/hgfs/e/Lessons/MyExercise/UtilLibs/THREAD$ 

代码相当拙劣基础，欢迎拍砖。