一、线程间的同步机制
线程间同步机制：让多个线程在执行某个任务时，具有先后顺序的执行。
信号量：实现线程间同步。
操作步骤：
1. 定义信号量对象 ：sem_t
2. 初始化信号量 ： sem_init();int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：初始化信号量
参数：
sem：要初始化的信号量对象地址
pshared：
0 ： 线程间共享
非0 ： 进程间共享
value：信号量的初始值（初始资源数）
返回值：
成功：0
失败：-1
3.申请信号量： P操作 ：int sem_wait(sem_t *sem);
释放信号量：V操作：int sem_post(sem_t *sem);
也称为PV操作
4. 销毁信号量：int sem_destroy(sem_t *sem);
例：创建三个线程，分别让这三个线程按照顺序打印:A-->B-->C-->A-->B-->C
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
sem_t sem_a;
sem_t sem_b;
sem_t sem_c;
void *task1(void *arg)
{
while(1)
{
sem_wait(&sem_a);
printf("A\n");
sem_post(&sem_b);
sleep(1);
}
}
void *task2(void *arg)
{
while(1)
{
sem_wait(&sem_b);
printf("B\n");
sem_post(&sem_c);
sleep(1);
}
}
void *task3(void *arg)
{
while(1)
{
sem_wait(&sem_c);
printf("C\n");
sem_post(&sem_a);
sleep(1);
}
}
int main(int argc, char const *argv[])
{
pthread_t tid[3];
sem_init(&sem_a, 0, 1);
sem_init(&sem_b, 0, 0);
sem_init(&sem_c, 0, 0);
pthread_create(&tid[0], NULL, task1, NULL);
pthread_create(&tid[1], NULL, task2, NULL);
pthread_create(&tid[2], NULL, task3, NULL);
for(int i = 0; i < 3; ++i)
{
pthread_join(tid[i], NULL);
}
sem_destroy(&sem_a);
sem_destroy(&sem_b);
sem_destroy(&sem_c);
return 0;
}
二、死锁
死锁：死锁指的是在多线程环境中，每个执行流（线程）都有未释放的资源，且互相请求对方未释放资源，从而导致陷入永久等待状态的情况。
现象：
现象1：忘记释放锁
现象2：重复加锁
现象3：多线程多锁，抢占锁资源不当
如：线程A获取了1锁，线程B获取了2锁，同时线程A还想获取2锁，线程B还想获取1锁
产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用（一个执行流获取锁后，其它执行流不能再获取该锁）。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放（执行流本身使用着一把锁并不释放，还在请求别的锁）。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺（A执行流拿着锁，其它执行流不能释放）。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系（多个执行流拿着对方想要的锁，并且各执行流还去请求对方的锁）。
解决方法：
1.锁一定要成对出现
2.使线程的加锁顺序一致
3.破坏环路等待条件
使用非阻塞锁，一旦线程发现请求的锁被使用，就去释放自己拥有的锁
pthread_mutex_trylock();
int sem_trywait(sem_t *sem);
死锁现象
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void *threadA(void *arg) {
pthread_mutex_lock(&lock1); // 线程A获取lock1
printf("Thread A: Got lock1, waiting for lock2...\n");
sleep(1); // 模拟耗时操作，确保线程B能拿到lock2
pthread_mutex_lock(&lock2); // 线程A尝试获取lock2（但lock2被线程B持有）
printf("Thread A: Got both locks!\n"); // 永远无法执行到这里
pthread_mutex_unlock(&lock2);
pthread_mutex_unlock(&lock1);
return NULL;
}
void *threadB(void *arg) {
pthread_mutex_lock(&lock2); // 线程B获取lock2
printf("Thread B: Got lock2, waiting for lock1...\n");
sleep(1); // 模拟耗时操作，确保线程A能拿到lock1
pthread_mutex_lock(&lock1); // 线程B尝试获取lock1（但lock1被线程A持有）
printf("Thread B: Got both locks!\n"); // 永远无法执行到这里
pthread_mutex_unlock(&lock1);
pthread_mutex_unlock(&lock2);
return NULL;
}
int main() {
pthread_t t1, t2;
pthread_create(&t1, NULL, threadA, NULL);
pthread_create(&t2, NULL, threadB, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
printf("Program finished.\n"); // 永远不会执行到这里
return 0;
}
解决方法1：按固定顺序加锁
修改 threadB，使其加锁顺序与 threadA 一致（先 lock1 后 lock2）：
void *threadB(void *arg) {
pthread_mutex_lock(&lock1); // 改为先获取lock1
printf("Thread B: Got lock1, waiting for lock2...\n");
sleep(1);
pthread_mutex_lock(&lock2); // 再获取lock2
printf("Thread B: Got both locks!\n");
pthread_mutex_unlock(&lock2);
pthread_mutex_unlock(&lock1);
return NULL;
}
注：此时程序能正常结束，因为两个线程的加锁顺序一致，不会形成循环等待。
解决方法2：使用 pthread_mutex_trylock 避免死锁
如果某个线程发现锁被占用，就主动释放自己的锁，避免死锁：
void *threadA(void *arg) {
while (1) {
pthread_mutex_lock(&lock1);
printf("Thread A: Got lock1, trying lock2...\n");
if (pthread_mutex_trylock(&lock2) { // 尝试获取lock2
printf("Thread A: Failed to get lock2, releasing lock1...\n");
pthread_mutex_unlock(&lock1); // 释放lock1，避免死锁
sleep(1); // 稍后重试
} else {
printf("Thread A: Got both locks!\n");
pthread_mutex_unlock(&lock2);
pthread_mutex_unlock(&lock1);
break;
}
}
return NULL;
}
三、进程间的通信:IPC机制
（1）使用IPC机制的原因
进程间空间独立，无法直接通信，需要IPC机制实现通信。
（2）通信方法
同一主机进程间通信
1、古老的通信方式
无名管道
有名管道
信号：进程间通知机制2、IPC对象通信 system v
共享内存*：效率最高
消息队列
信号量集 （信号灯）主要用在不同主机进程间通信
3、socket通信
网络通信
（3）管道通信
1. 管道
有名管道：可以用于同一主机，任意进程间通信
无名管道：只能用于同一主机，具有亲缘关系的进程间通信（父子进程间）2. 无名管道
1）无名管道操作流程：
1. 创建无名管道：pipe();
2. 写管道：write(); pipefd[1] ------>写端
3. 读管道：read(); pipefd[0] ----->读端
4. 关闭管道：close();2）管道本质：
内核空间中的一段缓冲区，遵循先进先出特点。
无名管道的：读端：pipefd[0]
写端：pipefd[1]
读写端不能交换。无名管道默认大小：65536bytes = 64K
3）管道的特性：
1. 写阻塞：读端和写端都存在，向管道中写数据，当管道满时，发生写阻塞。
2. 读阻塞：读端和写端都存在，从管道中读数据，若管道为空，则发生读阻塞。
3. 读返回0：当写端关闭，从管道中读数据，若管道中有数据，则读到数据；
若管道中没有数据，read则返回0，不再阻塞。
4. 管道破裂：读端关闭，向管道中写入数据，发生管道破裂（异常）3. 有名管道
1）有名管道本质：
内核空间的一段缓冲区，但这块缓冲区和一个管道文件相关联。2）有名管道的操作流程：
1. 创建管道文件 mkfifo、mkfifo();
2. 打开管道文件 open();
3. 写管道文件 write();
4. 读管道文件 read();
5. 关闭管道文件 close();
6. 删除管道文件 int remove(const char *pathname);int mkfifo(const char *pathname, mode_t mode);
功能：创建一个管道文件
参数：
pathname：管道文件的名称
mode：管道文件的读写执行权限
返回值：
成功：0；
失败：-1
例：无名管道
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
int main(int argc, char const *argv[])
{
int pipefd[2];
int ret = pipe(pipefd);
char buff[1024] = {0};
if(ret < 0)
{
perror("pipe create error");
}
pid_t pid = fork();
if(pid > 0)
{
close(pipefd[0]);
while(1)
{
fgets(buff, sizeof(buff), stdin);
buff[strlen(buff) - 1] = '\0';
write(pipefd[1], buff, strlen(buff));
}
close(pipefd[1]);
wait(NULL);
}
else if(0 == pid)
{
close(pipefd[1]);
while(1)
{
memset(buff, 0, sizeof(buff));
read(pipefd[0], buff, sizeof(buff));
printf("buff = %s\n", buff);
}
close(pipefd[0]);
}
else
{
perror("fork process error");
}
return 0;
}
例：有名管道
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
int ret = mkfifo("./myfifo", 0664);
if(ret != 0 && errno != EEXIST)
{
perror("mkfifo error");
return -1;
}
int fd = open("./myfifo", O_WRONLY);
if(fd < 0)
{
perror("open error");
return -1;
}
while(1)
{
char buff[1024] = {0};
fgets(buff, sizeof(buff), stdin);
buff[strlen(buff) - 1] = '\0';
write(fd, buff, strlen(buff));
if(0 == strcmp(buff, "exit"))
{
break;
}
}
close(fd);
return 0;
}
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
int ret = mkfifo("./myfifo", 0664);
if(ret != 0 && errno != EEXIST)
{
perror("mkfifo error");
return -1;
}
int fd = open("./myfifo", O_RDONLY);
if(fd < 0)
{
perror("open error");
return -1;
}
while(1)
{
char buff[1024] = {0};
memset(buff, 0, sizeof(buff));
ssize_t cnt = read(fd, buff, sizeof(buff));
printf("cnt = %ld, buff = %s\n", cnt, buff);
if(0 == strcmp(buff, "exit"))
{
break;
}
}
close(fd);
remove("./myfifo");
return 0;
}
四、将内存区域填充成指定的数据函数
void *memset(void *s, int c, size_t n);
功能：将内存区域填充成指定的数据
参数：
s：要填充的空间首地址
c：要填充的字符
n：要填充的字节数
返回值：
成功：返回s的首地址
失败：NULL常见用途：
清零内存：memset(ptr, 0, size)（相当于 bzero）。
初始化数组：如 memset(arr, -1, sizeof(arr))（将 arr 所有字节设为 0xFF）。
填充特定模式：如 memset(buffer, 'A', 100)（填充 100 个 'A'）。
#include <stdio.h>
#include <string.h>
int main() {
char str[50];
memset(str, 'X', sizeof(str) - 1); // 填充 'X'
str[sizeof(str) - 1] = '\0'; // 确保字符串终止
printf("%s\n", str); // 输出 49 个 'X'
int arr[10];
memset(arr, 0, sizeof(arr)); // 清零数组
return 0;
}
扫一扫
1547
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
