Unix pthread

线程概念

每个线程都包括线程ID、一组寄存器值、栈、调度优先级、策略、信号屏蔽字、errno变量、线程私有数据。使用_POSIX_THREADS来测试是否支持这个功能，使用_SC_THREADS运行时确定，都需要添加#include <pthread.h>，对于pthread库的函数成功返回0，错误返回错误编号。

线程标识

使用thread_t来标识一个线程，在不同系统中实现不一样，需要使用函数来比较。

int pthread_equal(pthread_t t1, pthread_t t2);
// 相等返回非0值

获取自身线程pthread_t

pthread_t pthread_self(void);

通过线程pthread_t来分配任务如图所示：

创建线程

int pthread_create(pthread_t *restrict tidp,
                   cosnt pthread_attr_t *restrict attr,
                   void *(start_rtn)(void *), void *restrict arg);
// 失败时返回错误码

attr用于定制线程的属性，为NULL时是默认属性。新创建的线程从start_rtn开始运行，将参数放到结构体中，通过void *restrict arg传递。

例子：获取线程id

#include "../include/apue.h"
#include <pthread.h>

pthread_t ntid;

void printids(const char *s)
{
  pid_t pid;
  pthread_t tid;

  pid = getpid();
  tid = pthread_self();
  printf("%s pid:%lu, tid:%lu\n", s, pid, tid);
}

void *thread_func(void * arg)
{
  printids("new~~~");
  sleep(1);
  return (void*)0;
}

int main(void) {
  int err;
  err = pthread_create(&ntid, NULL, thread_func, NULL); // 第二个是pthread线程参数， 第四个是函数参数
  if (err != 0) {
    err_exit(err, "can't create thread");
  }
  printids("main~~~");
  // sleep(1);
  exit(0);
}

如果新线程睡眠1s，然后主线程退出就不会输出新线程了。如果主线程睡眠1s，则两个线程的进程号相同。在Linux里输出如下:

main~~~ pid:8081, tid:139790962181888
new~~~ pid:8081, tid:139790953903872

线程终止

在任意线程中调用exit、_Exit、_exit都会将整个进程终止。线程终止的方法有三种：

1. 从线程启动函数中返回
2. 线程被同一进程中的其他线程取消
3. 线程调用pthread_exit

void pthread_exit(void * rval_ptr);
// rval_ptr指向返回值

也就是把需要返回的状态传进去，用于和等待的线程通信。可以使用pthread_join来等待指定线程完成

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);

如果被等待的线程返回，rval_ptr包含返回码，如果线程被取消，rval_ptr指定内存单元设置为PTHREAD_CANCELED。

例子：获取已终止线程退出码

#include "../include/apue.h"
#include <pthread.h>

void printids(const char *s)
{
  pid_t pid;
  pthread_t tid;

  pid = getpid();
  tid = pthread_self();
  printf("%s pid:%lu, tid:%lu\n", s, (long unsigned)pid, (long unsigned)tid);
}

void *return_thread(void * arg)
{
  printids("thread returning~~~");
  return (void*)0;
}
void *exit_thread(void * arg)
{
  printids("thread exiting~~~");
  pthread_exit((void*) 2); // 参数可以返回结构体，但是这个结构体必须返回后还能使用（不是在栈上分配）
}

int main(void) {
  int err;
  pthread_t tid1, tid2;
  void * rVal;
  err = pthread_create(&tid1, NULL, return_thread, NULL); // 第二个是pthread线程参数， 第四个是函数参数
  if (err != 0) {
    err_exit(err, "can't create thread");
  }
  err = pthread_create(&tid2, NULL, exit_thread, NULL); // 第二个是pthread线程参数， 第四个是函数参数
  if (err != 0) {
    err_exit(err, "can't create thread");
  }
  pthread_join(tid1, &rVal);
  printf("return_thread return:%ld\n", (long)rVal);

  pthread_join(tid2, &rVal);
  printf("exit_thread return:%ld\n", (long)rVal);
  printids("main~~~");
  // sleep(1);
  exit(0);
}

