Linux进程间锁:保证程序稳定运行的重要机制 (进程间锁 linux)

linux系统中,如果多个进程同时访问共享资源,就有可能出现竞争条件,导致程序崩溃、死锁等问题。为了解决这个问题,Linux内核提供了进程间锁机制,可以保证程序的稳定运行。

一、什么是进程间锁

进程间锁是Linux操作系统提供的多进程通信机制之一,它是一种锁机制,通过锁来控制进程对共享资源的访问。进程间锁有两种:互斥锁和读写锁。

互斥锁:是最常见的进程间锁,保证在同一时刻只有一个进程能够访问共享资源。如果一个进程在使用共享资源时占用了锁,那么其他进程就必须等待锁的释放才能访问共享资源。

读写锁:是一种特殊的互斥锁,用于控制读写操作的并发性。可以将一个共享资源分为读取和写入两个阶段,多个进程可以同时读取该共享资源,但只有一个进程能够进行写入操作。

进程间锁一般是在内核空间实现的,可以通过系统调用函数进行调用。Linux内核提供了下面这些函数用于操作进程间锁:

1. pthread_mutex_init 初始化互斥锁

2. pthread_mutex_lock 加锁

3. pthread_mutex_trylock 尝试加锁

4. pthread_mutex_unlock 解锁

5. pthread_rwlock_init 初始化读写锁

6. pthread_rwlock_rdlock 加读锁

7. pthread_rwlock_wrlock 加写锁

8. pthread_rwlock_unlock 解锁

9. pthread_mutex_destroy 销毁互斥锁

10. pthread_rwlock_destroy 销毁读写锁

二、进程间锁的作用

进程间锁可以解决多个进程同时访问共享资源的问题,保证程序的正常运行。假如没有进程间锁机制,如果多个进程同时访问同一块共享资源,就可能出现竞争条件,导致数据的不一致或者程序的死锁。有了进程间锁,就可以确保只有一个进程能够访问共享资源,避免了这些潜在的问题,保证了程序的稳定性。

进程间锁可以应用于多种情况,例如:

1、多个进程同时读取或写入一个文件时,需要使用读写锁机制。

2、多个进程同时对一块共享内存进行读写时,需要使用互斥锁机制。

3、多个进程同时使用网络服务、数据库等公共服务时,需要使用互斥锁或读写锁机制。

三、进程间锁的注意事项

1. 锁的范围:锁的粒度必须控制在最小范围内,避免一段不必要的代码也被锁住,从而影响程序的性能。

2. 锁的粒度:读写锁适合读操作比较多的情况,互斥锁适合写操作比较频繁的情况。

3. 锁的调用次数:锁的调用次数越少,程序的效率就越高。

4. 死锁:死锁是指多个进程之间相互等待对方的资源却无法释放自己的资源,从而导致程序崩溃。为了避免死锁,需要规划好进程之间的资源请求顺序,尽量避免循环依赖的情况。

五、

进程间锁是保证程序稳定运行的重要机制之一,它能够在多个进程同时访问同一共享资源时起到控制的作用,保证多个进程能够有序地访问共享资源,避免了数据的不一致和程序崩溃的问题。在使用进程间锁时,需要注意锁的范围和粒度,减少其调用次数,避免死锁的发生。

相关问题拓展阅读:

  • Linux系统内核首次加入锁定功能
  • Linux多进程和线程同步的几种方式

Linux系统内核首次加入锁定功能

Linux之父林纳斯·托瓦兹(Linus Torvalds)上周六宣布在新版Linux系统内晌乱核中首滚谨明次加入锁定功能。

这项名为“lockdown”的Linux内核新安全功能将作为L(Linux安全模块)出现在即将发布的Linux 5.4版本当中。

该功能默认情况下处于关闭状态,由于存在破坏现有系统的风险,因此用户可选使用。这项新功能的主要目的是通过防止root帐户与内核代码进行交互来加强用户态进程与内核代码之间的鸿沟。

启用后,新的“锁定”功能将限制Linux某些内核功能,即使对于root用户也大告是如此,这使得受到破坏的root帐户更难于破坏其余的系统内核。

托瓦兹表示:“启用后,各种内核功能都受到限制。 ” 这包括限制对内核功能的访问,这些功能可能允许通过用户级进程提供的代码执行任意代码;阻止进程写入或读取/ dev / mem和/ dev / kmem内存;阻止对打开/ dev / port的访问,以防止原始端口访问;加强内核模块签名等。

