嵌入式 互斥锁和读写锁区别

/*

 * 线程同步——互斥量

 * 创建两个线程，使用互斥量使任一时刻只有一个线程对全局变量进行

操作

 * Lzy 2011-6-19

 */

#include
<stdio.h>

#include
<stdlib.h>

#include
<pthread.h>

pthread_mutex_t mutex;                    /* 定义

互斥量
*/

int x;                                

    /* 定义全局变量
*/

void thread1(void)                /* 定义线程1运

行的函数，其功能是对全局变量x进行逐减操作
*/

{

  while(x>0)

  {

    pthread_mutex_lock(&mutex);            /*
对互斥量进行

加锁操作
*/

    printf("Thread 1 is running : x=%d \n",x);

    x--;

    pthread_mutex_unlock(&mutex);        /*
对互斥量进行

解锁操作
*/

    sleep(1);

  }

  pthread_exit(NULL);

}

void thread2(void)                /* 定义线程2运

行的函数，功能与thread2相同
*/

{

  while(x>0)

  {

    pthread_mutex_lock(&mutex);            /*
对互斥量进行

加锁操作
*/

    printf("Thread 2 is running : x=%d \n",x);

    x--;

    pthread_mutex_unlock(&mutex);        /*
对互斥量进行

解锁操作
*/

    sleep(1);

  }

  pthread_exit(NULL);

}

int main(void)

{

  pthread_t id1,id2;                        

/* 定义线程的标识符
*/

  int ret;

  ret
= pthread_mutex_init(&mutex,NULL);    /*
对互斥量进行

初始化，这里使用默认的属性
*/

  if(ret
!= 0)

  {

    printf
("Mutex initialization failed.\n");        /* 如果

初始化失败，打印错误信息
*/

    exit
(1);

  }

  x=10;                                

/* 对全局变量赋初值
*/

  ret
= pthread_create(&id1,
NULL,
(void *)&thread1,
NULL);    

    /* 创建线程1
*/

  if(ret
!= 0)

  {

    printf
("Thread1 creation failed.\n");

    exit
(1);

  }

  ret
= pthread_create(&id2,
NULL,
(void *)&thread2,
NULL);    

    /* 创建线程2
*/

  if(ret
!= 0)

  {

    printf
("Thread2 creation failed.\n");

    exit
(1);

  }

  pthread_join(id1,
NULL);                /*线程

合并
*/

  pthread_join(id2,
NULL);

  return
(0);

}

/*

 * 线程同步

 * ——读写锁

 *     只要没有进程持有某个给定的读写锁用于写，那么任意数目的

线程都可持有该读写锁用于读

 *     仅当没有线程持有某个给定的读写锁用于读或写，才能分配该

读写锁用于写。

 * Lzy 2011-6-19

 */

#include
<stdio.h>

#include
<stdlib.h>

#include
<pthread.h>

int product
= 0;        //定义全局变量

pthread_rwlock_t rwlock
= PTHREAD_RWLOCK_INITIALIZER;    //静态

初始化读写锁    

void
* threadRead(void
* arg)            //线程函数读

{

    int cnt
= 0;

    while(cnt++
< 100)

    {

        pthread_rwlock_rdlock(&rwlock);    //读锁

        

        printf("Read: product = %d\n", product);

        

        pthread_rwlock_unlock(&rwlock);    //解锁

        sleep(1);

    }

}

void
* tidProduce(void
* arg)    //线程函数写 加1

{

    int cnt
= 0;

    while(cnt++
< 100)

    {

        pthread_rwlock_wrlock(&rwlock);    //写锁

        

        product++;

        printf("Produce: product = %d\n", product);

        

        pthread_rwlock_unlock(&rwlock);    //解锁

        sleep(1);

    }

}

void
* threadConsume(void
* arg)    //线程函数写 减1

{

    int cnt
= 0;

    while(cnt++
< 100)

    {

        pthread_rwlock_wrlock(&rwlock);    //写锁

        

        product--;

        printf("Consume: product = %d\n", product);

        

        pthread_rwlock_unlock(&rwlock);    //解锁

        sleep(2);

    }

}

int main(void)

{

    int i;

    pthread_t tid[10], tidconsume, tidproduce;

    

    for(i
= 0; i
< 2; i++)

    {

        if(pthread_create(&tid[i],
NULL, threadRead,

NULL))

        {

            printf("pthread_create error\n");

            exit(0);

        }

    }

    if(pthread_create(&tidproduce,
NULL, tidProduce,
NULL))

    {

        printf("pthread_create error\n");

        exit(0);

    }

    if(pthread_create(&tidconsume,
NULL, threadConsume,

NULL))

    {

        printf("pthread_create error\n");

        exit(0);

    }

    pthread_exit(NULL);        //等待所有线程结束

    return 0;

}