线程同步技术

本文只是针对 POSIX 线程库功能接口与知识点的汇总罗列

库         :    /lib64/libpthread.so*

头文件  :    pthread.h

线程同步技术:

1.线程锁(互斥量)  pthread_mutext_t

定义在/usr/include/bits/pthredtypes.h  中

/*------------------------------------------------------------*/

typedef union

{

struct __pthread_mutex_s

{

int __lock;

unsigned int __count;

int __owner;

#ifdef __x86_64__

unsigned int __nusers;

#endif

/* KIND must stay at this position in the structure to maintain

binary compatibility.   */

int __kind;

#ifdef __x86_64__

int __spins;

__pthread_list_t __list;

# define __PTHREAD_MUTEX_HAVE_PREV 1

#else

unsigned int __nusers;

__extension__ union

{

int __spins;

__pthread_slist_t __list;

};

#endif

} __data;

char __size[__SIZEOF_PTHREAD_MUTEX_T];

long int __align;

} pthread_mutex_t;

/*------------------------------------------------------------*/

1-0.互斥量的种类：

A. PTHREAD_MUTEX_TIMED_NP

B. PTHREAD_MUTEX_RECURSIVE_NP

C. PTHREAD_MUTEX_ERRORCHECK_NP

D. PTHREAD_MUTEX_ADAPTIVE_NP

E. PTHREAD_MUTEX_FAST_N P

1-1.锁的初始化/销毁

pthread_mutex_t mutex;

1).  静态方式：mutex = PTHREAD_MUTEX_INITIALIZER ;

2).  动态方式：int pthread_mutex_init(pthread_mutex_t *restrict mutex,

const pthread_mutexattr_t *restrict attr);

^锁的种类由 attr结构指定

3).锁的销毁  ：  int pthread_mutex_destroy(pthread_mutex_t *mutex);

1-2.锁的属性设置  pthread_mutexattr_t

A.初始化/销毁  锁属性结构

int pthread_mutexattr_init(pthread_mutexattr_t *attr);

int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

B.设置/获取  锁属性(种类)

int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr, int *restrict type);

type 可选项：

PTHREAD_MUTEX_NORMAL

PTHREAD_MUTEX_ERRORCHECK

PTHREAD_MUTEX_RECURSIVE

PTHREAD_MUTEX_DEFAULT

PTHREAD_MUTEX_FAST_NP

1-3.加锁/解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,

const struct timespec *restrict abs_timeout);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

 

 

2.自旋锁 pthread_spinlock_t

与互斥锁类似，但不释放 CPU，适用于短程占用高频抢占式场景

2-0.自旋锁初始化/销毁

int pthread_spin_init(pthread_spinlock_t *lock, int pshared);

int pthread_spin_destroy(pthread_spinlock_t *lock);

注：pshared 可选项为：

PTHREAD_PROCESS_PRIVATE

PTHREAD_PROCESS_SHARED

2-1.自旋锁加解锁

int pthread_spin_lock(pthread_spinlock_t *lock);

int pthread_spin_trylock(pthread_spinlock_t *lock);

int pthread_spin_unlock(pthread_spinlock_t *lock);

 

 

3.读写锁 pthread_rwlock_t

用于读多写少场景

3-0.读写锁初始化/销毁

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,

const pthread_rwlockattr_t *restrict attr);

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

3-1.读写锁属性 pthread_rwlockattr_t

初始化/销毁

int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);

int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);

设置/获取  属性

int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared);

int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *

restrict attr, int *restrict pshared);

pshared 可选项为：

PTHREAD_PROCESS_PRIVATE

PTHREAD_PROCESS_SHARED

3-2.读写锁加解锁

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);     //读加锁

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);  //写加锁

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);  //解锁(读/写  通吃)

 

 

4.条件变量 pthread_cond_t

事件触发机制技术，与线程锁协同使用

4-0.条件变量初始化/销毁

int pthread_cond_init(pthread_cond_t *restrict cond,

const pthread_condattr_t *restrict attr);

int pthread_cond_destroy(pthread_cond_t *cond);

4-1.条件变量属性 pthread_condattr_t

初始化/销毁

int pthread_condattr_init(pthread_condattr_t *attr);

int pthread_condattr_destroy(pthread_condattr_t *attr);

设置/获取  属性

int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared);

int pthread_condattr_getpshared(const    pthread_condattr_t   *restrict attr,

int *restrict pshared);

pshared 可选项为：

PTHREAD_PROCESS_PRIVATE

PTHREAD_PROCESS_SHARED

4-2.等待条件变量

与线程锁协同工作，wait 之前应确保线程锁成功加锁，

下述 wait 函数内部率先解锁而后等待条件变化(挂起)，函数返回前再次加锁。

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);

int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,

const struct timespec *restrict abstime);

使用流程：

/*------------------------------------------------------------*/

pthread_mutex_lock(&mutex);

pthread_cond_wait(&cond,&mutex);    //内部先解锁，而后等条件，最后加锁后返回

pthread_mutex_unlock(&mutex);

/*------------------------------------------------------------*/

4-3.唤醒条件挂起线程

当其他线程完成工作释放条件时，唤醒其他线程

但条件变量是互斥使用，只可能有一个线程获得该条件控制权