3day6（线程间的通信）

原创 已于 2024-08-27 21:37:55 修改 · 243 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #c语言 #学习 #linux

于 2024-08-27 19:33:46 首次发布

作业一：创建3个线程，一个子线程拷贝文件的前一半，一个子线程拷贝后一半文件，主线程回收子线程资源。

（外部传参版）

#include <myhead.h>

//作业一：创建3个线程，一个子线程拷贝文件的前一半，一个子线程拷贝后一半文件，主线程回收子线程资源。
int get_len(const char *p1, const char *p2)
{
    int fd1 = open(p1, O_RDONLY); // 打开源文件
    if (fd1 == -1)
    {
        perror("open1");
        return -1;
    }
    int fd2 = open(p2, O_WRONLY | O_CREAT | O_TRUNC, 0664); // 打开创建目标文件
    if (fd2 == -1)
    {
        perror("open2");
        close(fd1);
        return -1;
    }
    int len = lseek(fd1, 0, SEEK_END); // 计算源文件长度
    close(fd1);
    close(fd2);
    return len;
}

void* copy_file(void *arg)
{
    char **args = (char**)arg;
    const char *src = args[0];
    const char *dest = args[1];
    int start = atoi(args[2]);
    int len = atoi(args[3]);

    int fd1, fd2;
    fd1 = open(src, O_RDONLY); // 只读方式打开源文件
    if (fd1 == -1)
    {
        perror("open1");
        pthread_exit(NULL);
    }
    fd2 = open(dest, O_WRONLY); // 只写方式打开目标文件
    if (fd2 == -1)
    {
        perror("open2");
        close(fd1);
        pthread_exit(NULL);
    }

    lseek(fd1, start, SEEK_SET);
    lseek(fd2, start, SEEK_SET);
    char buff[1024];
    int sum = 0;
    while (1)
    {
        int res = read(fd1, buff, sizeof(buff));
        sum += res;
        if (sum >= len || res == 0)
        {
            write(fd2, buff, res - (sum - len));
            break;
        }
        write(fd2, buff, res);
    }
    close(fd1);
    close(fd2);
    pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
    if (argc != 3)
    {
        printf("外部传参错误\n");
        return -1;
    }
    int len = get_len(argv[1], argv[2]); // 获取源文件的长度,打开创建目标文件
    if (len == -1)
    {
        return -1;
    }

    pthread_t tid1, tid2;
    char *args1[4] = {(char*)argv[1], (char*)argv[2], "0", malloc(20)};
    char *args2[4] = {(char*)argv[1], (char*)argv[2], malloc(20), malloc(20)};
    
    sprintf(args1[3], "%d", len/2);
    sprintf(args2[2], "%d", len/2);
    sprintf(args2[3], "%d", len - len/2);

    // 创建第一个线程拷贝前一半
    if (pthread_create(&tid1, NULL, copy_file, args1) != 0)
    {
        perror("pthread_create");
        return -1;
    }

    // 创建第二个线程拷贝后一半
    if (pthread_create(&tid2, NULL, copy_file, args2) != 0)
    {
        perror("pthread_create");
        return -1;
    }

    // 等待两个线程结束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    // 释放动态分配的内存
    free(args1[3]);
    free(args2[2]);
    free(args2[3]);

    printf("文件拷贝完成\n");
    return 0;
}

（外部传参，注释多一点，后续可更改）

#include <myhead.h>
//作业一：创建3个线程，一个子线程拷贝文件的前一半，
//一个子线程拷贝后一半文件，主线程回收子线程资源。
//
#define AZE 10//读取时中间变量数组的大小（缓冲区的大小）

//全局变量
int fd_src;//源文件的目标描述符
int fd_dest;//目标文件的文件描述符
off_t file_size;//源文件的大小

