Linux网络编程3——多线程编程（改良版）

一.多线程

1.什么是线程

要了解线程，首先需要知道进程。一个进程指的是一个正在执行的应用程序。线程对应的英文名称为“thread”，它的功能是执行应用程序中的某个具体任务，比如一段程序、一个函数等。
线程和进程之间的关系，类似于工厂和工人之间的关系，进程好比是工厂，线程就如同工厂中的工人。一个工厂可以容纳多个工人，工厂负责为所有工人提供必要的资源（电力、产品原料、食堂、厕所等），所有工人共享这些资源，每个工人负责完成一项具体的任务，他们相互配合，共同保证整个工厂的平稳运行。
每个进程执行前，操作系统都会为其分配所需的资源，包括要执行的程序代码、数据、内存空间、文件资源等。一个进程至少包含 1 个线程，可以包含多个线程，所有线程共享进程的资源，各个线程也可以拥有属于自己的私有资源。

进程仅负责为各个线程提供所需的资源，真正执行任务的是线程，而不是进程。

2.什么是多线程

所谓多线程，即一个进程中拥有多（≥2）个线程，线程之间相互协作、共同执行一个应用程序。

当进程中仅包含 1 个执行程序指令的线程时，该线程又称“主线程”，这样的进程称为“单线程进程”。

二.线程基础函数

1.pthread_self函数

作用：获取线程的ID，起作用对应于进程的getpid()函数

函数原型：

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

• 线程ID：pthread_t类型，本质是Linux下的无符号整数
• 线程ID是进程内部识别的标志（两个进程间，线程ID允许相同）

2.pthread_create函数

作用：用于创建新线程

函数原型：

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

参数说明：

• pthread_t *thread: 指向 pthread_t 类型的指针，用于存储新创建线程的线程 ID。
• const pthread_attr_t *attr: 指向 pthread_attr_t 结构的指针，该结构包含了新线程的属性。如果不需要设置特定属性，可以传递 NULL。
• void *(*start_routine)(void*): 新线程的入口函数（回调函数应用），即线程开始执行时调用的函数。这个函数必须有返回值类型 void* 并接受一个 void* 类型的参数。
• void *arg: 传递给（回调函数）线程入口函数 start_routine 的参数。

个人理解补充：

• 该函数的第一个参数 pthread_t *thread：传递一个 pthread_t 类型的指针变量，也可以直接传递某个 pthread_t 类型变量的地址。**pthread_t 是一种用于表示线程的数据类型，每一个 pthread_t 类型的变量都可以表示一个线程。**例如 int 是一种表示整数的数据类型，每个 int 类型的变量都可以表示一个整数，它们都是数据类型的一种。
• 该函数的第三个参数是正在创建的该线程需要执行的函数，需要注意的是这里是以函数指针的方式指明新建线程需要执行的函数，该函数的形参和返回值都必须为 void* 类型。void* 类型又称空指针类型，表明指针所指数据的类型是未知的（如果不理解，类比于结构体指针一样理解）。使用此类型指针时，我们通常需要先对其进行强制类型转换，然后才能正常访问指针指向的数据。
• 返回值：如果成功创建线程，pthread_create() 函数返回数字 0，反之返回非零值。各个非零值都对应着不同的宏，指明创建失败的原因，这里可以自己去了解。

