Linux 多线程同步机制(上)

简介: Linux 多线程同步机制(上)

前言


一、线程同步

在多线程环境下,多个线程可以并发地执行,访问共享资源(如内存变量、文件、网络连接  等)。
这可能导致 数据不一致性, 死锁, 竞争条件等 问题。
为了解决这些问题,需要使用同步机制来确保线程间的协作和互斥访问共享资源。

“同步” 的目的 是为了避免数据的混乱,解决与时间有关的错误。实际上,不仅线程需要同步,进程间,信号间等等都需要同步机制

线程同步,指一个线程发出某一功能调用时,在没有得到结果之前,该调用不返回。同时 其他线程为保证数据的一致性,不能调用该功能。

二、互斥量 mutex

互斥锁(Mutex,全称为 Mutual Exclusion)是一种常用的同步机制,用于保护共享资源免受多个线程同时访问和修改的影响。互斥锁提供了一种互斥访问的机制,同一时间只允许一个线程获取锁并访问被保护的资源。

每个线程在对资源操作前都尝试进行先加锁,成功加锁才能操作,操作结束解锁。

资源还是共享的,线程也还是竞争的。

但 通过 “锁” 就将资源的访问变成互斥操作,而后与时间有关的错误也就不会再产生了。

1. 互斥锁的基本操作包括两个关键操作:

  • 加锁(Lock):线程通过申请互斥锁来获取对共享资源的访问权。如果互斥锁当前未被其他线程获取,线程成功获得锁然后进入临界区(Critical Section),可以访问共享资源。如果互斥锁已经被其他线程获取,申请锁的线程将被阻塞,直到锁被释放。
  • 解锁(Unlock):线程在完成对共享资源的访问之后,释放互斥锁,使得其他线程可以申请并获取锁。

2. 互斥锁的主要应用函数 :

pthread_mutex_init: 用于初始化互斥锁变量。

pthread_mutex_destroy: 用于销毁互斥锁对象。

pthread_mutex_lock: 用于加锁,如果互斥锁已被其他线程占用,则当前线程阻塞。

pthread_mutex_trylock: 尝试加锁,如果互斥锁已被其他线程占用,则返回一个失败状态而不阻塞线程。

pthread_mutex_unlock: 用于解锁,释放互斥锁使其他线程可以获取。

3. 初始化线程锁 :

有两种方式可以对互斥锁进行初始化:静态初始化和动态初始化。

  • 静态初始化: 是在定义互斥锁变量时直接进行初始化,不需要调用特定的初始化函数。
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    PTHREAD_MUTEX_INITIALIZER 是一个宏,用于静态初始化互斥锁变量。
  • 动态初始化:动态初始化是在运行时使用初始化函数对互斥锁进行初始化。
    pthread_mutex_init(&mutex, NULL);

4. 示例代码

在下面代码中,main 函数中有一个主线程 打印小写字母,my_thread 为 子线程 打印 大写字母。两个线程通过互斥锁来访问 共享资源。

#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
pthread_mutex_t lock;             // 创建 互斥锁
void *my_thread(void *arg)
{
  srand(time(NULL));              // 设置随机种子
  while(1)
  {
    pthread_mutex_lock(&lock);
    printf("ABC ");
    sleep(rand() % 3);
    printf("XYZ\n");
    pthread_mutex_unlock(&lock);
    sleep(rand() % 3);              // 休眠随机秒,释放cpu资源
  }
  pthread_exit(NULL);
}
int main(void)
{
  pthread_t tid;
  int ret;
  srand(time(NULL));                  // 设置随机种子
  ret = pthread_mutex_init(&lock,  NULL);       // 初始化互斥锁
  if(ret != 0)
  {
    printf("pthread_mutex_init err\n");
  }
  ret = pthread_create(&tid, NULL, my_thread, NULL);
  if(ret != 0)
  {
    printf("pthread_create err\n");
  }
  while(1)
  {
    pthread_mutex_lock(&lock);
    printf("abc ");
    sleep(rand() % 3);
    printf("xyz\n");
    pthread_mutex_unlock(&lock);
    sleep(rand() % 3);
  }
  pthread_mutex_destroy(&lock);         // 销毁 互斥锁
  pthread_join(tid,NULL);             // 等待回收线程,获取回收状态
  return 0;
}

注意 :

锁粒度(Lock Granularity):锁的粒度应该尽可能小,以避免锁定过长时间,从而降低了并发性能。

三、死锁

死锁产生的原因:死锁是指多个线程或进程因为彼此相互等待对方所持有的资源而无法继续执行的状态。

解决:

  1. 使用资源的有序性:通过规定线程获取资源的顺序,避免出现循环等待的情况。例如,可以约定所有线程按照一定的顺序获取资源,从而避免死锁的发生。

如果下面两个线程 获取资源的顺序是相反的,则可能会产生死锁。可以将 线程 B 先获取 m1锁,再获取 m2锁。

以下面代码的方式获取锁,不会存在死锁风险。