void *copy_my_first(void * arg)//读取上半文件并拷贝
{
	char buff[AZE];//中间变量数组
	ssize_t bytes_read;//接受读取函数的返回值
	ssize_t bytes_write;//接收写入函数的返回值
	off_t current_pos =0;//光标所在位置（已经读取到的位置，防止超过一半）

	while (current_pos < file_size/2)//循环读取并拷贝到一半
	{
		bytes_read = read(fd_src,buff,(file_size/2-current_pos < AZE)?
				(file_size/2-current_pos):AZE);//此处用三目运算符代替下面的判断运算，
		//结果一样，效果简化了代码,提高了可阅读性
#if 0
		//等价于
		int len = file_size/2-current_pos;//计算是
				if(len<AZE)//判断是否到达中点
		{
			len = AZE;//没有到达中点则继续之前的大小读取
		}
		else//到达中点则按照剩余多少就取多大
		{
			len = file_size/2-current_pos;
		}
		bytes_read = read (fd_src,buff,len);

#endif
		if(bytes_read <= 0) break;//简化了读取错误时和读到文件末尾时的操作
		//无法区分是否读取错误，但缩减了代码量
		//等价于（不完全等价）
#if 0
		if(bytes_read = -1)
		{
			perror("bytes_read");
			break;
		}
		if(bytes_read = 0)
		{
			printf("文件前半部分读取完毕\n");
		}
#endif
	  bytes_write = write(fd_dest, buff, bytes_read);
	  //文件写入（拷贝）
        if (bytes_write != bytes_read) //错误则退出循环
		{
            perror("Write error");
            break;
        }

        current_pos += bytes_read;//光标位置记录（依靠读取返回值的累加）
    }

    pthread_exit(NULL);//结束线程
}

// 拷贝文件后半部分的线程函数
void* copy_second_half(void* arg) 
{
   	char buff[AZE];//中间变量数组
	ssize_t bytes_read;//接受读取函数的返回值
	ssize_t bytes_write;//接收写入函数的返回值
	off_t current_pos =0;//光标所在位置（已经读取到的位置，防止超过一半）

    // 将文件指针移动到文件中间
    lseek(fd_src, file_size / 2, SEEK_SET);//光标置位到中间

    while (current_pos < file_size) 
	{
        // 读取数据，确保不会读取超过文件末尾
        bytes_read = read(fd_src, buff,
                          (file_size - current_pos < AZE) ?
                          (file_size - current_pos) : AZE);

        if (bytes_read <= 0) break;  // 读取错误或到达文件末尾

        // 写入数据到目标文件
        bytes_write = write(fd_dest, buff, bytes_read);
        if (bytes_write != bytes_read) 
		{
            perror("Write error");
            break;
        }

        current_pos += bytes_read;
    }

    pthread_exit(NULL);
}
//主函数
int main(int argc, const char *argv[])
{
	  // 检查命令行参数
    if (argc != 3) 
	{
        fprintf(stderr, "Usage: %s <source_file> <destination_file>\n", argv[0]);
		//stderr 标准错误流.
		//%s 是一个格式说明符，它会被后面的参数替换。
		//<source_file> 和 <destination_file> 是提示用户需要提供的参数。
		//这是程序的名称。在命令行中，argv[0] 通常包含了执行的程序名。
		//使用 %s 和 argv[0] 可以确保无论程序如何重命名，使用说明中都会显示正确的程序名。
        exit(1);//错误则结束程序运行
    }

    // 打开源文件
    fd_src = open(argv[1], O_RDONLY);//只读方式打开源文件
    if (fd_src == -1) 
	{
        perror("读取出错1");
        exit(1);//错误则结束程序运行

    }

    // 打开或创建(文件不存在则创建文件)目标文件
    fd_dest = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0664);//
    if (fd_dest == -1) 
	{
        perror("Error opening destination file");
        close(fd_src);
        exit(1);//错误则结束程序运行

    }

    // 获取源文件的大小
    struct stat st;
    if (fstat(fd_src, &st) != 0) 
	{
        perror("Error getting file size");
        close(fd_src);
        close(fd_dest);
        exit(1);//错误则结束程序运行

    }
    file_size = st.st_size;

    pthread_t thread1, thread2;//定义线程

    // 创建第一个线程拷贝前半部分
    if (pthread_create(&thread1, NULL, copy_my_first, NULL) != 0) 
	{
        perror("Error creating thread 1");
        close(fd_src);
        close(fd_dest);
        exit(1);
    }

    // 创建第二个线程拷贝后半部分
    if (pthread_create(&thread2, NULL, copy_second_half, NULL) != 0) 
	{
        perror("Error creating thread 2");
        close(fd_src);
        close(fd_dest);
        exit(1);
    }

    // 等待两个线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 关闭文件
    close(fd_src);
    close(fd_dest);

    printf("File copy completed.\n");

	return 0;
}