void* thread_function(void *arg) {// 线程要执行的代码return NULL;
}int main() {pthread_t thread_id;int result = pthread_create(&thread_id, NULL, thread_function, NULL);if (result) {// 错误处理}// 其他代码return 0;
}

3.pthread_exit函数

用于终止调用线程。在 C 语言中，该函数的原型定义在 <pthread.h> 头文件中。函数原型如下：

void pthread_exit(void *retval);

参数说明：

• retval：指向一个指针的指针，用于返回一个值给其他线程。如果调用线程不关心返回值，可以传递 NULL。

当线程调用 pthread_exit 时，它将立即终止。如果有其他线程使用 pthread_join 等待该线程的结束，并且提供了一个接收返回值的指针，那么这个返回值将会被存储在提供的指针所指向的位置。

需要注意的是，pthread_exit 并不会清理线程的栈，也不会执行任何线程的清理处理程序。如果需要执行清理操作，应该使用 pthread_cleanup_push 和 pthread_cleanup_pop 函数来注册和注销清理函数。

该函数用来终止线程执行。多线程程序中，终止线程执行的方式本来有 3 种，分别是：

• 线程执行完成后，自行终止；

• 线程执行过程中遇到了 pthread_exit() 或者 return，也会终止执行；

• 线程执行过程中，接收到其它线程发送的“终止执行”的信号，然后终止执行。

第一种的理解就是什么也不管，线程执行完会自己终止；第二种就是本部分要用的pthread_exit()函数，return也好理解，返回即终止；第三种方法，本来要使用pthread_cancel()函数，但在使用这个函数时会出现其他一系列的问题，解决起来非常麻烦，所以除非特殊情况，我们一般使用第二种方式。

补充：pthread_exit()和return的区别：首先，return 语句和 pthread_exit() 函数的含义不同，return 的含义是返回，它不仅可以用于线程执行的函数，普通函数也可以使用；pthread_exit() 函数的含义是线程退出，它专门用于结束某个线程的执行。实际使用中，我们终止子线程一般都使用pthread_exit()函数，不建议使用return。

4.pthread_join函数

pthread_join 函数是 POSIX 线程库中的一个函数，用于等待一个线程结束。这个函数允许一个线程（通常称为“主线程”）等待另一个线程（即被等待的线程）完成执行。在 C 语言中，该函数的原型定义在 <pthread.h> 头文件中。函数原型如下：

int pthread_join(pthread_t thread, void **retval);

参数说明：

• thread：标识要等待的线程的线程 ID。
• retval：一个指向指针的指针，用于存储被等待线程的返回值。如果不需要获取返回值，可以传递 NULL。

返回值：

• 成功时，pthread_join 函数返回 0。
• 失败时，返回一个错误编号，具体错误编号可以在 <errno.h> 头文件中找到。

当 pthread_join 被调用时，如果 thread 参数指定的线程已经结束，那么 pthread_join 会立即返回。如果指定的线程还没有结束，调用 pthread_join 的线程将阻塞，直到被等待的线程退出。一旦被等待的线程退出，retval 指向的变量将被设置为该线程的返回值（如果有的话）。

5.pthread_cancel函数

pthread_cancel 函数是 POSIX 线程（pthread）库中的一个函数，用于请求取消（终止）一个指定的线程。当调用这个函数时，目标线程将收到一个取消信号，并且通常会执行一些清理操作后终止。这个函数的原型定义在 <pthread.h> 头文件中，如下所示：

int pthread_cancel(pthread_t thread);

参数说明：

• thread：需要被取消的线程的标识符。

返回值：

• 成功时，返回 0。
• 失败时，返回一个错误编号，具体错误编号可以在 <errno.h> 头文件中找到。

需要注意的是，pthread_cancel 函数只是发起了一个取消请求，并不保证目标线程会立即停止执行。目标线程可能会在完成当前操作或者达到一个安全点后才开始处理取消请求。此外，目标线程可以安装取消处理函数（使用 pthread_setcanceltype 和 pthread_cleanup_push/pthread_cleanup_pop），以便在被取消时执行一些清理工作。

6.pthread_detach函数

pthread_detach 函数用于将一个线程标记为分离状态（detached）。当线程被创建时，默认情况下它是“joinable”，这意味着在它结束执行之前，其他线程可以使用 pthread_join 函数来等待它结束。如果一个线程被标记为分离状态，那么一旦线程结束执行，它的资源将自动被释放，不需要其他线程显式调用 pthread_join。

pthread_detach 函数的原型定义在 <pthread.h> 头文件中，如下所示：

int pthread_detach(pthread_t thread);

参数说明：

• thread：需要被标记为分离状态的线程的标识符。

返回值：

• 成功时，返回 0。
• 失败时，返回一个错误编号，具体错误编号可以在 <errno.h> 头文件中找到。

三.线程同步

1.缘由

多线程程序中各个线程除了可以使用自己的私有资源（局部变量、函数形参等）外，还可以共享全局变量、静态变量、堆内存、打开的文件等资源。我们通常将“多个线程同时访问某一公共资源”的现象称为“线程间产生了资源竞争”或者“线程间抢夺公共资源”，线程间竞争资源往往会导致程序的运行结果出现异常，我们常常采用同步机制来解决这种问题。

2.实现方法

实现线程同步的常用方法有 4 种，分别称为互斥锁、信号量、条件变量和读写锁。

• 互斥锁（Mutex）又称互斥量或者互斥体，是最简单也最有效地一种线程同步机制。互斥锁的用法和实际生活中的锁非常类似，当一个线程访问公共资源时，会及时地“锁上”该资源，阻止其它线程访问；访问结束后再进行“解锁”操作，将该资源让给其它线程访问。

• 信号量又称“信号灯”，主要用于控制同时访问公共资源的线程数量，当线程数量控制在 ≤1 时，该信号量又称二元信号量，功能和互斥锁非常类似；当线程数量控制在 N（≥2）个时，该信号量又称多元信号量，指的是同一时刻最多只能有 N 个线程访问该资源。

• 条件变量的功能类似于实际生活中的门，门有“打开”和“关闭”两种状态，分别对应条件变量的“成立”状态和“不成立”状态。当条件变量“不成立”时，任何线程都无法访问资源，只能等待条件变量成立；一旦条件变量成立，所有等待的线程都会恢复执行，访问目标资源。为了防止各个线程竞争资源，条件变量总是和互斥锁搭配使用。

• 多线程程序中，如果大多数线程都是对公共资源执行读取操作，仅有少量的线程对公共资源进行修改，这种情况下可以使用读写锁解决线程同步问题。

这里我们使用最简单的也是最常用的方法：互斥锁。

3.互斥锁

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>//共享资源，打印机
void printer(char *str)
{while(*str != '\0'){putchar(*str);fflush(stdout);str++;sleep(1);}
}//线程1
void *thread_fun_1(void *arg)
{char *str = "hello";printer(str);   
}//线程2
void *thread_fun_2(void *arg)
{char *str = "HELLO";printer(str);
}int main()
{pthread_t tid1,tid2;//创建两个线程pthread_create(&tid1,NULL,thread_fun_1,NULL);pthread_create(&tid2,NULL,thread_fun_2,NULL);//等待线程执行结束，回收其资源pthread_join(tid1,NULL);pthread_join(tid2,NULL);return 0;
}

这里是一个共享打印机的程序案例，此刻还没有使用互斥锁。

下面是几个互斥锁常用的API函数：

1.初始化线程函数

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

• 功能：初始化一个互斥锁。

• 参数：

  • mutex：互斥锁地址。类型是 pthread_mutex_t 。
  • attr：设置互斥量的属性，通常可采用默认属性，即可将attr设为 NULL。

• 可以使用宏 PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁，比如： pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_mutex_init() 来完成动态初始化，不同之处在于 PTHREAD_MUTEX_INITIALIZER 宏不进行错误检查。

• 返回值：

  • 成功：0，成功申请的锁默认是打开的。
  • 失败：非 0 错误码

2.销毁线程函数

#include <pthread.h>
​
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：销毁指定的一个互斥锁。互斥锁在使用完毕后，必须要对互斥锁进行销毁，以释放资源。
参数：mutex：互斥锁地址。
返回值：成功：0失败：非 0 错误码

3.加锁函数

#include <pthread.h>
​
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：对互斥锁上锁，若互斥锁已经上锁，则调用者阻塞，直到互斥锁解锁后再上锁。
参数：mutex：互斥锁地址。
返回值：成功：0失败：非 0 错误码
​
int pthread_mutex_trylock(pthread_mutex_t *mutex);
   调用该函数时，若互斥锁未加锁，则上锁，返回 0；
   若互斥锁已加锁，则函数直接返回失败，即 EBUSY。

4.解锁函数

#include <pthread.h>
​
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：对指定的互斥锁解锁。
参数：mutex：互斥锁地址。
返回值：成功：0失败：非0错误码

使用互斥锁修改上述案例：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>pthread_mutex_t mutex; //互斥锁void printer(char *str)
{pthread_mutex_lock(&mutex); //上锁while(*str != '\0'){putchar(*str);fflush(stdout);str++;sleep(1);}pthread_mutex_unlock(&mutex); //解锁
}//线程1
void *thread_fun_1(void *arg)
{char *str = "hello";printer(str);   
}//线程2
void *thread_fun_2(void *arg)
{char *str = "HELLO";printer(str);
}int main()
{pthread_t tid1,tid2;//创建两个线程pthread_create(&tid1,NULL,thread_fun_1,NULL);pthread_create(&tid2,NULL,thread_fun_2,NULL);//等待线程执行结束，回收其资源pthread_join(tid1,NULL);pthread_join(tid2,NULL);return 0;
}

4.读写锁

​ 当有一个线程已经持有互斥锁时，互斥锁将所有试图进入临界区的线程都阻塞住。但是考虑一种情形，当前持有互斥锁的线程只是要读访问共享资源，而同时有其它几个线程也想读取这个共享资源，但是由于互斥锁的排它性，所有其它线程都无法获取锁，也就无法读访问共享资源了，但是实际上多个线程同时读访问共享资源并不会导致问题。

​ 在对数据的读写操作中，更多的是读操作，写操作较少，例如对数据库数据的读写应用。为了满足当前能够允许多个读出，但只允许一个写入的需求，线程提供了读写锁来实现。

读写锁的特点如下：

1）如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作。

2）如果有其它线程写数据，则其它线程都不允许读、写操作。

读写锁分为读锁和写锁，规则如下：

1）如果某线程申请了读锁，其它线程可以再申请读锁，但不能申请写锁。

2）如果某线程申请了写锁，其它线程不能申请读锁，也不能申请写锁。

POSIX 定义的读写锁的数据类型是： pthread_rwlock_t。

读写锁常规API函数：

初始化读写锁：

#include <pthread.h>
​
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);
功能：用来初始化 rwlock 所指向的读写锁。
​
参数：rwlock：指向要初始化的读写锁指针。attr：读写锁的属性指针。如果 attr 为 NULL 则会使用默认的属性初始化读写锁，否则使用指定的 attr 初始化读写锁。
​可以使用宏 PTHREAD_RWLOCK_INITIALIZER 静态初始化读写锁，比如：pthread_rwlock_t my_rwlock = PTHREAD_RWLOCK_INITIALIZER;
​这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_rwlock_init() 来完成动态初始化，不同之处在于PTHREAD_RWLOCK_INITIALIZER 宏不进行错误检查。
​
返回值：成功：0，读写锁的状态将成为已初始化和已解锁。失败：非 0 错误码。