程序输出结果如下：

thread returning~~~ pid:5832, tid:139867556669184
thread exiting~~~ pid:5832, tid:139867548276480
return_thread return:0
exit_thread return:2
main~~~ pid:5832, tid:139867564947200

取消其他线程

int pthread_cancel(pthread_t tid);

pthrea_cancel不等待线程终止，而是提出请求。

线程清理函数

线程安排自己的退出函数，多个清理函数会注册到栈中，按找栈里顺序执行。

void pthread_cleanup_push(void (*rtn)(void *), void *arg);
void pthread_cleanup_pop(int execute);

触发时机：

• 调用pthread_exit时
• 响应取消请求时
• 使用非零execute参数调用pthread_cleanup_pop,使用pthread_cleanup_pop(0)不会调用清理函数，只是删除清理函数。

例子：线程清理

输出：

thread 1 start up
thread 2 start up
thread1 return:1
clean up in thread2 second handler
clean up in thread2 first handler
thread2 return:2
main~~~ pid:10122, tid:140514088802048

只有第二个线程的清理函数被调用，这是因为系统正常终止是不会调用清理函数，即return结束

线程与进程对比

进程原语	线程原语	描述
fork	pthread_create	创建新的控制流
exit	pthread_exit	从现有控制流退出
waitpid	pthread_join	从控制流中得到退出状态
atexit	pthread_cleanup_push	注册在退出时调用的函数
getpid	pthread_self	获取控制流的ID
abort	pthread_cancel	请求控制流的非正常退出

分离线程

int pthread_detach(pthread_t tid);

线程同步

当线程B在线程A的读写间隔中读取数据就会出现不一致的值：

在存储操作需要多个总线周期时：

互斥变量

互斥变量本质是一把锁。对互斥量加锁后，任何试图再次对互斥量加锁的线程都会被阻塞。释放互斥量后，其他阻塞的线程变为可运行状态，第一个变为可运行状态的线程对互斥量加锁，其他变量依然变为阻塞。
互斥变量使用pthrea_mutex_t数据表示，使用前必须初始化，可以设置为pthread_mutex_t t = PTHREAD_MUTEX_INITIALIZER;用于静态初始化互斥量。

int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                       const pthread_mutexattr_t *restrict attr);// 使用函数初始化
int pthread_mutex_destroy(pthread_mutex_t *mutex); // 使用malloc动态生成的，需要desotry函数销毁

加锁与解锁操作：

int pthread_mutex_lock(pthread_muex_t *mutex);
int pthread_mutex_trylock(pthread_muex_t *mutex); // 线程不希望被阻塞，就使用trylock，成功返回0, 失败返回EBUSY
int pthread_mutex_unlock(pthread_muex_t *mutex);

例子：互斥锁

#include "../include/apue.h"
#include <pthread.h>

struct foo {
  int f_count;
  pthread_mutex_t f_lock;
  int f_id;
};

struct foo * foo_alloc(int id) {
  struct foo *fp;

  if ((fp=malloc(sizeof(struct foo))) != NULL) {
    fp->f_count = 1;
    fp->f_id = id;
    if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
      free(fp);
      return (NULL);
    }
  }
  return fp;
}

void foo_hold(struct foo *fp) {
  pthread_mutex_lock(&fp->f_lock);
  fp->f_count++;
  pthread_mutex_unlock(&fp->f_lock);
}

