1、线程

一个进程可以包含多个线程，同一程序中的所有线程会独立执行相同的程序，共享同一份全局内存区域（初始化数据段、未初始化数据段、堆）。

同样是执行并行任务，用子进程会有一些限制，比如：

• 进程间的信息难以共享，需要使用进程通信；
• 调用fork创建进程的代价相对较高。

线程可以很好地解决上面的问题

• 方便、快速地共享信息，只要把数据复制到共享变量中即可（全局/堆）中即可。但是要注意不要出现多个线程试图同时修改一份信息的情况；
• 创建线程比创建进程要快10倍甚至更多；

要注意，虽然线程之间不会共享栈数据，但是线程栈都是驻留在同一虚拟地址空间的，所以可以通过指针共享对方栈中的数据。

以下是一些线程数据类型：

• pthread_t：线程ID
• pthread_mutex_t：互斥对象
• pthread_mutexattr_t：互斥属性对象
• pthread_cond_t：条件变量
• pthread_condattr_t：条件变量
• pthread_key_t：条件变量的属性对象
• pthread_once_t：一次性初始化控制上下文
• pthread_attr_t：线程的属性对象

在多线程程序中，每个线程都有自己的errno。

在linux平台上，编译调用了pthread api的程序时需要设置 -pthread。

我们可以使用pthread_create来创建线程：

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start)(void *), void *arg);

新线程会调用带有参数arg的函数start开始执行。将参数arg声明未void*类型，表示可以将任意对象的指针传递给start函数，一般来说，arg指向一个全局或者堆变量，也可以是NULL。如果向start传递多个参数，可以将arg指向一个结构。

有如下方式可以中止线程的运行：

• 线程start函数指向return语句并返回；
• 线程调用pthread_exit；
• 调用pthread_cancel取消线程；
• 任意线程调用exit，或者主线程执行return，都会导致进程中的所有线程立即中止。

pthread_exit会中止调用线程，返回值可以由另一个线程调用pthread_join来获取。

#include <pthread.h>
void pthread_exit(void *retval);

调用pthread_exit相当于在start函数中执行return。和return不同的是，可以在start调用的任意函数中调用pthread_exit。返回值retval不应该分配于线程栈中，类似的，也不能在线程栈中分配start函数的返回值。

如果主线程调用了pthread_exit，而不是exit或者return，其他线程将继续执行。

线程可以通过pthread_self获取自己的线程ID：

#include <pthread.h>
pthread_t pthread_self(void);

pthread_join用于等待某个线程的中止，如果线程已经中止pthread_join会立即返回。

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

如果retval未一个非空指针，那么会将线程中止时的返回值拷贝到retval中。

如果线程未分离（detach），必须使用pthread_join来进行连接。如果没有进行连接，那么线程中止时会产生僵尸线程。

pthread_join和wait有点类似，不过也有区别，线程之间是平等的，所以任意线程都可以调用pthread_join来（连接）回收另一个线程，而wait只能由父进程调用。pthread_join只能连接特定线程ID，这么做的意图是线程只能连接它知道的线程。

默认情况下，线程是可以连接的（joinable），线程退出时，其他线程可以调用pthread_join获取返回状态。有的时候，系统希望线程终止时能够自动清理并移除，可以调用pthread_detach。

#include <pthread.h>
int pthread_detach(pthread_t thread);

线程也可以调用pthread_detach(pthread_self())自行分离。一旦线程处于分离状态，就不能调用pthread_join来获取状态了。不过其他线程调用了exit或者主线程执行了return，分离的线程也会收到影响。

以下是一个简单的线程示例：

#include <unistd.h>
#include <stdio.h>
#include <time.h>
#include <pthread.h>
#include <sys/syscall.h> // gettidstatic void *func(void* arg) {int cnt = *(int*)arg;for(int i = 0; i < cnt; i++) {time_t ti = time(NULL);printf("%s tid:%ld, index:%d, cnt:%d\n", ctime(&ti), syscall(SYS_gettid), i, cnt);sleep(1);}
}int main(int argc, char **argv) {pthread_t th;int cnt = 10;int ret = pthread_create(&th, NULL, func, &cnt);pthread_join(th, NULL);printf("pid:%d, tid:%ld, finish!\n", getpid(), syscall(SYS_gettid));return 0;
}

