线程同步与互斥：互斥锁

为什么需要互斥锁？

在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。

下面我们用程序模拟一下这个过程，线程一需要打印“ hello ”，线程二需要打印“ world ”，不加任何处理的话，打印出来的内容会错乱：

[cpp] view
plaincopy

  1. #include <stdio.h>
  2. #include <pthread.h>
  3. #include <unistd.h>
  4. // 打印机
  5. void printer(char *str)
  6. {
  7. while(*str!=‘\0‘)
  8. {
  9. putchar(*str);
  10. fflush(stdout);
  11. str++;
  12. sleep(1);
  13. }
  14. printf("\n");
  15. }
  16. // 线程一
  17. void *thread_fun_1(void *arg)
  18. {
  19. char *str = "hello";
  20. printer(str); //打印
  21. }
  22. // 线程二
  23. void *thread_fun_2(void *arg)
  24. {
  25. char *str = "world";
  26. printer(str); //打印
  27. }
  28. int main(void)
  29. {
  30. pthread_t tid1, tid2;
  31. // 创建 2 个线程
  32. pthread_create(&tid1, NULL, thread_fun_1, NULL);
  33. pthread_create(&tid2, NULL, thread_fun_2, NULL);
  34. // 等待线程结束，回收其资源
  35. pthread_join(tid1, NULL);
  36. pthread_join(tid2, NULL);
  37. return 0;
  38. }

运行结果如下：

实际上，打印机是有做处理的，我在打印着的时候别人是不允许打印的，只有等我打印结束后别人才允许打印。这个过程有点类似于，把打印机放在一个房间里，给这个房间安把锁，这个锁默认是打开的。当 A 需要打印时，他先过来检查这把锁有没有锁着，没有的话就进去，同时上锁在房间里打印。而在这时，刚好 B 也需要打印，B 同样先检查锁，发现锁是锁住的，他就在门外等着。而当 A 打印结束后，他会开锁出来，这时候 B 才进去上锁打印。

而在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。

互斥锁的操作流程如下：

1）在访问共享资源后临界区域前，对互斥锁进行加锁。

2）在访问完成后释放互斥锁导上的锁。

3）对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。

互斥锁的数据类型是： pthread_mutex_t。

互斥锁基本操作

以下函数需要的头文件：

#include <pthread.h>

1）初始化互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

功能：

初始化一个互斥锁。

参数：

mutex：互斥锁地址。类型是 pthread_mutex_t 。

attr：设置互斥量的属性，通常可采用默认属性，即可将 attr 设为 NULL。

可以使用宏 PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁，比如：

pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;

这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_mutex_init() 来完成动态初始化，不同之处在于 PTHREAD_MUTEX_INITIALIZER 宏不进行错误检查。

返回值：

成功：0，成功申请的锁默认是打开的。

失败：非 0 错误码

2）上锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

功能：

对互斥锁上锁，若互斥锁已经上锁，则调用者一直阻塞，直到互斥锁解锁后再上锁。

参数：

mutex：互斥锁地址。

返回值：

成功：0

失败：非 0 错误码

int pthread_mutex_trylock(pthread_mutex_t *mutex);

调用该函数时，若互斥锁未加锁，则上锁，返回 0；若互斥锁已加锁，则函数直接返回失败，即 EBUSY。

3）解锁

int pthread_mutex_unlock(pthread_mutex_t * mutex);

功能：

对指定的互斥锁解锁。

参数：

mutex：互斥锁地址。

返回值：

成功：0

失败：非 0 错误码

4）销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

功能：

销毁指定的一个互斥锁。互斥锁在使用完毕后，必须要对互斥锁进行销毁，以释放资源。

参数：

mutex：互斥锁地址。

返回值：

成功：0

失败：非 0 错误码

互斥锁应用实例

我们通过互斥锁完善上面的例子，示例代码如下：

[cpp] view
plaincopy

  1. #include <stdio.h>
  2. #include <pthread.h>
  3. #include <unistd.h>
  4. pthread_mutex_t mutex; //互斥锁
  5. // 打印机
  6. void printer(char *str)
  7. {
  8. pthread_mutex_lock(&mutex); //上锁
  9. while(*str!=‘\0‘)
  10. {
  11. putchar(*str);
  12. fflush(stdout);
  13. str++;
  14. sleep(1);
  15. }
  16. printf("\n");
  17. pthread_mutex_unlock(&mutex); //解锁
  18. }
  19. // 线程一
  20. void *thread_fun_1(void *arg)
  21. {
  22. char *str = "hello";
  23. printer(str); //打印
  24. }
  25. // 线程二
  26. void *thread_fun_2(void *arg)
  27. {
  28. char *str = "world";
  29. printer(str); //打印
  30. }
  31. int main(void)
  32. {
  33. pthread_t tid1, tid2;
  34. pthread_mutex_init(&mutex, NULL); //初始化互斥锁
  35. // 创建 2 个线程
  36. pthread_create(&tid1, NULL, thread_fun_1, NULL);
  37. pthread_create(&tid2, NULL, thread_fun_2, NULL);
  38. // 等待线程结束，回收其资源
  39. pthread_join(tid1, NULL);
  40. pthread_join(tid2, NULL);
  41. pthread_mutex_destroy(&mutex); //销毁互斥锁
  42. return 0;
  43. }

运行结果如下：