void foo_release(struct foo *fp) {
  pthread_mutex_lock(&fp->f_lock);
  if (--fp->f_count == 0) {
    pthread_mutex_unlock(&fp->f_lock);
    pthread_mutex_destroy(&fp->f_lock);
    free(fp);
  } else {
    printf("id:%d count:%d\n", fp->f_id, fp->f_count);
    pthread_mutex_unlock(&fp->f_lock);
  }
}
void * thread(void* arg) {
  struct foo* f = (struct foo*)arg;
  foo_hold(f);
}
int main(int argc, char const *argv[])
{
  pthread_t tid;
  struct foo* f = foo_alloc(12);
  pthread_create(&tid, NULL, thread, (void*)f);
  pthread_create(&tid, NULL, thread, (void*)f);

  pthread_join(tid, NULL);
  foo_release(f);
  foo_release(f);
  return 0;
}

可以看到结果中第一次释放foo时count为2，每次运行都是。

id:12 count:2
id:12 count:1

避免死锁

当线程对同一互斥量加锁两次时就会死锁。通过仔细控制互斥量加锁顺序来避免死锁发生。另一种方法: 如果已经占有某些锁，则使用pthread_mutex_trylock，如果成功则继续，如果失败则释放锁，做好清理工作，等待一段时间后再试试。

当程序师徒获取一个已加锁的互斥量时，pthread_mutex_timedlock互斥量原语绑定线程阻塞的时间。到达超时时间后pthread_mutex_timedlock不会对互斥量加锁而是返回错误码ETIMEDOUT

#include <pthread.h>
#include <time.h>
int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const struct timespec *restrict tsptr);

#include <time.h>中的timespec使用秒和纳秒描述时间。

struct timespec
{
    __time_t tv_sec;		/* Seconds.  */
    __syscall_slong_t tv_nsec;	/* Nanoseconds.  */
 };

#include <time.h>中的tm表示年月日星期等。

struct tm
{
  int tm_sec;			/* Seconds.	[0-60] (1 leap second) */
  int tm_min;			/* Minutes.	[0-59] */
  int tm_hour;			/* Hours.	[0-23] */
  int tm_mday;			/* Day.		[1-31] */
  int tm_mon;			/* Month.	[0-11] */
  int tm_year;			/* Year	- 1900.  */
  int tm_wday;			/* Day of week.	[0-6] */
  int tm_yday;			/* Days in year.[0-365]	*/
  int tm_isdst;			/* DST.		[-1/0/1]*/
}

例子：pthread_mutex_timedlock阻塞时间

#include "../include/apue.h"
#include <pthread.h>

void printTime() {
  char buf[64];
  struct timespec tout;
  struct tm* tmp;
  clock_gettime(CLOCK_REALTIME, &tout);
  tmp = localtime(&tout.tv_sec);
  strftime(buf, sizeof(buf), "%r", tmp);
  printf("current time is %s\n", buf);

}
int main(int argc, char const *argv[])
{
  int err;
  struct timespec tout;
  struct tm *tmp;
  pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

  printTime();

  pthread_mutex_lock(&lock);
  printf("mutex is lock\n");

  clock_gettime(CLOCK_REALTIME, &tout);
  tout.tv_sec += 10;
  pthread_mutex_timedlock(&lock, &tout);

  printTime();
  return 0;
}

因为已经获得了lock的锁，再次用pthread_mutex_lock锁住会导致死锁，使用pthread_mutex_timedlock只会阻塞指定时间。 输出结果如下，只阻塞了10秒

current time is 06:55:12 PM
mutex is lock
current time is 06:55:22 PM

读写锁（共享互斥锁）

读写锁有三种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁

1. 当写锁已加锁时，试图对其加锁会使线程阻塞
2. 在读锁已加锁时，试图对其加读锁的线程获得访问权，若对其加写锁会使线程阻塞，直到所以线程释放读锁
3. 读写锁适用于对数据结构读取次数远大于写入的情况

读写锁必须在使用前初始化、使用后释放内存前销毁

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                        const pthread_rwlockattr_t *restrict attr);
// 初始化函数，如果读写锁默认属性则传入null给attr

int pthread_rwlock_destroy(pthread_rwlock_t * rwlock);
// 在free前调用

