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

 

  1. /*
  2.  * 线程同步——互斥量
  3.  * 创建两个线程，使用互斥量使任一时刻只有一个线程对全局变量进行
  4. 操作
  5.  * Lzy 2011-6-19
  6.  */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <pthread.h>
  10. pthread_mutex_t mutex;                    /* 定义
  11. 互斥量 */
  12. int x;                                
  13.     /* 定义全局变量 */
  14. void thread1(void)                /* 定义线程1运
  15. 行的函数，其功能是对全局变量x进行逐减操作 */
  16. {
  17.   while(x>0)
  18.   {
  19.     pthread_mutex_lock(&mutex);            /* 对互斥量进行
  20. 加锁操作 */
  21.     printf("Thread 1 is running : x=%d \n",x);
  22.     x--;
  23.     pthread_mutex_unlock(&mutex);        /* 对互斥量进行
  24. 解锁操作 */
  25.     sleep(1);
  26.   }
  27.   pthread_exit(NULL);
  28. }
  29. void thread2(void)                /* 定义线程2运
  30. 行的函数，功能与thread2相同 */
  31. {
  32.   while(x>0)
  33.   {
  34.     pthread_mutex_lock(&mutex);            /* 对互斥量进行
  35. 加锁操作 */
  36.     printf("Thread 2 is running : x=%d \n",x);
  37.     x--;
  38.     pthread_mutex_unlock(&mutex);        /* 对互斥量进行
  39. 解锁操作 */
  40.     sleep(1);
  41.   }
  42.   pthread_exit(NULL);
  43. }
  44. int main(void)
  45. {
  46.   pthread_t id1,id2;                        
  47. /* 定义线程的标识符 */
  48.   int ret;
  49.   ret = pthread_mutex_init(&mutex,NULL);    /* 对互斥量进行
  50. 初始化，这里使用默认的属性 */
  51.   if(ret != 0)
  52.   {
  53.     printf ("Mutex initialization failed.\n");        /* 如果
  54. 初始化失败，打印错误信息 */
  55.     exit (1);
  56.   }
  57.   x=10;                                
  58. /* 对全局变量赋初值 */
  59.   ret = pthread_create(&id1, NULL, (void *)&thread1, NULL);    
  60.     /* 创建线程1 */
  61.   if(ret != 0)
  62.   {
  63.     printf ("Thread1 creation failed.\n");
  64.     exit (1);
  65.   }
  66.   ret = pthread_create(&id2, NULL, (void *)&thread2, NULL);    
  67.     /* 创建线程2 */
  68.   if(ret != 0)
  69.   {
  70.     printf ("Thread2 creation failed.\n");
  71.     exit (1);
  72.   }
  73.   pthread_join(id1, NULL);                /*线程
  74. 合并 */
  75.   pthread_join(id2, NULL);
  76.   return (0);
  77. }
  1. /*
  2.  * 线程同步
  3.  * ——读写锁 
  4.  *     只要没有进程持有某个给定的读写锁用于写，那么任意数目的
  5. 线程都可持有该读写锁用于读
  6.  *     仅当没有线程持有某个给定的读写锁用于读或写，才能分配该
  7. 读写锁用于写。
  8.  * Lzy 2011-6-19
  9.  */
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <pthread.h>
  13. int product = 0;        //定义全局变量
  14. pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;    //静态
  15. 初始化读写锁    
  16. void * threadRead(void * arg)            //线程函数读 
  17. {
  18.     int cnt = 0;
  19.     while(cnt++ < 100)
  20.     {
  21.         pthread_rwlock_rdlock(&rwlock);    //读锁
  22.         
  23.         printf("Read: product = %d\n", product);
  24.         
  25.         pthread_rwlock_unlock(&rwlock);    //解锁
  26.         sleep(1);
  27.     }
  28. }
  29. void * tidProduce(void * arg)    //线程函数写 加1
  30. {
  31.     int cnt = 0;
  32.     while(cnt++ < 100)
  33.     {
  34.         pthread_rwlock_wrlock(&rwlock);    //写锁
  35.         
  36.         product++;
  37.         printf("Produce: product = %d\n", product);
  38.         
  39.         pthread_rwlock_unlock(&rwlock);    //解锁
  40.         sleep(1);
  41.     }
  42. }
  43. void * threadConsume(void * arg)    //线程函数写 减1
  44. {
  45.     int cnt = 0;
  46.     while(cnt++ < 100)
  47.     {
  48.         pthread_rwlock_wrlock(&rwlock);    //写锁
  49.         
  50.         product--;
  51.         printf("Consume: product = %d\n", product);
  52.         
  53.         pthread_rwlock_unlock(&rwlock);    //解锁
  54.         sleep(2);
  55.     }
  56. }
  57. int main(void)
  58. {
  59.     int i;
  60.     pthread_t tid[10], tidconsume, tidproduce;
  61.     
  62.     for(i = 0; i < 2; i++)
  63.     {
  64.         if(pthread_create(&tid[i], NULL, threadRead, 
  65. NULL))
  66.         {
  67.             printf("pthread_create error\n");
  68.             exit(0);
  69.         }
  70.     }
  71.     if(pthread_create(&tidproduce, NULL, tidProduce, NULL))
  72.     {
  73.         printf("pthread_create error\n");
  74.         exit(0);
  75.     }
  76.     if(pthread_create(&tidconsume, NULL, threadConsume, 
  77. NULL))
  78.     {
  79.         printf("pthread_create error\n");
  80.         exit(0);
  81.     }
  82.     pthread_exit(NULL);        //等待所有线程结束 
  83.     return 0;
  84. }
