线程相关作业

1.创建两个线程，分支线程1拷贝文件的前一部分，分支线程2拷贝文件的后一部分

#include "head.h"#define BUFFER_SIZE 1024// 线程参数结构体，包含文件名和文件偏移量
typedef struct {FILE *src_file;FILE *dest_file;long start_offset;long length;
} ThreadArgs;// 线程1：拷贝文件的前一部分
void *copyFirstPart(void *args) {ThreadArgs *thread_args = (ThreadArgs *)args;FILE *src = thread_args->src_file;FILE *dest = thread_args->dest_file;long start_offset = thread_args->start_offset;long length = thread_args->length;// 分配缓冲区char buffer[BUFFER_SIZE];fseek(src, start_offset, SEEK_SET);long bytes_read = 0;while (bytes_read < length) {size_t read_size = (length - bytes_read < BUFFER_SIZE) ? (length - bytes_read) : BUFFER_SIZE;size_t read_count = fread(buffer, 1, read_size, src);fwrite(buffer, 1, read_count, dest);bytes_read += read_count;}printf("Thread 1 finished copying the first part.\n");return NULL;
}// 线程2：拷贝文件的后一部分
void *copySecondPart(void *args) {ThreadArgs *thread_args = (ThreadArgs *)args;FILE *src = thread_args->src_file;FILE *dest = thread_args->dest_file;long start_offset = thread_args->start_offset;long length = thread_args->length;// 分配缓冲区char buffer[BUFFER_SIZE];fseek(src, start_offset, SEEK_SET);long bytes_read = 0;while (bytes_read < length) {size_t read_size = (length - bytes_read < BUFFER_SIZE) ? (length - bytes_read) : BUFFER_SIZE;size_t read_count = fread(buffer, 1, read_size, src);fwrite(buffer, 1, read_count, dest);bytes_read += read_count;}printf("Thread 2 finished copying the second part.\n");return NULL;
}int main() {FILE *src_file = fopen("head.h", "rb");if (src_file == NULL) {perror("Error opening source file");return 1;}// 获取源文件的大小fseek(src_file, 0, SEEK_END);long file_size = ftell(src_file);fseek(src_file, 0, SEEK_SET);// 创建两个目标文件FILE *dest_file1 = fopen("part1.h", "wb");FILE *dest_file2 = fopen("part2.h", "wb");if (dest_file1 == NULL || dest_file2 == NULL) {perror("Error opening destination file");fclose(src_file);return 1;}// 创建线程pthread_t thread1, thread2;// 设置线程参数ThreadArgs args1 = {src_file, dest_file1, 0, file_size / 2};ThreadArgs args2 = {src_file, dest_file2, file_size / 2, file_size - file_size / 2};// 创建两个线程，分别拷贝前后部分pthread_create(&thread1, NULL, copyFirstPart, &args1);pthread_create(&thread2, NULL, copySecondPart, &args2);// 等待线程完成pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 关闭文件fclose(src_file);fclose(dest_file1);fclose(dest_file2);printf("File copy completed.\n");return 0;
}

2.创建3个线程，线程A打印A，线程B打印B，线程C打印C，要求重复打印顺序ABC (分别使用信号量和条件变量实现)

#include "head.h"sem_t semA, semB, semC;  // 信号量A, B, C// 线程A打印A
void* printA(void* arg) {while (1) {sem_wait(&semA);  // 等待信号量Aprintf("A\n");sleep(1);sem_post(&semB);  // 释放信号量B，通知线程B执行}return NULL;
}// 线程B打印B
void* printB(void* arg) {while (1) {sem_wait(&semB);  // 等待信号量Bprintf("B\n");sleep(1);sem_post(&semC);  // 释放信号量C，通知线程C执行}return NULL;
}// 线程C打印C
void* printC(void* arg) {while (1) {sem_wait(&semC);  // 等待信号量C                        printf("C\n");sleep(1);sem_post(&semA);  // 释放信号量A，通知线程A执行}return NULL;
}int main() {// 初始化信号量sem_init(&semA, 0, 1);  // 初始化信号量A为1，线程A先执行sem_init(&semB, 0, 0);  // 初始化信号量B为0，线程B等待线程Asem_init(&semC, 0, 0);  // 初始化信号量C为0，线程C等待线程B// 创建线程pthread_t threadA, threadB, threadC;pthread_create(&threadA, NULL, printA, NULL);pthread_create(&threadB, NULL, printB, NULL);pthread_create(&threadC, NULL, printC, NULL);// 等待线程结束（实际上永远不会结束，因为是无限循环）pthread_join(threadA, NULL);pthread_join(threadB, NULL);pthread_join(threadC, NULL);// 销毁信号量sem_destroy(&semA);sem_destroy(&semB);sem_destroy(&semC);return 0;
}

#include "head.h"// 定义条件变量和互斥锁
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;// 用于控制线程执行的变量
int current_thread = 0;  // 0: A, 1: B, 2: C// 线程 A
void* print_A(void* arg) {while (1) {pthread_mutex_lock(&mutex);while (current_thread != 0) {pthread_cond_wait(&cond, &mutex);  // 等待轮到线程 A}sleep(1);printf("A\n");  // 打印 Afflush(stdout);  // 刷新输出缓冲区current_thread = 1;  // 切换到线程 Bpthread_cond_broadcast(&cond);  // 唤醒其他线程pthread_mutex_unlock(&mutex);}return NULL;
}// 线程 B
void* print_B(void* arg) {while (1) {pthread_mutex_lock(&mutex);while (current_thread != 1) {pthread_cond_wait(&cond, &mutex);  // 等待轮到线程 B}                                                                  sleep(1);printf("B\n");  // 打印 Bfflush(stdout);  // 刷新输出缓冲区current_thread = 2;  // 切换到线程 Cpthread_cond_broadcast(&cond);  // 唤醒其他线程pthread_mutex_unlock(&mutex);}return NULL;
}// 线程 C
void* print_C(void* arg) {while (1) {pthread_mutex_lock(&mutex);while (current_thread != 2) {pthread_cond_wait(&cond, &mutex);  // 等待轮到线程 C}sleep(1);printf("C\n");  // 打印 Cfflush(stdout);  // 刷新输出缓冲区current_thread = 0;  // 切换到线程 Apthread_cond_broadcast(&cond);  // 唤醒其他线程pthread_mutex_unlock(&mutex);}return NULL;
}int main() {pthread_t thread_A, thread_B, thread_C;// 创建线程pthread_create(&thread_A, NULL, print_A, NULL);pthread_create(&thread_B, NULL, print_B, NULL);pthread_create(&thread_C, NULL, print_C, NULL);// 等待线程结束pthread_join(thread_A, NULL);pthread_join(thread_B, NULL);pthread_join(thread_C, NULL);return 0;
}