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

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

操作
 * 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;
}