pthread_rwlock_t lock = PTHREAD_RWLOCK_INITIALIZER;  // 静态初始化（Signle UNIX Specification）

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); // 条件版本（Signle UNIX Specification）
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); // 条件版本（Signle UNIX Specification）
// 获得锁是返回0，否则返回错误EBUSY

例子：读写锁（共享互斥锁）

作业队列，使用单个读写锁保护队列，插入、删除会尝试给队列加写锁，查找队列时会给队列加读锁。

#include "../include/apue.h"
#include <pthread.h>

struct job {
  struct job *j_next;
  struct job *j_prev;
  pthread_t j_id; // 哪一个线程处理这个任务
};

struct queue {
  struct job *q_head;
  struct job *q_tail;
  pthread_rwlock_t q_lock;
};

int queue_init(struct queue *qp) {
  int err;
  qp->q_head = NULL;
  qp->q_tail = NULL;
  err = pthread_rwlock_init(&qp->q_lock);
  if (err != 0) {
    return err;
  }
  return 0;
}

// 从队列后面插入job
void job_insert_tail(struct queue *qp, struct job *jp) {
  pthread_rwlock_wrlock(&qp->q_lock);
  jp->j_next = NULL;
  jp->j_prev = qp->q_tail;
  if (qp->q_tail != NULL) {
    qp->q_tail->j_next = jp;
  } else {
    qp->q_head = jp; // 链表为空
  }
  qp->q_tail = jp;
  pthread_rwlock_unlock(&qp->q_lock);
}

// 从队列前面插入job
void job_insert_front(struct queue *qp, struct job *jp) {
  pthread_rwlock_wrlock(&qp->q_lock);
  jp->j_next = qp->q_head;
  jp->j_prev = NULL;
  if (qp->q_head != NULL) {
    qp->q_head->j_prev = jp;
  } else {
    qp->q_tail = jp; // 链表为空
  }
  qp->q_head = jp;
  pthread_rwlock_unlock(&qp->q_lock);
}

// 从队列中删除job
void job_remove(struct queue *qp, struct job *jp) {
  pthread_rwlock_wrlock(&qp->q_lock);
  if (jp == qp->q_head) {
    qp->q_head = jp->j_next;
    if (jp == qp->q_tail) {
      qp->q_tail = NULL;
    } else {
      jp->j_next->j_prev = jp->j_prev;
    }
  } else if (jp == qp->q_tail) {
    jp->j_prev->j_next = jp->j_next;
    qp->q_tail = jp->j_prev;
  } else {
    jp->j_prev->j_next = jp->j_next;
    jp->j_next->j_prev = jp->j_prev;
  }
  pthread_rwlock_unlock(&qp->q_lock);
}

// 通过线程id查找某个任务
struct job* job_find(struct queue *qp, pthread_t id) {
  struct job* jp;
  if (pthread_rwlock_rdlock(&qp->q_lock) != 0) {
    return NULL;
  }
  for (jp = qp->q_head; jp != NULL; jp = jp->j_next) {
    if (pthread_equal(jp->j_id, id)) {
      printf("Find you!\n");
      break;
    }
  }
  pthread_rwlock_unlock(&qp->q_lock);
  return jp;
}

每次只能有一个写锁，所以对于job结构体不需要对它加锁。

带有超时的读写锁(Single UNIX Specification)

int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock,
                               const struct timespec *restrict tsptr);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock,
                               const struct timespec *restrict tsptr);

超时会返回ETIMEDOUT

条件变量

条件变量有互斥量保护，线程在改变条件状态之前首先锁住互斥量，锁住后计算条件。

// 1.动态初始化
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);`
// 2.静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;`

// 销毁方式：
int pthread_cond_destroy(pthread_cond_t *cond);

// 等待条件变量变为真
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 tsptr);