Linux是一种自由和开放源码的类UNIX 操作系统。该操作系统的内核由林纳斯·托瓦兹在1991年10月5日首次发布。在加上用户空间的应用程序之后,成为 Linux 操作系统。Linux也是最著名的自由软件和开放源代码软件。只要遵循GNU 通用公共许可证(GPL),任何个人和机构都可以自由地使用Linux 的所有底层源代码,也可以自由地修改和再发布。

Linux多进程和线程同步的几种方式

Linux 线程同步的橘蚂笑三种方法

线程的更大特点是资源的共享性,但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步,最常用的是互斥锁、条件变量和信号量。

一、互斥锁(mutex)

通过锁机制实现线程间的同步。

初始化锁。在Linux下,线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。

静态分配:pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

动态分配:int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);

加锁。对共享资源的访问,要对互斥量进行加锁,如果互斥量已经上了锁,调用线程会阻塞,直到互斥量被解锁。

int pthread_mutex_lock(pthread_mutex *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

解锁。在完成了对共享资源的访问后,要对互斥量进行解锁。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

销毁锁。锁在是使用完成后,需要进行销毁以释放资源。

int pthread_mutex_destroy(pthread_mutex *mutex);

view plain copy

#include

#include

#include

#include

#include “iostream”

using namespace std;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int tmp;

void* thread(void *arg)

{

cout

#include

#include “stdlib.h”

#include “unistd.h”

pthread_mutex_t mutex;

pthread_cond_t cond;

void hander(void *arg)

{

free(arg);

(void)pthread_mutex_unlock(&mutex);

}

void *thread1(void *arg)

{

pthread_cleanup_push(hander, &mutex);

while(1)

{

printf(“thread1 is running\n”);

pthread_mutex_lock(&mutex);

pthread_cond_wait(&cond, &mutex);

printf(“thread1 applied the condition\n”);

pthread_mutex_unlock(&mutex);

sleep(4);

}

pthread_cleanup_pop(0);

}

void *thread2(void *arg)

{

while(1)

{

printf(“thread2 is running\n”);

pthread_mutex_lock(&mutex);

pthread_cond_wait(&cond, &mutex);

printf(“thread2 applied the condition\n”);

pthread_mutex_unlock(&mutex);

sleep(1);

}

}

int main()

{

pthread_t thid1,thid2;

printf(“condition variable study!\n”);

pthread_mutex_init(&mutex, NULL);

pthread_cond_init(&cond, NULL);

pthread_create(&thid1, NULL, thread1, NULL);

pthread_create(&thid2, NULL, thread2, NULL);

sleep(1);

do

{

pthread_cond_signal(&cond);

}while(1);

sleep(20);

pthread_exit(0);

return 0;

}

view plain copy

#include

#include

#include “stdio.h”

#include “stdlib.h”

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

struct node

{

int n_number;

struct node *n_next;

}*head = NULL;

static void cleanup_handler(void *arg)

{

printf(“Cleanup handler of second thread./n”);

free(arg);

(void)pthread_mutex_unlock(&mtx);

}

static void *thread_func(void *arg)

{

struct node *p = NULL;

pthread_cleanup_push(cleanup_handler, p);

while (1)

{

//这个mutex主要是用来保证pthread_cond_wait的并发性

pthread_mutex_lock(&mtx);

while (head == NULL)

{

//这个while要特别说明一下,单个pthread_cond_wait功能很完善,为何

//这里要有一个while (head == NULL)呢?因为pthread_cond_wait里的线

//程可能会被意外唤醒,如果这个时候head != NULL,则不是我们想要的情况。

//这个时候,应该让线程继续进入pthread_cond_wait

// pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx,

//然后阻塞在等待对列里休眠,直到再次被唤醒(大多数情况下是等待的条件成立

//而被唤醒,唤醒后,该进程会先锁定先pthread_mutex_lock(&mtx);,再读取资源

//用这个流程是比较清楚的

pthread_cond_wait(&cond, &mtx);

p = head;

head = head->n_next;

printf(“Got %d from front of queue/n”, p->n_number);

free(p);

}

pthread_mutex_unlock(&mtx); //临界区数据操作完毕,释放互斥锁

}

pthread_cleanup_pop(0);

return 0;

}

int main(void)

{

pthread_t tid;

int i;

struct node *p;

//子线程会一直等待资源,类似生产者和消费者,但是这里的消费者可以是多个消费者,而

//不仅仅支持普通的单个消费者,这个模型虽然简单,但是很强大

pthread_create(&tid, NULL, thread_func, NULL);

sleep(1);

for (i = 0; i n_number = i;

pthread_mutex_lock(&mtx); //需要操作head这个临界资源,先加锁,

p->n_next = head;

head = p;

pthread_cond_signal(&cond);

pthread_mutex_unlock(&mtx); //解锁

sleep(1);

}

printf(“thread 1 wanna end the line.So cancel thread 2./n”);

//关于pthread_cancel,有一点额外的说明,它是从外部终止子线程,子线程会在最近的取消点,退出

//线程,而在我们的代码里,最近的取消点肯定就是pthread_cond_wait()了。

pthread_cancel(tid);

pthread_join(tid, NULL);

printf(“All done — exiting/n”);

return 0;

}

三、信号量(sem)

如同进程一样,线程也可以通过信号量来实现通信,虽然是轻量级的。信号量函数的名字都以”sem_”打头。线程使用的基本信号量函数有四个。

信号量初始化。

int sem_init (sem_t *sem , int pshared, unsigned int value);

这是对由sem指定的信号量进行初始化,设置好它的共享选项(linux 只支持为0,即表示它是当前进程的局部信号量),然后给它一个初始值VALUE。

等待信号量。给信号量减1,然后等待直到信号量的值大于0。

int sem_wait(sem_t *sem);

释放信号量。信号量值加1。并通知其他等待线程。

int sem_post(sem_t *sem);

销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。

int sem_destroy(sem_t *sem);

view plain copy

#include

#include

#include

#include

#include

#include

#define return_if_fail(p) if((p) == 0){printf (“:func error!/n”, __func__);return;}

typedef struct _PrivInfo

{

sem_t s1;

sem_t s2;

time_t end_time;

}PrivInfo;

static void info_init (PrivInfo* thiz);

static void info_destroy (PrivInfo* thiz);

static void* pthread_func_1 (PrivInfo* thiz);

static void* pthread_func_2 (PrivInfo* thiz);

int main (int argc, char** argv)

{

pthread_t pt_1 = 0;

pthread_t pt_2 = 0;

int ret = 0;

PrivInfo* thiz = NULL;

thiz = (PrivInfo* )malloc (sizeof (PrivInfo));

if (thiz == NULL)

{

printf (“: Failed to malloc priv./n”);

return -1;

}

info_init (thiz);

ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);

if (ret != 0)

{

perror (“pthread_1_create:”);

}

ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);

if (ret != 0)

{

perror (“pthread_2_create:”);

}

pthread_join (pt_1, NULL);

pthread_join (pt_2, NULL);

info_destroy (thiz);

return 0;

}

