网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
只能被单一线程访问的设备,例如:打印机。
一个最简单的实现方法就是当线程(Thread)进入临界区块时,禁止改变处理器;在uni-processor系统上,可以用“禁止中断(CLI)”来完成,避免发生系统调用(System Call)导致的上下文交换(Context switching);当离开临界区块时,处理器恢复原先的状态。
根据临界区是否引起问题,函数可以分为以下 2 类:
- 线程安全函数(Thread-safe function)
- 非线程安全函数(Thread-unsafe function)
线程安全函数被多个线程同时调用也不会发生问题。反之,非线程安全函数被同时调用时会引发问题。但这并非有关于临界区的讨论,线程安全的函数中同样可能存在临界区。只是在线程安全的函数中,同时被多个线程调用时可通过一些措施避免问题。
幸运的是,大多数标准函数都是线程安全函数。操作系统在定义非线程安全函数的同时,提供了具有相同功能的线程安全的函数。比如,
struct hostent \*gethostbyname(const char \*hostname);
同时,也提供了同一功能的安全函数:
struct hostent \*gethostbyname\_r(const char \*name,
struct hostent \*result,
char \*buffer,
int intbuflen,
int \*h_errnop);
线程安全函数结尾通常是 _r
。但是使用线程安全函数会给程序员带来额外的负担,可以通过以下方法自动将 gethostbyname 函数调用改为 gethostbyname_r 函数调用。\
声明头文件前定义
_REENTRANT
宏。
无需特意更改源代码加,可以在编译的时候指定编译参数定义宏。
gcc -D_REENTRANT mythread.c -o mthread -lpthread
2.3 工作(Worker)线程模型
下面的示例是计算从 1 到 10 的和,但并不是通过 main 函数进行运算,而是创建两个线程,其中一个线程计算 1 到 5 的和,另一个线程计算 6 到 10 的和,main 函数只负责输出运算结果。这种方式的线程模型称为「工作线程」。显示该程序的执行流程图:
下面是代码:
thread3.c
#include <stdio.h>
#include <pthread.h>
void \*thread\_summation(void \*arg);
int sum = 0;
int main(int argc, char \*argv[])
{
pthread_t id_t1, id_t2;
int range1[] = {1, 5};
int range2[] = {6, 10};
pthread\_create(&id_t1, NULL, thread_summation, (void \*)range1);
pthread\_create(&id_t2, NULL, thread_summation, (void \*)range2);
pthread\_join(id_t1, NULL);
pthread\_join(id_t2, NULL);
printf("result: %d \n", sum);
return 0;
}
void \*thread\_summation(void \*arg)
{
int start = ((int \*)arg)[0];
int end = ((int \*)arg)[1];
while (start <= end)
{
sum += start;
start++;
}
return NULL;
}
运行结果为:sum = 55
可以看出计算结果正确,两个线程都用了全局变量 sum ,证明了 2 个线程共享保存全局变量的数据区。
但是本例子本身存在问题。存在临界区相关问题,可以从下面的代码看出,下面的代码和上面的代码相似,只是增加了发生临界区错误的可能性,即使在高配置系统环境下也容易产生的错误:
thread4.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#define NUM\_THREAD 100
void \*thread\_inc(void \*arg);
void \*thread\_des(void \*arg);
long long num = 0;
int main(int argc, char \*argv[])
{
pthread_t thread_id[NUM_THREAD];
int i;
printf("sizeof long long: %d \n", sizeof(long long));
for (i = 0; i < NUM_THREAD; i++)
{
if (i % 2)
pthread\_create(&(thread_id[i]), NULL, thread_inc, NULL);
else
pthread\_create(&(thread_id[i]), NULL, thread_des, NULL);
}
for (i = 0; i < NUM_THREAD; i++)
pthread\_join(thread_id[i], NULL);
printf("result: %lld \n", num);
return 0;
}
void \*thread\_inc(void \*arg)
{
int i;
for (i = 0; i < 50000000; i++)
num += 1;
return NULL;
}
void \*thread\_des(void \*arg)
{
int i;
for (i = 0; i < 50000000; i++)
num -= 1;
return NULL;
}
运行结果如下:
从图上可以看出,每次运行的结果竟然不一样。理论上来说,上面代码的最后结果应该是 0 。原因暂时不得而知,但是可以肯定的是,这对于线程的应用是个大问题。
3 线程存在的问题和临界区
下面分析 thread4.c 中产生问题的原因,并给出解决方案。
3.1 多个线程访问同一变量是问题
thread4.c 的问题如下:
2 个线程正在同时访问全局变量 num
任何内存空间,只要被同时访问,都有可能发生问题。
因此,线程访问变量 num 时应该阻止其他线程访问,直到线程 1 运算完成。这就是同步(Synchronization)
3.2 临界区位置
那么在刚才代码中的临界区位置是:
函数内同时运行多个线程时引发问题的多条语句构成的代码块
全局变量 num 不能视为临界区,因为他不是引起问题的语句,只是一个内存区域的声明。下面是刚才代码的两个 main 函数
void \*thread\_inc(void \*arg)
{
int i;
for (i = 0; i < 50000000; i++)
num += 1;//临界区
return NULL;
}
void \*thread\_des(void \*arg)
{
int i;
for (i = 0; i < 50000000; i++)
num -= 1;//临界区
return NULL;
}
由上述代码可知,临界区并非 num 本身,而是访问 num 的两条语句,这两条语句可能由多个线程同时运行,也是引起这个问题的直接原因。产生问题的原因可以分为以下三种情况:
- 2 个线程同时执行 thread_inc 函数
- 2 个线程同时执行 thread_des 函数
- 2 个线程分别执行 thread_inc 和 thread_des 函数
也就是说,两条不同的语句由不同的线程执行时,也有可能构成临界区。前提是这 2 条语句访问同一内存空间。
4 线程同步
前面讨论了线程中存在的问题,下面就是解决方法,线程同步。
4.1 同步的两面性
线程同步用于解决线程访问顺序引发的问题。需要同步的情况可以从如下两方面考虑。
- 同时访问同一内存空间时发生的情况
- 需要指定访问同一内存空间的线程顺序的情况
情况一之前已经解释过,下面讨论情况二。这是「控制线程执行的顺序」的相关内容。假设有 A B 两个线程,线程 A 负责向指定的内存空间内写入数据,线程 B 负责取走该数据。所以这是有顺序的,不按照顺序就可能发生问题。所以这种也需要进行同步。
4.2 互斥量
互斥锁(英语:英语:Mutual exclusion,缩写 Mutex)是一种用于多线程编程中,防止两条线程同时对同一公共资源(比如全域变量)进行读写的机制。该目的通过将代码切片成一个一个的临界区域(critical section)达成。临界区域指的是一块对公共资源进行访问的代码,并非一种机制或是算法。一个程序、进程、线程可以拥有多个临界区域,但是并不一定会应用互斥锁。
通俗的说就互斥量就是一把优秀的锁,当临界区被占据的时候就上锁,等占用完毕然后再放开。
下面是互斥量的创建及销毁函数。
#include <pthread.h>
int pthread\_mutex\_init(pthread_mutex_t \*mutex,
const pthread_mutexattr_t \*attr);
int pthread\_mutex\_destroy(pthread_mutex_t \*mutex);
/\*
成功时返回 0,失败时返回其他值
mutex : 创建互斥量时传递保存互斥量的变量地址值,销毁时传递需要销毁的互斥量地址
attr : 传递即将创建的互斥量属性,没有特别需要指定的属性时传递 NULL
\*/
从上述函数声明中可以看出,为了创建相当于锁系统的互斥量,需要声明如下 pthread_mutex_t 型变量:
pthread_mutex_t mutex
该变量的地址值传递给 pthread_mutex_init
函数,用来保存操作系统创建的互斥量(锁系统)。调用 pthread_mutex_destroy
函数时同样需要该信息。如果不需要配置特殊的互斥量属性,则向第二个参数传递 NULL 时,可以利用 PTHREAD_MUTEX_INITIALIZER
进行如下声明:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
推荐尽可能的使用 pthread_mutex_init 函数进行初始化,因为通过宏进行初始化时很难发现发生的错误。
下面是利用互斥量锁住或释放临界区时使用的函数。
#include <pthread.h>
int pthread\_mutex\_lock(pthread_mutex_t \*mutex);
int pthread\_mutex\_unlock(pthread_mutex_t \*mutex);
/\*
成功时返回 0 ,失败时返回其他值
\*/
函数本身含有 lock unlock 等词汇,很容易理解其含义。进入临界区前调用的函数就是 pthread_mutex_lock 。调用该函数时,发现有其他线程已经进入临界区,则 pthread_mutex_lock 函数不会返回,直到里面的线程调用 pthread_mutex_unlock 函数退出临界区位置。也就是说,其他线程让出临界区之前,当前线程一直处于阻塞状态。接下来整理一下代码的编写方式:
pthread\_mutex\_lock(&mutex);
//临界区开始
//...
//临界区结束
pthread\_mutex\_unlock(&mutex);
简言之,就是利用 lock 和 unlock 函数围住临界区的两端。此时互斥量相当于一把锁,阻止多个线程同时访问,还有一点要注意,线程退出临界区时,如果忘了调用 pthread_mutex_unlock
函数,那么其他为了进入临界区而调用 pthread_mutex_lock
的函数无法摆脱阻塞状态。这种情况称为「死锁」。需要格外注意,下面是利用互斥量解决示例 thread4.c 中遇到的问题代码:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#define NUM\_THREAD 100
void \*thread\_inc(void \*arg);
void \*thread\_des(void \*arg);
long long num = 0;
pthread_mutex_t mutex; //保存互斥量读取值的变量
int main(int argc, char \*argv[])
{
pthread_t thread_id[NUM_THREAD];
int i;
pthread\_mutex\_init(&mutex, NULL); //创建互斥量
for (i = 0; i < NUM_THREAD; i++)
{
if (i % 2)
pthread\_create(&(thread_id[i]), NULL, thread_inc, NULL);
else
pthread\_create(&(thread_id[i]), NULL, thread_des, NULL);
}
for (i = 0; i < NUM_THREAD; i++)
pthread\_join(thread_id[i], NULL);
printf("result: %lld \n", num);
pthread\_mutex\_destroy(&mutex); //销毁互斥量
return 0;
}
void \*thread\_inc(void \*arg)
{
int i;
pthread\_mutex\_lock(&mutex); //上锁
for (i = 0; i < 50000000; i++)
num += 1;
pthread\_mutex\_unlock(&mutex); //解锁
return NULL;
}
void \*thread\_des(void \*arg)
{
int i;
pthread\_mutex\_lock(&mutex);
for (i = 0; i < 50000000; i++)
num -= 1;
pthread\_mutex\_unlock(&mutex);
return NULL;
}
运行结果如下:
从运行结果可以看出,通过互斥量机制得出了正确的运行结果。
在代码中:
void \*thread\_inc(void \*arg)
{
int i;
pthread\_mutex\_lock(&mutex); //上锁
for (i = 0; i < 50000000; i++)
num += 1;
pthread\_mutex\_unlock(&mutex); //解锁
return NULL;
}
以上代码的临界区划分范围较大,但这是考虑如下优点所做的决定:
最大限度减少互斥量 lock unlock 函数的调用次数
4.3 信号量
信号量(英语:Semaphore)又称为信号标,是一个同步对象
,用于保持在0至指定最大值之间的一个计数值。当线程完成一次对该semaphore对象的等待(wait)时,该计数值减一;当线程完成一次对semaphore对象的释放(release)时,计数值加一。当计数值为0,则线程等待该semaphore对象不再能成功直至该semaphore对象变成signaled状态。semaphore对象的计数值大于0,为signaled状态;计数值等于0,为nonsignaled状态.
semaphore对象适用于控制一个仅支持有限个用户的共享资源,是一种不需要使用忙碌等待(busy waiting)的方法。
信号量的概念是由荷兰计算机科学家艾兹赫尔·戴克斯特拉(Edsger W. Dijkstra)发明的,广泛的应用于不同的操作系统中。在系统中,给予每一个进程一个信号量,代表每个进程当前的状态,未得到控制权的进程会在特定地方被强迫停下来,等待可以继续进行的信号到来。如果信号量是一个任意的整数,通常被称为计数信号量
(Counting semaphore),或一般信号量
(general semaphore);如果信号量只有二进制的0或1,称为二进制信号量
(binary semaphore)。在linux系统中,二进制信号量(binary semaphore)又称互斥锁(Mutex)。
下面介绍信号量,在互斥量的基础上,很容易理解信号量。此处只涉及利用「二进制信号量」(只用 0 和 1)完成「控制线程顺序」为中心的同步方法。下面是信号量的创建及销毁方法:
#include <semaphore.h>
int sem\_post(sem_t \*sem);
int sem\_wait(sem_t \*sem);
/\*
成功时返回 0 ,失败时返回其他值
sem : 传递保存信号量读取值的变量地址值,传递给 sem\_post 的信号量增1,传递给 sem\_wait 时信号量减一
\*/
调用 sem_init 函数时,操作系统将创建信号量对象,此对象中记录这「信号量值」(Semaphore Value)整数。该值在调用 sem_post 函数时增加 1 ,调用 wait_wait 函数时减一。但信号量的值不能小于 0 ,因此,在信号量为 0 的情况下调用 sem_wait 函数时,调用的线程将进入阻塞状态(因为函数未返回)。当然,此时如果有其他线程调用 sem_post 函数,信号量的值将变为 1 ,而原本阻塞的线程可以将该信号重新减为 0 并跳出阻塞状态。实际上就是通过这种特性完成临界区的同步操作,可以通过如下形式同步临界区(假设信号量的初始值为 1)
sem\_wait(&sem);//信号量变为0...
// 临界区的开始
//...
//临界区的结束
sem\_post(&sem);//信号量变为1...
上述代码结构中,调用 sem_wait
函数进入临界区的线程在调用 sem_post
函数前不允许其他线程进入临界区。信号量的值在 0 和 1 之间跳转,因此,具有这种特性的机制称为「二进制信号量」。接下来的代码是信号量机制的代码。下面代码并非是同时访问的同步,而是关于控制访问顺序的同步,该场景为:
线程 A 从用户输入得到值后存入全局变量 num ,此时线程 B 将取走该值并累加。该过程一共进行 5 次,完成后输出总和并退出程序。
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
void \*read(void \*arg);
void \*accu(void \*arg);
static sem_t sem_one;
static sem_t sem_two;
static int num;
int main(int argc, char const \*argv[])
{
pthread_t id_t1, id_t2;
sem\_init(&sem_one, 0, 0);
sem\_init(&sem_two, 0, 1);
pthread\_create(&id_t1, NULL, read, NULL);
pthread\_create(&id_t2, NULL, accu, NULL);
pthread\_join(id_t1, NULL);
pthread\_join(id_t2, NULL);
sem\_destroy(&sem_one);
sem\_destroy(&sem_two);
return 0;
}
void \*read(void \*arg)
{
int i;
for (i = 0; i < 5; i++)
{
fputs("Input num: ", stdout);
sem\_wait(&sem_two);
scanf("%d", &num);
sem\_post(&sem_one);
}
return NULL;
}
void \*accu(void \*arg)
{
int sum = 0, i;
for (i = 0; i < 5; i++)
{
sem\_wait(&sem_one);
sum += num;
sem\_post(&sem_two);
}
printf("Result: %d \n", sum);
return NULL;
}
编译运行:
gcc semaphore.c -D_REENTRANT -o sema -lpthread
./sema
运行结果如下:
5 线程的销毁和多线程并发服务器端的实现
先介绍线程的销毁,然后再介绍多线程服务端
5.1 销毁线程的 3 种方法
Linux 的线程并不是在首次调用的线程 main 函数返回时自动销毁,所以利用如下方法之一加以明确。否则由线程创建的内存空间将一直存在。
- 调用
pthread_join
函数 - 调用
pthread_detach
函数
之前调用过 pthread_join
函数。调用该函数时,不仅会等待线程终止,还会引导线程销毁。但该函数的问题是,线程终止前,调用该函数的线程将进入阻塞状态。因此,通过如下函数调用引导线程销毁。
#include <pthread.h>
int pthread\_detach(pthread_t th);
/\*
成功时返回 0 ,失败时返回其他值
thread : 终止的同时需要销毁的线程 ID
\*/
调用上述函数不会引起线程终止或进入阻塞状态,可以通过该函数引导销毁线程创建的内存空间。调用该函数后不能再针对相应线程调用 pthread_join 函数。
5.2 多线程并发服务器端的实现
下面是多个客户端之间可以交换信息的简单聊天程序。
chat_server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#define BUF\_SIZE 100
#define MAX\_CLNT 256
void \*handle\_clnt(void \*arg);
void send\_msg(char \*msg, int len,int cur_sock);
void error\_handling(char \*msg);
int clnt_cnt = 0;
int clnt_socks[MAX_CLNT];
pthread_mutex_t mutx;
int main(int argc, char \*argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
int clnt_adr_sz;
pthread_t t_id;
if (argc != 2)
{
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
pthread\_mutex\_init(&mutx, NULL); //创建互斥锁
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1]));
if (bind(serv_sock, (struct sockaddr \*)&serv_adr, sizeof(serv_adr)) == -1)
error\_handling("bind() error");
if (listen(serv_sock, 5) == -1)
error\_handling("listen() error");
while (1)
{
clnt_adr_sz = sizeof(clnt_adr);
clnt_sock = accept(serv_sock, (struct sockaddr \*)&clnt_adr, &clnt_adr_sz);
pthread\_mutex\_lock(&mutx); //上锁
clnt_socks[clnt_cnt++] = clnt_sock; //写入新连接
pthread\_mutex\_unlock(&mutx); //解锁
pthread\_create(&t_id, NULL, handle_clnt, (void \*)&clnt_sock); //创建线程为新客户端服务,并且把clnt\_sock作为参数传递
pthread\_detach(t_id);
//引导线程销毁,不阻塞
printf("Connected client IP: %s \n", inet\_ntoa(clnt_adr.sin_addr)); //客户端连接的ip地址
}
![img](https://img-blog.csdnimg.cn/img_convert/fa40b5377773f99946e0289c8f31af87.png)
![img](https://img-blog.csdnimg.cn/img_convert/bb61847e35f31a7886921957c7130e49.png)
**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上C C++开发知识点,真正体系化!**
**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新**
**[如果你需要这些资料,可以戳这里获取](https://bbs.csdn.net/topics/618668825)**
t_cnt++] = clnt_sock; //写入新连接
pthread\_mutex\_unlock(&mutx); //解锁
pthread\_create(&t_id, NULL, handle_clnt, (void \*)&clnt_sock); //创建线程为新客户端服务,并且把clnt\_sock作为参数传递
pthread\_detach(t_id);
//引导线程销毁,不阻塞
printf("Connected client IP: %s \n", inet\_ntoa(clnt_adr.sin_addr)); //客户端连接的ip地址
}
[外链图片转存中...(img-uGFkXCvs-1715594296542)]
[外链图片转存中...(img-qknt1FLT-1715594296542)]
**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上C C++开发知识点,真正体系化!**
**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新**
**[如果你需要这些资料,可以戳这里获取](https://bbs.csdn.net/topics/618668825)**