线程同步学习1

看下简单的例子：

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

pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;
struct foo
{
    int f_count;
    pthread_mutex_t f_lock;
};
struct foo* AllocFoo()
{
    foo* lpFoo = (foo*)malloc(sizeof(struct foo));
    if(NULL != lpFoo)
    {
        lpFoo->f_count = 1;
        if(0 != pthread_mutex_init(&lpFoo->f_lock,NULL))
        {
            printf("pthread_mutex_init error.
");
            free(lpFoo);
            return NULL;
        }
    }
    printf("Alloc a Foo.
");
    return lpFoo;
}

bool DestoryFoo(foo* apFoo)
{
    pthread_mutex_lock(&apFoo->f_lock);
    if(--apFoo->f_count == 0)
    {
        printf("in DestoryFoo: f_coount:%d.
",apFoo->f_count);
        pthread_mutex_unlock(&apFoo->f_lock);
        pthread_mutex_destroy(&apFoo->f_lock);
        free(apFoo);
        printf("Destroy foo.
");
        return true;
    }
    else
    {
        printf("in DestoryFoo: f_coount:%d.
",apFoo->f_count);
        pthread_mutex_unlock(&apFoo->f_lock);
        return false;
    }
}

void HoldFoo(foo* apFoo)
{
    pthread_mutex_lock(&apFoo->f_lock);
    ++apFoo->f_count;
    printf("in  HoldFoo f_coount:%d.
",apFoo->f_count);
    pthread_mutex_unlock(&apFoo->f_lock);
}

void PrintTids(const char* s);

void* ThreadFun(void* Arg)
{
    PrintTids("");
    foo* lpFoo = (foo*)Arg;
    for(int i=0;i<5;++i)
    {
        //pthread_mutex_lock(&glock);
        HoldFoo(lpFoo);
        //pthread_mutex_unlock(&glock);
    }
    return NULL;
}
void PrintTids(const char* s)
{
    pid_t lPid = getpid();
    pthread_t lTid = pthread_self();
    printf("%s pid:%u,tid:(0x%x).
",s,(unsigned int)lPid, (unsigned int)lTid);
}
int main()
{
    foo* lpFoo = AllocFoo();
    pthread_t lTid1;
    int lErr = pthread_create(&lTid1,NULL,ThreadFun,lpFoo);
    if(0 != lErr)
    {
        exit(1);
    }
    printf("main thread");

    pthread_t lTid2;
    lErr = pthread_create(&lTid2,NULL,ThreadFun,lpFoo);
    if(0 != lErr)
    {
        exit(1);
    }
    //HoldFoo(lpFoo);
    void* lTret;
    lErr = pthread_join(lTid1,&lTret);
    if(0 != lErr)
    {
        printf("can't join thread1.
");
    }
    lErr = pthread_join(lTid2,&lTret);
    if(0 != lErr)
    {
        printf("can't join thread1.
");
    }

    bool lIsDestory = false;
    do
    {
        lIsDestory = DestoryFoo(lpFoo);
    }while(!lIsDestory);
}

 输出：