static void info_init (PrivInfo* thiz)

{

return_if_fail (thiz != NULL);

thiz->end_time = time(NULL) + 10;

sem_init (&thiz->s1, 0, 1);

sem_init (&thiz->s2, 0, 0);

return;

}

static void info_destroy (PrivInfo* thiz)

{

return_if_fail (thiz != NULL);

sem_destroy (&thiz->s1);

sem_destroy (&thiz->s2);

free (thiz);

thiz = NULL;

return;

}

static void* pthread_func_1 (PrivInfo* thiz)

{

return_if_fail(thiz != NULL);

while (time(NULL) end_time)

{

sem_wait (&thiz->s2);

printf (“pthread1: pthread1 get the lock./n”);

sem_post (&thiz->s1);

printf (“pthread1: pthread1 unlock/n”);

sleep (1);

}

return;

}

static void* pthread_func_2 (PrivInfo* thiz)

{

return_if_fail (thiz != NULL);

while (time (NULL) end_time)

{

sem_wait (&thiz->s1);

printf (“pthread2: pthread2 get the unlock./n”);

sem_post (&thiz->s2);

printf (“pthread2: pthread2 unlock./n”);

sleep (1);

}

return;

}

版权声明:本文采用知识共享 署名4.0国际许可协议 [BY-NC-SA] 进行授权
文章名称:《Linux进程间锁:保证程序稳定运行的重要机制 (进程间锁 linux)》
文章链接:https://zhuji.vsping.com/53149.html
本站资源仅供个人学习交流,请于下载后24小时内删除,不允许用于商业用途,否则法律问题自行承担。