作业二：使用无名信号量实现循环输出 春、夏、秋、冬。

（稍改版）

include <myhead.h>

sem_t sem1,sem2,sem3,sem4;
void *fun1(void *ggg)
{
	while(1)
	{
		sem_wait(&sem4);
		printf("春天\t");
		fflush(stdout);
		sem_post(&sem3);

	}
	pthread_exit(NULL);
}
void *fun2(void *ggg)
{
	while(1)
	{
		sem_wait(&sem3);
		printf("夏天\t");
		fflush(stdout);
		sem_post(&sem2);
	}
	pthread_exit(NULL);
}
void *fun3(void *ggg)
{
	while(1)
	{
		sem_wait(&sem2);
		printf("秋天\t");
		fflush(stdout);
		sem_post(&sem1);
	}
	pthread_exit(NULL);
}
void *fun4(void *ggg)
{
	while(1)
	{
		sem_wait(&sem1);
		printf("冬天\t");
		fflush(stdout);
		sem_post(&sem4);
	}
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	pthread_t tid1,tid2,tid3,tid4;

	sem_init(&sem1,0,0);
	sem_init(&sem2,0,0);
	sem_init(&sem3,0,0);
	sem_init(&sem4,0,1);
	if(pthread_create(&tid1,NULL,fun1,NULL)!=0)
	{
		perror("ptcreat1");
		return -1;
	}
	if(pthread_create(&tid2,NULL,fun2,NULL)!=0)
	{
		perror("ptcreat2");
		return -1;
	}
	if(pthread_create(&tid3,NULL,fun3,NULL)!=0)
	{
		perror("ptcreat3");
		return -1;
	}
	if(pthread_create(&tid4,NULL,fun4,NULL)!=0)
	{
		perror("ptcreat4");
		return -1;
	}


	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);
	pthread_join(tid4,NULL);
	return 0;
}

作业三：互斥锁，无名信号量，条件变量再联系一遍。

思维导图：

