linux 多核线程同步,Linux内核同步，进程，线程同步

朱雀 2023-01-21 09:20 8阅读 0赞

From:http://buaadallas.blog.51cto.com/399160/168011/

作者：buaadallas

关于作者的基本信息，请登陆作者的博客：

http://home.51cto.com/index.php?s=/space/399160

原文：

原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。

否则将追究法律责任。http://buaadallas.blog.51cto.com/399160/168011

包括我自己在内，很多人对内核，进程，线程同步都不是很清楚，下面稍微总结一下：

内核同步：

主要是防止多核处理器同时访问修改某段代码，或者在对设备驱动程序进行临界区保护。主要有一下几种方式：

1、Mutex(互斥)

头文件：

\#include

初始化方法：

DEFINE\_MUTEX(name);

或者

void mutex\_init (struct mutex \*lock);

使用方法：

void mutex\_lock (struct mutex \*lock);

尝试得到互斥量，否则进入睡眠，不能被中断，否则会导致进程无法杀死。

int mutex\_lock\_interruptible(struct mutex \*lock);

Same, but can be interrupted. If interrupted, returns a non zero value

and doesn't hold the lock.

Test the return value!!!

可以被中断

int mutex\_trylock (struct mutex \*lock);

Never waits. Returns a non zero value if the mutex is not avaiable.

无等待

int mutex\_is\_locked(struct mutex \*lock);

Just tells whether the mutex is locked or not.

void mutex\_unlock(struct mutex \*lock);

Releases the lock. Make sure you do it as quickly as possible!

2、Reader/writer semphopres 读写信号量

Allow shared access by unlimited readers, or by only 1 writer. Writers get priority.

允许有限数量的读访问，但是只能有一个写访问。

void init\_rwsem(struct rw\_semaphore \*sem);

void down\_read(struct rw\_semaphore \*sem);

int down\_read\_trylock(struct rw\_semaphore \*sem);

int up\_read(struct rw\_semaphore \*sem);

void down\_write(struct rw\_semaphore \*sem);

int down\_write\_trylock(struct rw\_semaphore \*sem);

int up\_write(struct rw\_semaphore \* sem);

Well suited for rare writes, holding the semaphore briefly.

Otherwise, readers get starved, waiting too long for the semaphore to be released.

3、Sinlocks自旋锁

初始化：

Static

sinlock\_t my\_lock = SPIN\_LOCK\_UNLOCKED;

Dynamic

void spin\_lock\_init(spinlock\_t \* lock);

使用：

void spin\_\[un\]lock(spinlock\_t \* lock);

Doesn't disable interrupts.

Used for locking in process context

(critical sections in which you do not want to sleep).

void spin\_lock\_irqsave / spin\_unlock\_irqrestore(spinlock\_t \*lock, unsigned long flags);

Disables / restores IRQs on the local CPU.

Typically used when the lock can be accessed in both process and interrupt context,

to prevent preemption by interrupts.

进程同步/通信

1、Semaphore信号量

semaphore sv = 1;

loop forever \{

P(sv);

critical code section;

V(sv);

noncritical code section;

头文件以及函数：

\#include

int semctl(int sem\_id, int sem\_num, int command, ...);

int semget(key\_t key, int num\_sems, int sem\_flags);

int semop(int sem\_id, struct sembuf \*sem\_ops, size\_t num\_sem\_ops);

2、Share Memory共享内存

头文件以及函数

\#include

void \* shmat(int shm\_id, const void \* shm\_addr, int shmflag);

int shmctl(int shm\_id, int cmd, struct shmid\_ds \*buf);

int shmdt(const void \* shm\_addr);

int shmget(key\_t key, size\_t size, int shmflg);

3、Message Queues消息队列

头文件以及函数

\#include

int msgctl(int msqid, int cmd, struct msqid\_ds \*buf);

int msgget(key\_t key, int msgflg);

int msgrcv(int msqid, void \*msg\_ptr, size\_t msg\_sz, long int msgtype, int msgflg);

int msgnd(int msgid, const void \*msg\_ptr, size\_t msg\_sz, int msgflg);

线程同步

1、semophore信号量

简单用法：

\#include

sem\_t bin\_sem;

res = sem\_init(&bin\_sem, 0, 0);

sem\_wait(&bin\_sem);

sem\_post(&bin\_sem);

sem\_destory(&bin\_sem);

2、Mutex互斥

头文件以及函数

\#include

int pthread\_mutex\_init(pthread\_mutex\_t \* mutex, const pthread\_mutexattr\_t \* mutexattr);

int pthread\_mutex\_lock(pthread\_mutex\_t \* mutex);

int pthread\_mutex\_unlock(pthread\_mutex\_t \* mutex);

int pthread\_mutex\_destroy(pthread\_mutex\_t \* mutex);

3、读写锁

头文件以及函数

\#include

int pthread\_rwlock\_init(pthread\_rwlock\_t \* restrict rwlock, const pthread\_rwlockattr\_t \* restrict attr);

int pthread\_rwlock\_destroy(pthread\_rwlock\_t \* rwlock);

int pthread\_rwlock\_rdlock(pthread\_rwlock\_t \* rwlock);

int pthread\_rwlock\_wrlock(pthread\_rwlock\_t \* rwlock);

int pthread\_rwlock\_unlock(pthread\_rwlock\_t \* rwlock);

int pthread\_rwlock\_tryrdlock(pthread\_rwlock\_t \* rwlock);

int pthread\_rwlock\_trywrlock(pthread\_rwlock\_t \* rwlock);

4、条件变量

\#include

pthread\_cond\_t cond = PTHREAD\_COND\_INITIALIZER;

int pthread\_cond\_init(pthread\_cond\_t \* cond, pthread\_condattr\_t \* cond\_attr);

int pthread\_cond\_signal(pthread\_cond\_t \* cond);

int pthread\_cond\_broadcast(pthread\_cond\_t \* cond);

int pthread\_cond\_wait(pthread\_cond\_t \* cond, pthread\_mutex\_t \* mutex);

int pthread\_cond\_timedwait(pthread\_cond\_t \* cond, pthread\_mutex\_t \* mutex, const struct timespec \* abstime);

int pthread\_cond\_destroy(pthread\_cond\_t \* cond);

linux 多核线程同步,Linux内核同步，进程，线程同步

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关【Linux】多线程互斥与同步

相关【Linux】线程同步

相关 linux 多核线程同步,Linux内核同步，进程，线程同步

相关 linux线程同步和进程同步的区别

相关 Linux线程同步屏障

相关进程同步和线程同步

相关【多线程-线程同步】

相关【Linux】线程同步

相关 Linux多线程——使用互斥量同步线程

相关 Linux多线程——使用信号量同步线程