时间： 2024-10-30 22:09:15

嵌入式 互斥锁和读写锁区别的相关文章

PHP程序中的文件锁、互斥锁、读写锁使用技巧解析_php技巧

文件锁全名叫 advisory file lock, 书中有提及. 这类锁比较常见,例如 mysql, php-fpm 启动之后都会有一个pid文件记录了进程id,这个文件就是文件锁. 这个锁可以防止重复运行一个进程,例如在使用crontab时,限定每一分钟执行一个任务,但这个进程运行时间可能超过一分钟,如果不用进程锁解决冲突的话两个进程一起执行就会有问题. 使用PID文件锁还有一个好处,方便进程向自己发停止或者重启信号.例如重启php-fpm的命令为 kill -USR2 `cat /usr/

GO语言并发编程之互斥锁、读写锁详解_Golang

在本节,我们对Go语言所提供的与锁有关的API进行说明.这包括了互斥锁和读写锁.我们在第6章描述过互斥锁,但却没有提到过读写锁.这两种锁对于传统的并发程序来说都是非常常用和重要的. 一.互斥锁 互斥锁是传统的并发程序对共享资源进行访问控制的主要手段.它由标准库代码包sync中的Mutex结构体类型代表.sync.Mutex类型(确切地说,是*sync.Mutex类型)只有两个公开方法--Lock和Unlock.顾名思义,前者被用于锁定当前的互斥量,而后者则被用来对当前的互斥量进行解锁. 类型sy

嵌入式 自旋锁、互斥锁、读写锁、递归锁

互斥锁(mutexlock): 最常使用于线程同步的锁:标记用来保证在任一时刻,只能有一个线程访问该对象,同一线程多次加锁操作会造成死锁:临界区和互斥量都可用来实现此锁,通常情况下锁操作失败会将该线程睡眠等待锁释放时被唤醒 自旋锁(spinlock): 同样用来标记只能有一个线程访问该对象,在同一线程多次加锁操作会造成死锁:使用硬件提供的swap指令或test_and_set指令实现:同互斥锁不同的是在锁操作需要等待的时候并不是睡眠等待唤醒,而是循环检测保持者已经释放了锁,这样做的好处是节省了线

UNIX环境高级编程：线程同步之互斥锁、读写锁和条件变量

一.使用互斥锁 1.初始化互斥量 pthread_mutex_t mutex =PTHREAD_MUTEX_INITIALIZER;//静态初始化互斥量 int pthread_mutex_init(pthread_mutex_t*mutex,pthread_mutexattr_t*attr);//动态初始化互斥量 int pthread_mutex_destory(pthread_mutex_t*mutex);//撤销互斥量 不能拷贝互斥量变量,但可以拷贝指向互斥量的指针,这样就可以使多个函数

Java多线程编程中线程锁与读写锁的使用示例_java

线程锁LockLock  相当于 当前对象的 Synchronized import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* * Lock lock = new ReentrantLock(); * lock.lock(); lock.unLock(); * 类似于 synchronized,但不能与synchronized 混用 */ public class Lo

嵌入式 Linux线程同步读写锁rwlock示例

读写锁比mutex有更高的适用性,可以多个线程同时占用读模式的读写锁,但是只能一个线程占用写模式的读写锁.1. 当读写锁是写加锁状态时,在这个锁被解锁之前,所有试图对这个锁加锁的线程都会被阻塞:2. 当读写锁在读加锁状态时,所有试图以读模式对它进行加锁的线程都可以得到访问权,但是以写模式对它进行枷锁的线程将阻塞:3. 当读写锁在读模式锁状态时,如果有另外线程试图以写模式加锁,读写锁通常会阻塞随后的读模式锁请求,这样可以避免读模式锁长期占用,而等待的写模式锁请求长期阻塞:这种锁适用对数据结构进行读

非一致性内存访问的读写锁

原文地址,译文地址,译者: 李杰聪,校对:郑旭东 原文作者: Irina Calciu         Brown University        irina@cs.brown.edu Dave Dice          Oracle Labs             dave.dice@oracle.com Yossi Lev           Oracle Labs             yossi.lev@oracle.com Victor Luchangco    Oracle

pthread_rwlock_t读写锁函数说明

转:http://www.cnblogs.com/renxinyuan/p/3875659.html 索引:  初始化一个读写锁pthread_rwlock_init 读锁定读写锁      pthread_rwlock_rdlock 非阻塞读锁定 pthread_rwlock_tryrdlock 写锁定读写锁      pthread_rwlock_wrlock 非阻塞写锁定      pthread_rwlock_trywrlock 解锁读写锁         pthread_rwlock_

Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁_java

在Java5.0之前,只有synchronized(内置锁)和volatile. Java5.0后引入了显示锁ReentrantLock. ReentrantLock概况 ReentrantLock是可重入的锁,它不同于内置锁, 它在每次使用都需要显示的加锁和解锁, 而且提供了更高级的特性:公平锁, 定时锁, 有条件锁, 可轮询锁, 可中断锁. 可以有效避免死锁的活跃性问题.ReentrantLock实现了 Lock接口: 复制代码 代码如下:   public interface Lock {