使用互斥量对条件进行保护，调用者把锁住的互斥量传给函数，函数然后自动把调用线程放到等待条件的线程列表中，然后对互斥量解锁。
等待时间使用的是绝对时间，不是之前的时间差而是将未来时间传入，使用clock_gettime获得timespec表示的当前时间，也可以通过gettimeofday获得timeval结构表示的当前时间，再转换为timespec，函数如下所示：

#include <sys/time.h>
#include <stdlib.h>

// 以分钟作为时间间隔
void maketimeout(struct timespec *tsp, long minutes) {
    struct timeval now;
    gettimeofday(&now, NULL);
    tsp->tv_sec = now.tv_sec;
    tsp->tv_nsec = now.tv_usec * 1000;
    tsp->tv_sec += minutes * 60;
}

从pthread_cond_wait或pthread_cond_timedwait调用成功返回时，线程需要重新计算条件。pthread_cond_signal能唤醒至少一个睡眠线程，pthread_cond_broadcast能唤醒所以等待而睡眠的线程。

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

必须在改变条件状态之后再给线程发送信号

例子：使用条件变量和互斥量进行线程同步

#include "../include/apue.h"
#include <pthread.h>

#define WORKS_NUMS 10

struct msg
{
  struct msg *m_next;
  char message[64];
};

struct msg *workq;

pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;

void process_msg(char* name)
{
  struct msg *mp;
  pthread_mutex_lock(&qlock);
  while (workq == NULL)
    pthread_cond_wait(&qready, &qlock);
    // 将锁住的互斥量传入，pthread_cond_wait会将线程放入等待队列中，然后解锁qlock，
    // 此时阻塞在pthread_cond_wait，当被pthread_cond_signal或pthread_cond_broadcast
    // 唤醒后此时qlock会锁住，如果workq==NULL，就会再次等待
  mp = workq;
  workq = workq->m_next;
  pthread_mutex_unlock(&qlock);

  printf("[process-%s]:%s\n", name, mp->message);
}

void enqueue_msg(struct msg *mp)
{
  pthread_mutex_lock(&qlock); // 条件workq是由互斥量mutex保护
  mp->m_next = workq;         //  修改条件这个操作需要保持一致
  workq = mp;
  pthread_mutex_unlock(&qlock);
  pthread_cond_signal(&qready); // 修改条件后才发送信号
}

void *worker(void *arg)
{
  printf("worker %s create!\n", (char *)arg);
  process_msg((char*)arg);
}

void *sender(void *arg)
{
  printf("sender create!\n");
  for (int i = 0; i < WORKS_NUMS; i++)
  {
    struct msg *m = (struct msg *)malloc(sizeof(struct msg));
    sprintf(m->message, "msg-%d", i);
    enqueue_msg(m);
    sleep(1); // 发送后等待1s，让worker处于等待状态
  }
  return 0;
}
int main(int argc, char const *argv[])
{
  pthread_t send;
  pthread_t works[WORKS_NUMS];
  pthread_create(&send, NULL, sender, NULL);
  // sleep(1);
  for(int i= 0; i < WORKS_NUMS; i++) {
    char *name = (char*)malloc(10);
    sprintf(name, "%d", i);
    pthread_create(&works[i], NULL, worker, (void *)name);
  }
  
  pthread_join(send, NULL);
  for(int i= 0; i < WORKS_NUMS; i++) {
    pthread_join(works[i], NULL);
  }
  return 0;
}

输出:

sender create!
worker 0 create!
[worker-0]:msg-0
worker 3 create!
worker 2 create!
worker 4 create!
worker 1 create!
worker 5 create!
worker 6 create!
worker 7 create!
worker 8 create!
worker 9 create!
[worker-3]:msg-1
[worker-2]:msg-2
[worker-4]:msg-3
[worker-1]:msg-4
[worker-5]:msg-5
[worker-6]:msg-6
[worker-7]:msg-7
[worker-8]:msg-8
[worker-9]:msg-9

因为pthread_cond_wait是在while循环中，如果不满足条件会继续进入循环。

自旋锁