2、线程同步

线程能够使用全局变量来共享信息，不过要注意的是：必须确保多个线程不会同时修改同一变量，或者说是某一线程不会读取正由其他线程修改的变量。临界区：指的是访问某个共享资源的代码片段，并且这段代码的执行应该为原子操作。

互斥量有两种状态：已锁定（locked）和未锁定（unlocked）。任何时候，至多只有一个线程可以锁定互斥量，试图对某个已经锁定的互斥量再次加锁，可能会阻塞线程，或者是报错失败。

线程锁定互斥量就会称为互斥量的所有者，只有所有者才能给互斥量解锁。获取（acquire）等于加锁和释放（release）等于解锁。

创建互斥量后，使用前必须要先初始化：

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

PTHREAD_MUTEX_INITIALIZER只能初始化静态分配的互斥量。

如果互斥量是不是静态分配的，那么需要调用pthread_mutex_init初始化：

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

如果attr为NULL，互斥量使用默认值。以下几种情况需要用该函数进行初始化：

• 动态分配于堆中的互斥量；
• 栈中分配的自动变量；
• 初始化经由静态分配，且不使用默认属性的互斥量。

如果不需要使用自动/动态分配的互斥量时，应该调用pthread_mutex_destroy进行销毁。使用PTHREAD_MUTEX_INITIALIZER初始化的静态互斥量不需要销毁。

int pthread_mutex_destroy(pthread_mutex_t *mutex);

初始化之后，互斥量处于未锁定状态，我们可以用以下函数来进行加锁解锁：

#include <pthread.h>int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

调用pthread_mutex_lock时如果互斥量处于未锁定状态，调用之后立即返回。如果有其他线程已经锁定了互斥量，那么调用pthread_mutex_lock的一方将会一直阻塞直到互斥量倍解锁。

避免死锁问题，最简单的方法是定义互斥量的层级关系。多个线程对一组互斥量操作时，应该总是以相同的顺序对该组互斥量进行锁定。

条件变量也有动态和静态分配之分，静态分配如下：

static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

动态分配的条件变量需要使用pthread_cond_init来初始化，它和mutex类似。

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

条件变量使用完成后要调用destroy

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);

条件变量的主要操作是发送信号（signal）和等待（wait）。发送信号操作指的是通知一个或多个处于等待状态的线程，某个共享变量的状态已经改变。等待操作指的是收到一个通知之前一直处于阻塞状态。

#include <pthread.h>
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);

pthread_cond_wait用于阻塞线程直至收到条件变量cond的通知。pthread_cond_signal和pthread_cond_broadcast用于向条件变量发出信号。signal只保证唤醒至少一条被阻塞的线程，broadcast会唤醒所有线程。

pthread_cond_signal适用于线程在执行完全相同的任务，pthread_cond_broadcast适用于线程在执行不同的任务（关于条件变量的判断条件不同）。

#include <pthread.h>
int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

pthread_cond_timewait和pthread_cond_wait几乎相同，不过pthread_cond_timewait可以设置阻塞时间的上限。

必须是由一个while循环，而不是if语句，来控制堆pthread_cond_wait的调用。这是因为，pthread_cond_wait返回时，不能确定判断条件的状态，应该立即重新检查判断条件，不满足的情况下继续休眠。

取消线程：

#include <pthread.h>
int pthread_cancel(pthread_t thread);

pthread_cancel用于向线程发送一个请求，要求其立刻退出，发出请求后，pthread_cancel立即返回，不会等待目标线程退出。如果线程的取消状态和类型分别为启动和延迟，只有在线程达到某个取消点时，取消请求才会起作用。

3、线程池

以下是一个简单的线程池