Java零基础之多线程篇：线程间如何通信？
喵手的博客
08-03 1449
随着计算机技术的发展，多线程编程已经成为现代软件开发中的一个重要方向。在多线程编程中，线程间的通信是一个非常关键的问题。在Java开发语言中，Java提供了一些机制来实现线程间的通信，帮助开发者协调不同线程之间的执行顺序和数据交换。本文将介绍Java多线程编程中的线程间通信的相关知识。首先，我们将从简介开始，介绍线程间通信的基本概念和原理。然后，我们将通过源代码解析的方式，深入探讨Java中实现线程间通信的方法。接着，我们将给出一些应用场景案例，展示线程间通信在实际开发中的应用。
【学习嵌入式day-26-线程间通信】
weixin_47152578的博客
08-16 983
摘要： 本文包含三个主要部分：1) 文件遍历程序，实现在指定目录下查找特定扩展名文件（如.mp3/.mp4等）的功能；2) 多线程编程示例，创建四个不同功能的线程（采集、存储、显示、日志）并演示线程属性设置；3) 线程同步机制，包括互斥锁和信号量的使用，以及如何避免死锁情况。代码展示了Linux系统编程中常见的目录操作、线程创建与管理、线程间通信等关键技术，并提供了详细的函数接口说明和实现示例。
day 22线程间通信
2301_79909332的博客
08-08 727
2、互斥锁： 是一种资源,当一个线程任务加锁,其余线程任务无法再次加锁,直到解锁后才能加锁，互斥锁主要是用来防止多个线程任务竞争某个资源，加锁和解锁中间的代码称为临界代码也称为临界区。2.不剥夺条件：不剥夺条件是指一个线程任务已经锁定了一个资源,不能被其他线程任务抢占,直到它使用完该资源。资源是有限的，在程序运行过程中，一段代码、一段空间、一个变量、CPU、内存都可以看做资源。资源数 == 0 申请操作会阻塞,直到资源数不为0,申请得到资源后继续向下执行。2.打破互斥条件、不可剥夺条件（不建议使用）
Java学习——day27（线程间通信与死锁防范）
blackA_的博客
04-11 742
通过·wait()notify()和实现线程间的协调，确保在临界区内的线程能够互相告知状态变化，从而达到数据共享和顺序控制。学习了死锁的四个必要条件，并通过设计合理的同步代码（避免不必要的嵌套锁定和严格的锁获取顺序）来防止死锁的发生。编写协作代码时，应尽量缩小 synchronized 块的范围，确保及时释放锁。
python 线程通信 day08
时光
08-15 741
目录 线程通信 python 线程的GIL问题 服务器模型 day08 线程通信 线程通信 通信方法：多个线程共用进程空间，所以进程的全局变量对进程内线程均可见。线程往往使用全局变量进行通信 注意事项：线程间使用全局变量进行通信，全局变量为共享资源，往往同步互斥机制 示例： # three1.py from threading import Thread from tim...
day 31 线程间的同步和互斥
luochen330x的博客
12-17 851
死锁是指在多线程多进程环境中，两个或多个进程（或线程）互相持有对方所需资源，导致它们都无法继续执行的一种状态。避免嵌套锁：尽量避免在持有一个锁的时候去申请另一个锁，因为这样可能会导致死锁的发生。统一获取锁的顺序：如果多个线程需要获取多个锁，可以约定获取锁的顺序，这样可以避免出现死锁。设置超时时间：在获取锁的时候可以设置超时时间，如果超过一定时间还没有获取到锁，就放弃获取锁并释放已经获取的锁。死锁检测：通过检测程序的锁状态来判断是否存在死锁，并进行相应的处理。
Day39 | Java线程通信的两种方式
懒惰蜗牛的博客
10-15 981
本文详细讲解了Java中线程协作的两种方式：1）使用synchronized配合Object的wait/notify机制，通过生产者-消费者模型演示了线程如何在共享资源上协作；2）使用ReentrantLock配合Condition接口，通过创建多个等待队列实现更精细化的线程控制。两种方式都能实现线程间的通信与协调，但Condition提供了更灵活的等待/唤醒机制，可以精准控制特定条件下的线程唤醒，减少不必要的上下文切换。文章通过包子铺案例对比了两种实现方式的代码差异，帮助读者理解多线程协作的核心机制。
day6-day7多线程和并发
m0_46391590的博客
05-31 885
线程与进程的区别线程是操作系统能够进行运算调度最小的单元，是进程的执行单元。线程是进程内部创建和调度的，共享进程的资源；进程具有独立的地址空间，而线程共享进程的地址空间。进程之间通信需要特殊的机制，如管道、消息队列，而线程之间通信可以通过共享内存直接访问。进程切换开销较大，涉及到地址空间的切换，而线程切换开销较小，因为线程共享地址空间和其他资源。
day15 07线程通信-死锁概述
qq_42722278的博客
03-09 131
Java多线程同步和通信
♾️
12-07 2487
多线程同步 回顾 1 进程:正在运行的程序，操作系统通过进程Id区分不同进程。 2 线程：进程中的一条执行路径。一个进程中可以包含多个线程，至少有一个。 3 区别: a.一个程序运行后至少有一个进程 b.一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义的 c.进程间不能共享资源，但线程之间可以 d.系统创建进程需要为该进程重新分配系统资源，而创建线程则容易的多，...
Day 22多线程、线程通信、线程池和Lambda表达式
12-22
线程通信是解决多线程间共享资源问题的关键。在Java中，可以使用`synchronized`关键字、`wait()`, `notify()`, `notifyAll()`等方法实现线程间的同步与通信。例如，生产者消费者模型中，生产者线程和消费者线程通过...
进程、线程和进程间通信课件资料.zip
01-10
day1_1进程基础（基本概念）.pptx day1_2进程基础（常用命令）....day6_3进程间通信（有名管道）.pptx day7_1进程间通信（内存映射).pptx day7_2进程间通信（systemV共享内存）.pptx day8_1进程间通信（信号机制）.pptx
python 08、多任务编程多线程 3-1_进程间通信、同步互斥、threading线程_Day03_AM.mp4
03-09
python 08、多任务编程多线程 3-1_进程间通信、同步互斥、threading线程_Day03_AM.mp4
【开发语言】Rust语言介绍
wendao76的专栏
12-07 1591
Rust是一种系统级编程语言，由Mozilla开发并于2015年发布1.0版本，现由Rust基金会维护。其核心特点是内存安全、高性能和并发友好，通过所有权模型和零成本抽象实现无GC的内存管理。与Go相比，Rust更适用于高性能系统编程，而Go更适合快速开发高并发服务。Rust广泛应用于操作系统、区块链、Web后端等领域，并连续多年被评为最受开发者喜爱的语言。基础语法包括变量、数据类型、所有权等，高级特性涵盖Trait、生命周期、异步编程等。尽管学习曲线陡峭，但Rust在性能敏感领域前景广阔。
C语言实战3
2201_75969037的博客
12-12 223
本文介绍了基于C语言开发的学生成绩管理系统。系统采用结构体存储学生信息，实现动态内存管理和文件读写功能。核心模块包括成绩录入、查询统计及二进制文件存储，通过控制台菜单实现交互界面。项目注重错误处理机制和内存泄漏防护，并提供了扩展建议（如链表结构、图形界面等）。开发过程中强调代码注释规范和版本控制工具的使用。该系统实现了学生成绩管理的基础功能，具有良好的可扩展性。
运放学习笔记
最新发布
Z97371539的博客
12-13 459
单电源运放是指仅使用单一电源电压（例如，+5V）和地（0V）作为电源供给的运放。也就是说，它只需要一个正电压和地作为参考电压，而不需要负电压。
学习离线处理 [CSP-J 2022 山东] 部署
SHOJYS的博客
12-09 766
所谓离线, 就是等你操作完了后再问你问题, 每一次操作时间复杂度可能很大, 我们可以把操作堆起来最后一遍完成.我们记录完之后, 就是要统计答案了. 我们不妨先思考操作二该怎么统计., 而对于其子节点和祖先而言, 兵力都要增加。我们不妨记录两个内容, 一个是操作一在节点。最后展示总代码, 当然肯定与上述有部分出入.. 但问题来了, 它的子树都要增加。要求增加的兵, 不妨将其设为。要求增加的兵, 不妨将其设为。我们再思考操作一该怎么统计.而言, 其增加的兵力就是。而言, 其兵力增加就是。我们首先记录所有操作,
学习笔记095——Ubuntu 安装 lrzsz 服务？
code__bee的博客
12-10 400
lrzsz是一款基于协议的文件传输工具集，专门用于在终端环境下实现本地与远程服务器之间的文件上传和下载，是 Linux/Unix 运维和开发场景中常用的轻量级工具。
Kamailio的学习
2301_79965178的博客
12-12 590
摘要：本文详细介绍了Kamailio SIP服务器的架构与配置。Kamailio是一款支持高并发、多协议的高性能SIP服务器，采用模块化设计，包含150多个功能模块。文章从配置文件结构（全局参数、模块设置、路由区块）入手，深入解析其多进程模型、Epoll多路复用机制、共享内存和锁定系统等底层实现。重点阐述了Kamailio处理SIP消息的完整流程，包括请求/响应处理、进程间通信等核心机制，并展示了通过kamcmd命令查看进程状态的实践示例。
深入解析day14_多线程编程技术要点
### 线程通信 多线程间通信通常使用wait()、notify()和notifyAll()方法。这些方法定义在Object类中，因此所有的Java对象都可以使用这些方法来进行线程间的协作。 ### 线程池 为了减少线程创建和销毁的开销，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值