Linux之线程处理函数

Linux的线程处理函数需包含头文件：#include <pthread.h>

一、线程函数：成功则返回0，出错则返回错误编号

1 线程创建

• int pthread_create(pthread_t *tidp, const pthread_attr_t *attr, void *(*start_rtn)(void *), void *arg);

2 线程终止

• void pthread_exit(void *rval_ptr);

3 线程等待：只能用于等待非分离线程

• int pthread_join(pthread_t thread, void **rval_ptr);

4 线程取消

• int pthread_cancel(pthread_t tid);

5 线程分离：使得线程终止时其资源立即被系统回收，而非分离状态则需要pthread_join来释放资源

• int pthread_detach(pthread_t tid); 

6 获取线程ID

• pthread_t pthread_self(void); //返回调用线程的线程ID

二、同步函数：成功则返回0，出错则返回错误编号

1 互斥量

（1）初始化和销毁

• pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
  
• int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
• int pthread_mutex_destroy(pthread_mutex_t *mutex);

（2）加锁

• int pthread_mutex_lock(pthread_mutex_t *mutex);
• int pthread_mutex_trylock(pthread_mutex_t *mutex);
• int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *tsptr);

（3）解锁

• int pthread_mutex_unlock(pthread_mutex_t *mutex);

2 条件变量：和互斥量mutex搭配一起使用

（1）初始化和销毁

• pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 
  
• int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
• int pthread_cond_destroy(pthread_cond_t *cond);

（2）等待条件变量

• 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 *tsptr);

（3）发信号

• int pthread_cond_signal(pthread_cond_t *cond);
• int pthread_cond_broadcast(pthread_cond_t *cond);

代码举例：

 1 //1 等待条件
 2 pthread_mutex_lock(&lock);     ------上锁
 3 while(条件不成立)
 4 {
 5     pthread_cond_wait(&cond);  ------条件不成立时挂起等待（注意是while）
 6 }
 7 进行操作......                  ------修改、操作
 8 pthread_mutex_unlock(&lock);   ------解锁
 9 
10 //2 给条件发信号
11 pthread_mutex_lock(&lock);     ------上锁
12 设置条件为真...                 ------符合条件
13 pthread_cond_signal(&cond);    ------唤醒
14 pthread_mutex_unlock(&lock);   ------解锁

注意：如果是只有一个资源且广播信号让多个线程等到条件，为防止除第一个以外的线程误以为拿到资源，所以用while循环而不是if语句；

3 读写锁

（1）初始化和销毁

• int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
• int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

（2）加读锁

• int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
• int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
• int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *tsptr);

（3）加写锁

• int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
• int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
• int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *tsptr);

（4）解锁

• int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

4 自旋锁

（1）初始化和销毁

• int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
• int pthread_spin_destroy(pthread_spinlock_t *lock);

（2）加锁

• int pthread_spin_lock(pthread_spinlock_t *lock);
• int pthread_spin_trylock(pthread_spinlock_t *lock)

（3）解锁

• int pthread_spin_unlock(pthread_spinlock_t *lock);

三、线程属性函数：成功则返回0，出错则返回错误编号

1 初始化和销毁

• int pthread_attr_init(pthread_attr_t *attr);
• int pthead_attr_destroy(pthread_attr_t *attr);

2 分离属性---PTHREAD_CREATE_DETACHED

• int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
• int pthread_attr_setdetachstate(const pthread_attr_t *attr, int detachstate); 

3 栈属性

• int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
• int pthread_attr_setstacksize(const pthread_attr_t *attr, size_t stacksize);

四、同步属性函数

1 互斥量

（1）初始化和销毁

• int pthread_mutexattr_init(pthread_mutexattr_t *attr);
• int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

（2）进程共享属性---PHTEAD_PROCESS_PRIVATE(默认值)或PTHREAD_PROCESS_SHARED

• int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared);
• int pthread_mutexattr_setpshared(const pthread_mutexattr_t *attr, int pshared);

（3）健壮属性：解决持有互斥量的进程意外终止却没有释放互斥量---PTHREAD_MUTEX_STALLED(默认值)或PTHREAD_MUTEX_ROBUST

• int pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr, int *robust);
• int pthread_mutexattr_setrobust(const pthread_mutexattr_t *attr, int robust);
• int pthread_mutexattr_consistent(const pthread_mutexattr_t *attr);？？？？？？

（4）类型属性---PHREAD_MUTEX_RECURSIVE

• int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);
• int pthread_mutexattr_settype(const pthread_mutexattr_t *attr, int type);

2 条件变量

（1）初始化和销毁

• int pthread_condattr_init(pthread_condattr_t *attr);
• int pthread_condattr_destroy(pthread_condattr_t *attr);

（2）进程共享属性---同互斥量mutex

• int pthread_condattr_getpshared(pthread_condattr_t *attr, int *pshared);
• int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared);

（3）时钟属性：控制pthead_cond_timedwait函数的超时参数采用哪个时钟---CLOCK_REALTIME或CLOCK_MONOTONIC

• int pthread_condattr_getclock(pthread_condattr_t *attr, clockid_t *clock_id);
• int pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t clock_id);

3 读写锁

（1）初始化和销毁

• int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
• int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);

（2）进程共享属性---同互斥量mutex

• int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr, int *pshared);
• int pthread_rwlockattr_setpshared(const pthread_rwlockattr_t *attr, int pshared);

转载于:https://www.cnblogs.com/bo1990/p/11384274.html