销毁读写锁：

#include <pthread.h>
​
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
功能：用于销毁一个读写锁，并释放所有相关联的资源（所谓的所有指的是由 pthread_rwlock_init() 自动申请的资源） 。
参数：rwlock：读写锁指针。
返回值：成功：0失败：非 0 错误码

添加读锁函数：

#include <pthread.h>
​
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
功能：以阻塞方式在读写锁上获取读锁（读锁定）。如果没有写者持有该锁，并且没有写者阻塞在该锁上，则调用线程会获取读锁。如果调用线程未获取读锁，则它将阻塞直到它获取了该锁。一个线程可以在一个读写锁上多次执行读锁定。线程可以成功调用 pthread_rwlock_rdlock() 函数 n 次，但是之后该线程必须调用 pthread_rwlock_unlock() 函数 n 次才能解除锁定。
参数：rwlock：读写锁指针。
返回值：成功：0失败：非 0 错误码
​
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
   用于尝试以非阻塞的方式来在读写锁上获取读锁。
   如果有任何的写者持有该锁或有写者阻塞在该读写锁上，则立即失败返回。

添加写锁函数“

#include <pthread.h>
​
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
功能：在读写锁上获取写锁（写锁定）。如果没有写者持有该锁，并且没有写者读者持有该锁，则调用线程会获取写锁。如果调用线程未获取写锁，则它将阻塞直到它获取了该锁。
参数：rwlock：读写锁指针。
返回值：成功：0失败：非 0 错误码
​
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
   用于尝试以非阻塞的方式来在读写锁上获取写锁。
   如果有任何的读者或写者持有该锁，则立即失败返回。