#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void *my_thread1(void *arg)
{
  pthread_mutex_lock(&lock1);
  printf("my_thread1 : begin\n");
  pthread_mutex_lock(&lock2);
  printf("my_thread1 : end\n");
  pthread_mutex_unlock(&lock2);
  pthread_mutex_unlock(&lock1);
  pthread_exit(NULL);
}
void *my_thread2(void *arg)
{
  pthread_mutex_lock(&lock1);
  printf("my_thread2 : begin\n");
  pthread_mutex_lock(&lock2);
  printf("my_thread2 : end\n");
  pthread_mutex_unlock(&lock2);
  pthread_mutex_unlock(&lock1);
  pthread_exit(NULL);
}
int main(void)
{
  pthread_t tid1,tid2;
  int ret;
  ret = pthread_create(&tid1, NULL, my_thread1, NULL);
  if(ret != 0)
  {
    printf("pthread1_create err\n");
  }
  ret = pthread_create(&tid2, NULL, my_thread2, NULL);
  if(ret != 0)
  {
    printf("pthread2_create err\n");
  }
  pthread_join(tid1,NULL);
  pthread_join(tid2,NULL);
  return 0;
}
  1. 设置超时机制:在请求资源时,设置一个超时时间,在超过该时间后如果仍未获得资源,则放弃等待,释放已经获取的资源,避免长时间的死锁等待。

总结

相关文章
|
6月前
|
安全 算法 Java
Java 多线程:线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术,涵盖线程的创建与启动、线程安全问题及其解决方案,包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法,帮助开发者提升程序性能与稳定性。
274 0
|
11月前
|
存储 Linux API
【Linux进程概念】—— 操作系统中的“生命体”,计算机里的“多线程”
在计算机系统的底层架构中,操作系统肩负着资源管理与任务调度的重任。当我们启动各类应用程序时,其背后复杂的运作机制便悄然展开。程序,作为静态的指令集合,如何在系统中实现动态执行?本文带你一探究竟!
【Linux进程概念】—— 操作系统中的“生命体”,计算机里的“多线程”
|
9月前
|
并行计算 Linux
Linux内核中的线程和进程实现详解
了解进程和线程如何工作,可以帮助我们更好地编写程序,充分利用多核CPU,实现并行计算,提高系统的响应速度和计算效能。记住,适当平衡进程和线程的使用,既要拥有独立空间的'兄弟',也需要在'家庭'中分享和并行的成员。对于这个世界,现在,你应该有一个全新的认识。
314 67
|
存储 编译器 Linux
动态链接的魔法:Linux下动态链接库机制探讨
本文将深入探讨Linux系统中的动态链接库机制,这其中包括但不限于全局符号介入、延迟绑定以及地址无关代码等内容。
2153 141
|
9月前
|
存储 Linux
Linux内核中的current机制解析
总的来说,current机制是Linux内核中进程管理的基础,它通过获取当前进程的task_struct结构的地址,可以方便地获取和修改进程的信息。这个机制在内核中的使用非常广泛,对于理解Linux内核的工作原理有着重要的意义。
412 11
|
10月前
|
Ubuntu Linux
Linux系统管理:服务器时间与网络时间同步技巧。
以上就是在Linux服务器上设置时间同步的方式。然而,要正确运用这些知识,需要理解其背后的工作原理:服务器根据网络中的其他机器的时间进行校对,逐步地精确自己的系统时间,就像一只犹豫不决的啮齿动物,通过观察其他啮齿动物的行为,逐渐确定自己的行为逻辑,既简单,又有趣。最后希望这个过程既能给你带来乐趣,也能提高你作为系统管理员的专业素养。
1425 20
|
12月前
|
并行计算 安全 Java
Python GIL(全局解释器锁)机制对多线程性能影响的深度分析
在Python开发中,GIL(全局解释器锁)一直备受关注。本文基于CPython解释器,探讨GIL的技术本质及其对程序性能的影响。GIL确保同一时刻只有一个线程执行代码,以保护内存管理的安全性,但也限制了多线程并行计算的效率。文章分析了GIL的必要性、局限性,并介绍了多进程、异步编程等替代方案。尽管Python 3.13计划移除GIL,但该特性至少要到2028年才会默认禁用,因此理解GIL仍至关重要。
925 16
Python GIL(全局解释器锁)机制对多线程性能影响的深度分析
|
11月前
|
Linux
Linux编程: 在业务线程中注册和处理Linux信号
通过本文,您可以了解如何在业务线程中注册和处理Linux信号。正确处理信号可以提高程序的健壮性和稳定性。希望这些内容能帮助您更好地理解和应用Linux信号处理机制。
216 26
|
11月前
|
Linux
Linux编程: 在业务线程中注册和处理Linux信号
本文详细介绍了如何在Linux中通过在业务线程中注册和处理信号。我们讨论了信号的基本概念,并通过完整的代码示例展示了在业务线程中注册和处理信号的方法。通过正确地使用信号处理机制,可以提高程序的健壮性和响应能力。希望本文能帮助您更好地理解和应用Linux信号处理,提高开发效率和代码质量。
218 17
|
监控 算法 Linux
Linux内核锁机制深度剖析与实践优化####
本文作为一篇技术性文章,深入探讨了Linux操作系统内核中锁机制的工作原理、类型及其在并发控制中的应用,旨在为开发者提供关于如何有效利用这些工具来提升系统性能和稳定性的见解。不同于常规摘要的概述性质,本文将直接通过具体案例分析,展示在不同场景下选择合适的锁策略对于解决竞争条件、死锁问题的重要性,以及如何根据实际需求调整锁的粒度以达到最佳效果,为读者呈现一份实用性强的实践指南。 ####