#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>typedef struct task {void (*func)(void*);void *arg;
} task_t;typedef struct threadpool {pthread_t 			*threads;task_t 				*task_queue;int 				queue_capacity;int 				queue_size;int 				thread_count;int 				running;pthread_mutex_t 	mutex;pthread_cond_t 		not_empty;pthread_cond_t 		not_full;
} threadpool_t;static void *threadpool_worker(void *arg) {threadpool_t *pool = (threadpool_t *)arg;task_t task;while(1) {pthread_mutex_lock(&pool->mutex);while(pool->queue_size == 0 && pool->running) {pthread_cond_wait(&pool->not_empty, &pool->mutex);}if(!pool->running) {pthread_mutex_unlock(&pool->mutex);pthread_exit(NULL);}task = pool->task_queue[0];for(int i = 0; i < pool->queue_size - 1; i++)pool->task_queue[i] = pool->task_queue[i+1];pool->queue_size--;pthread_cond_signal(&pool->not_full);pthread_mutex_unlock(&pool->mutex);task.func(task.arg);}return NULL;
}threadpool_t *threadpool_create(int thread_count, int queue_capacity) {threadpool_t *pool		 = (threadpool_t *)malloc(sizeof(threadpool_t));pool->thread_count 		 = thread_count;pool->queue_capacity 	 = queue_capacity;pool->queue_size 		 = 0;pool->running			 = 1;pool->threads			 = (pthread_t *)malloc(thread_count * sizeof(pthread_t));pool->task_queue		 = (task_t *)malloc(queue_capacity * sizeof(task_t));int ret = pthread_mutex_init(&pool->mutex, NULL);pthread_cond_init(&pool->not_empty, NULL);pthread_cond_init(&pool->not_full, NULL);for(int i = 0; i < thread_count; i++) {pthread_create(&pool->threads[i], NULL, threadpool_worker, (void *)pool);}#ifdef DEBUGprintf("threadpool create OK! ");for(int i = 0; i < pool->thread_count; i++) {printf("%ld ", pool->threads[i]);}printf("\n");
#endifreturn pool;
}void threadpool_destroy(threadpool_t *pool) {pool->running = 0;pthread_cond_broadcast(&pool->not_empty);pthread_cond_broadcast(&pool->not_full);for(int i = 0; i < pool->thread_count; i++) {pthread_join(pool->threads[i], NULL);}pthread_mutex_destroy(&pool->mutex);pthread_cond_destroy(&pool->not_empty);pthread_cond_destroy(&pool->not_full);free(pool->threads);free(pool->task_queue);free(pool);
}int threadpool_addTask(threadpool_t *pool, void (*func)(void *), void *arg) {
#ifdef DEBUGprintf("pool pointer in main before addTask: %p\n", pool);
#endifpthread_mutex_lock(&pool->mutex);while(pool->queue_size == pool->queue_capacity && pool->running) {pthread_cond_wait(&pool->not_full, &pool->mutex);}if(!pool->running) {pthread_mutex_unlock(&pool->mutex);return -1;}int index = pool->queue_size;
#ifdef DEBUGprintf("current index:%d\n", index);
#endiftask_t *task = &pool->task_queue[index];task->func = func;task->arg = arg;pool->queue_size++;
#ifdef DEBUGprintf("add task OK!\n");
#endifpthread_cond_signal(&pool->not_empty);pthread_mutex_unlock(&pool->mutex);return index; 
}void print_task(void *args) {int num = *(int *)args;for(int i = 0; i < num; i++) {printf("thread:%ld num:%d index:%d\n", pthread_self(), num, i);sleep(1);}
}int main(int argc, char **argv) {threadpool_t *pool = threadpool_create(3, 10);int num[20];for(int i = 0; i < 20; i++) {num[i] = i+1;int index = threadpool_addTask(pool, print_task, &num[i]);
#ifdef DEBUGprintf("addTask:%d index:%d\n", i, index);
#endif}sleep(30);printf("stop!\n");threadpool_destroy(pool);return 0;
}