解锁函数：

#include <pthread.h>
​
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
功能：无论是读锁或写锁，都可以通过此函数解锁。
参数：rwlock：读写锁指针。
返回值：成功：0失败：非 0 错误码

读写锁示例：

pthread_rwlock_t rwlock; //读写锁
int num = 1;
​
//读操作，其他线程允许读操作，却不允许写操作
void *fun1(void *arg)
{while (1){pthread_rwlock_rdlock(&rwlock);printf("read num first===%d\n", num);pthread_rwlock_unlock(&rwlock);sleep(1);}
}
​
//读操作，其他线程允许读操作，却不允许写操作
void *fun2(void *arg)
{while (1){pthread_rwlock_rdlock(&rwlock);printf("read num second===%d\n", num);pthread_rwlock_unlock(&rwlock);sleep(2);}
}
​
//写操作，其它线程都不允许读或写操作
void *fun3(void *arg)
{while (1){
​pthread_rwlock_wrlock(&rwlock);num++;printf("write thread first\n");pthread_rwlock_unlock(&rwlock);sleep(2);}
}
​
//写操作，其它线程都不允许读或写操作
void *fun4(void *arg)
{while (1){
​pthread_rwlock_wrlock(&rwlock);num++;printf("write thread second\n");pthread_rwlock_unlock(&rwlock);sleep(1);}
}
​
int main()
{pthread_t ptd1, ptd2, ptd3, ptd4;
​pthread_rwlock_init(&rwlock, NULL);//初始化一个读写锁
​//创建线程pthread_create(&ptd1, NULL, fun1, NULL);pthread_create(&ptd2, NULL, fun2, NULL);pthread_create(&ptd3, NULL, fun3, NULL);pthread_create(&ptd4, NULL, fun4, NULL);
​//等待线程结束，回收其资源pthread_join(ptd1, NULL);pthread_join(ptd2, NULL);pthread_join(ptd3, NULL);pthread_join(ptd4, NULL);
​pthread_rwlock_destroy(&rwlock);//销毁读写锁
​return 0;
}