本教程示例代码下载请点此处。

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-09 18:43:35

线程同步与互斥：互斥锁的相关文章

线程同步机制之互斥锁通信机制

#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <string.h> void *thread_function(void *arg); pthread_mutex_t work_mutex; #define WORK_SIZE 1024 char work_area[WORK_SIZE]; int time_to_exit=0; int main(int argc,

线程同步：何时互斥锁不够，还需要条件变量?

http://www.blogjava.net/fhtdy2004/archive/2009/07/05/285519.html 线程同步:何时互斥锁不够,还需要条件变量? 很显然,pthread中的条件变量与Java中的wait,notify类似 假设有共享的资源sum,与之相关联的mutex 是lock_s.假设每个线程对sum的操作很简单的,与sum的状态无关,比如只是sum++.那么只用mutex足够了.程序员只要确保每个线程操作前,取得lock,然后sum++,再unlock即可.每个

Linux程序设计学习笔记----多线程编程线程同步机制之互斥量(锁)与读写锁

互斥锁通信机制 基本原理 互斥锁以排他方式防止共享数据被并发访问,互斥锁是一个二元变量,状态为开(0)和关(1),将某个共享资源与某个互斥锁逻辑上绑定之后,对该资源的访问操作如下: (1)在访问该资源之前需要首先申请互斥锁,如果锁处于开状态,则申请得到锁并立即上锁(关),防止其他进程访问资源,如果锁处于关,则默认阻塞等待. (2)只有锁定该互斥锁的进程才能释放该互斥锁. 互斥量类型声明为pthread_mutex_t数据类型,在<bits/pthreadtypes.h>中有具体的定义. 互斥量

第9章 线程编程（4）_线程同步1：互斥锁

5. 线程的互斥和同步 5.1 同步和互斥的概念 (1)线程同步:是一个宏观概念,在微观上包含线程的相互排斥和线程的先后执行的约束问题.解决同步方式一般采用条件变量和信号量. (2)线程互斥:线程执行的相互排斥(注意,它不关心线程间执行的先后顺序!).解决互斥一般使用互斥锁.读写锁和信号量. [编程实验]银行ATM(线程不安全的例子) //account.h #ifndef __ACCOUNT_H__ #define __ACCOUNT_H__ typedef struct { int code

线程同步机制之互斥锁

进程间通讯介绍 1.几种进程间的通信方式 # 管道( pipe ):管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用.进程的亲缘关系通常是指父子进程关系. # 有名管道 (named pipe) : 有名管道也是半双工的通信方式,但是它允许无亲缘关系进程间的通信. # 信号量( semophore ) : 信号量是一个计数器,可以用来控制多个进程对共享资源的访问.它常作为一种锁机制,防止某进程正在访问共享资源时,其他进程也访问该资源.因此,主要作为进程间以及同一进

线程同步方式之互斥量Mutex

互斥量和临界区非常相似,只有拥有了互斥对象的线程才可以访问共享资源,而互斥对象只有一个,因此可以保证同一时刻有且仅有一个线程可以访问共享资源,达到线程同步的目的. 互斥量相对于临界区更为高级,可以对互斥量进行命名,支持跨进程的线程同步.互斥量是调用的Win32的API对互斥锁的操作,因此在同一操作系统下不同进程可以按照互斥锁的名称共享锁. 正因为如此,互斥锁的操作会更好资源,性能上相对于临界区也有降低,在使用时还要多斟酌.对于进程内的线程同步使用临界区性能会更佳. 在.Net中使用Mutex类来

python-多线程同步中创建互斥锁解决资源竞争的问题

import threadingimport time # 定义一个全局变量g_num = 0 def test1(num): global g_num for i in range(num): g_num += 1 print('-------in test1 g_num={}'.format(g_num)) def test2(num): global g_num for i in range(num): g_num += 1 print('-------in test1 g_num={}'

VC++线程同步(二) Mutex互斥量的例子

同步对象使用实例 Win32窗口的建立: 我们将要学习的使用,分别是:互斥量,临界区,事件,信号量.所以我们需要一个窗口,呈现四种四种同步对象状态. 首先创建一个Win32项目,不要选空项目; 我们需要四个小窗口,先找到注册主窗口的代码. ATOM MyRegisterClass(HINSTANCE hInstance) { WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style= CS_HREDRAW | CS_VREDRAW

C# 多线程编程第二步——线程同步与线程安全

上一篇博客学习了如何简单的使用多线程.其实普通的多线程确实很简单,但是一个安全的高效的多线程却不那么简单.所以很多时候不正确的使用多线程反倒会影响程序的性能. 下面先看一个例子 : class Program { static int num = 1; static void Main(string[] args) { Stopwatch stopWatch = new Stopwatch(); //开始计时 stopWatch.Start(); ThreadStart threadStart

说说C# 多线程那些事-线程同步和线程优先级

上个文章分享了一些多线程的一些基础的知识,今天我们继续学习. 努力学习,成为最好的自己. 一.Task类 上次我们说了线程池,线程池的QueueUserWorkItem()方法发起一次异步的线程执行很简单 但是该方法最大的问题是没有一个内建的机制让你知道操作什么时候完成,有没有一个内建的机制在操作完成后获得一个返回值.为此,可以使用System.Threading.Tasks中的Task类. 简单代码实现: using System; using System.Threading.Tasks;