5.条件变量

与互斥锁不同，条件变量是用来等待而不是用来上锁的，条件变量本身不是锁！

条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

条件变量的两个动作：

• 条件不满, 阻塞线程
• 当条件满足, 通知阻塞的线程开始工作

条件变量的类型: pthread_cond_t。

初始化条件变量函数：

#include <pthread.h>
​
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
功能：初始化一个条件变量
参数：cond：指向要初始化的条件变量指针。attr：条件变量属性，通常为默认值，传NULL即可也可以使用静态初始化的方法，初始化条件变量：pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
返回值：成功：0失败：非0错误号
​

销毁条件变量函数：

#include <pthread.h>
​
int pthread_cond_destroy(pthread_cond_t *cond);
功能：销毁一个条件变量
参数：cond：指向要初始化的条件变量指针
返回值：成功：0失败：非0错误号

阻塞等待条件变量函数：

#include <pthread.h>
​
int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
功能：阻塞等待一个条件变量a) 阻塞等待条件变量cond（参1）满足b) 释放已掌握的互斥锁（解锁互斥量）相当于pthread_mutex_unlock(&mutex);a) b) 两步为一个原子操作。c) 当被唤醒，pthread_cond_wait函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);
​
参数：cond：指向要初始化的条件变量指针mutex：互斥锁
​
返回值：成功：0失败：非0错误号
​
int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,const struct.*restrict abstime);
功能：限时等待一个条件变量
​
参数：cond：指向要初始化的条件变量指针mutex：互斥锁abstime：绝对时间
​
返回值：成功：0失败：非0错误号

abstime补充说明：

struct timespec {time_t tv_sec;      /* seconds */ // 秒long   tv_nsec; /* nanosecondes*/ // 纳秒
}time_t cur = time(NULL);        //获取当前时间。
struct timespec t;              //定义timespec 结构体变量t
t.tv_sec = cur + 1;             // 定时1秒
pthread_cond_timedwait(&cond, &t);

唤醒至阻塞在条件变量上的线程：

#include <pthread.h>
​
int pthread_cond_signal(pthread_cond_t *cond);
功能：唤醒至少一个阻塞在条件变量上的线程
参数：cond：指向要初始化的条件变量指针
返回值：成功：0失败：非0错误号
​
int pthread_cond_broadcast(pthread_cond_t *cond);
功能：唤醒全部阻塞在条件变量上的线程
参数：cond：指向要初始化的条件变量指针
返回值：成功：0失败：非0错误号

综合互斥锁和条件变量案例联系：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>int flag = 0;
pthread_mutex_t mutex; //互斥锁
pthread_cond_t cond;   //条件变量//改变条件的线程
void *thread_fun_1(void *arg)
{while(1){//加锁pthread_mutex_lock(&mutex);flag = 1;//解锁pthread_mutex_unlock(&mutex);//唤醒因为条件而阻塞的线程pthread_cond_signal(&cond);sleep(2);}
}//线程2
void *thread_fun_2(void *arg)
{while(1){//加锁pthread_mutex_lock(&mutex);//条件不成立，阻塞，等待条件为真if(0 == flag){pthread_cond_wait(&cond,&mutex);}printf("条件为真，开始修改值\n");flag = 0;//解锁pthread_mutex_unlock(&mutex);}
}int main()
{int ret = -1;pthread_t tid1,tid2;//初始化条件变量ret = pthread_cond_init(&cond,NULL);if(0 != ret){printf("初始化条件变量失败\n");return 1;}//初始化互斥锁ret = pthread_mutex_init(&mutex,NULL);if(0 != ret){printf("初始化互斥锁失败\n");}//创建两个线程pthread_create(&tid1,NULL,thread_fun_1,NULL);pthread_create(&tid2,NULL,thread_fun_2,NULL);//等待线程执行结束，回收其资源pthread_join(tid1,NULL);pthread_join(tid2,NULL);//销毁互斥锁pthread_mutex_destroy(&mutex);//销毁条件变量pthread_cond_destroy(&cond);return 0;
}

6.生产者消费者模型

生产消费者模型：

// 节点结构
typedef struct node
{int data;struct node* next;
}Node;
​
// 永远指向链表头部的指针
Node* head = NULL;
​
// 线程同步 - 互斥锁
pthread_mutex_t mutex;
// 阻塞线程 - 条件变量类型的变量
pthread_cond_t cond;
​
// 生产者
void* producer(void* arg)
{while (1){// 创建一个链表的节点Node* pnew = (Node*)malloc(sizeof(Node));// 节点的初始化pnew->data = rand() % 1000; // 0-999
​// 使用互斥锁保护共享数据pthread_mutex_lock(&mutex);// 指针域pnew->next = head;head = pnew;printf("====== produce: %lu, %d\n", pthread_self(), pnew->data);pthread_mutex_unlock(&mutex);
​// 通知阻塞的消费者线程，解除阻塞pthread_cond_signal(&cond);
​sleep(rand() % 3);}return NULL;
}
​
void* customer(void* arg)
{while (1){pthread_mutex_lock(&mutex);// 判断链表是否为空if (head == NULL){// 线程阻塞// 该函数会对互斥锁解锁pthread_cond_wait(&cond, &mutex);// 解除阻塞之后，对互斥锁做加锁操作}// 链表不为空 - 删掉一个节点 - 删除头结点Node* pdel = head;head = head->next;printf("------ customer: %lu, %d\n", pthread_self(), pdel->data);free(pdel);pthread_mutex_unlock(&mutex);}return NULL;
}
​
int main(int argc, const char* argv[])
{pthread_t p1, p2;// initpthread_mutex_init(&mutex, NULL);pthread_cond_init(&cond, NULL);
​// 创建生产者线程pthread_create(&p1, NULL, producer, NULL);// 创建消费者线程pthread_create(&p2, NULL, customer, NULL);
​// 阻塞回收子线程pthread_join(p1, NULL);pthread_join(p2, NULL);
​pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond);
​return 0;
}

7.信号量

信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。

编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。

PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。

信号量主要用于进程或线程间的同步和互斥这两种典型情况。

信号量数据类型为：sem_t。

信号量用于互斥：

信号量用于同步：

信号量的常见API函数：

1.初始化信号量函数

#include <semaphore.h>
​
int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：创建一个信号量并初始化它的值。一个无名信号量在被使用前必须先初始化。
参数：sem：信号量的地址。pshared：等于 0，信号量在线程间共享（常用）；不等于0，信号量在进程间共享。value：信号量的初始值。
返回值：成功：0失败： - 1

2.销毁信号量

#include <semaphore.h>
​
int sem_destroy(sem_t *sem);
功能：删除 sem 标识的信号量。
参数：sem：信号量地址。
返回值：成功：0失败： - 1

3.信号量P操作（占用1个资源）

#include <semaphore.h>
​
int sem_wait(sem_t *sem);
功能：将信号量的值减 1。操作前，先检查信号量（sem）的值是否为 0，若信号量为 0，此函数会阻塞，直到信号量大于 0 时才进行减 1 操作。
参数：sem：信号量的地址。
返回值：成功：0失败： - 1
​
int sem_trywait(sem_t *sem);
   以非阻塞的方式来对信号量进行减 1 操作。
   若操作前，信号量的值等于 0，则对信号量的操作失败，函数立即返回。
​
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
   限时尝试将信号量的值减 1
   abs_timeout：绝对时间

abs_timeout补充说明：

struct timespec {time_t tv_sec;      /* seconds */ // 秒long   tv_nsec; /* nanosecondes*/ // 纳秒
}time_t cur = time(NULL);        //获取当前时间。
struct timespec t;              //定义timespec 结构体变量t
t.tv_sec = cur + 1;             // 定时1秒
sem_timedwait(&cond, &t);

4.信号量V操作（释放1个资源）

#include <semaphore.h>
​
int sem_post(sem_t *sem);
功能：将信号量的值加 1 并发出信号唤醒等待线程（sem_wait()）。
参数：sem：信号量的地址。
返回值：成功：0失败：-1

5.获取信号量的值

#include <semaphore.h>
​
int sem_getvalue(sem_t *sem, int *sval);
功能：获取 sem 标识的信号量的值，保存在 sval 中。
参数：sem：信号量地址。sval：保存信号量值的地址。
返回值：成功：0失败：-1

信号量案例：

sem_t sem; //信号量
​
void printer(char *str)
{sem_wait(&sem);//减一while (*str){putchar(*str);fflush(stdout);str++;sleep(1);}printf("\n");
​sem_post(&sem);//加一
}
​
void *thread_fun1(void *arg)
{char *str1 = "hello";printer(str1);
}
​
void *thread_fun2(void *arg)
{char *str2 = "world";printer(str2);
}
​
int main(void)
{pthread_t tid1, tid2;
​sem_init(&sem, 0, 1); //初始化信号量，初始值为 1
​//创建 2 个线程pthread_create(&tid1, NULL, thread_fun1, NULL);pthread_create(&tid2, NULL, thread_fun2, NULL);
​//等待线程结束，回收其资源pthread_join(tid1, NULL);pthread_join(tid2, NULL);
​sem_destroy(&sem); //销毁信号量
​return 0;
}