进程线程3：无名信号量，互斥锁

#include<myhead.h>
typedef struct 
{
    const char *p1;
    const char *p2;
    int start;
    int len;
}File;

int get_len(const char *p1,const char *p2)
{
    int fd1,fd2;
    fd1=open(p1,O_RDONLY);
    if (fd1==-1)
    {
        perror("open1");
        return -1;
    }
    fd2=open(p2,O_CREAT|O_WRONLY|O_TRUNC,0664);
    if (fd2==-1)
    {
        perror("open2");
        return -1;
    }
    int len=lseek(fd1,0,SEEK_END);
    close(fd1);
    close(fd2);
    return len;
};

void *copy_file(void *FFF)
{
    File *banz = (File *)FFF;

    int fd1,fd2;
    if((fd1 =open(banz->p1,O_RDONLY))==-1)
    {
        perror("open 1");
        return NULL;
    }
    if((fd2=open(banz->p2,O_WRONLY))==-1)
    {
        perror("open 2");
        return NULL;
    }

    
    lseek(fd1,banz->start,SEEK_SET);
    lseek(fd2,banz->start,SEEK_SET);

    char buff[200];
    int sum=0;
    while (1)
    {
        memset(buff,0,sizeof(buff));
        int res =read(fd1,buff,sizeof(buff));
        sum+=res;
        if(sum>=banz->len||res==0)
        {
            write(fd2,buff,res-(sum-banz->len));
            break;
        }
        write(fd2,buff,res);
    }
    pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
    pthread_t tid1,tid2;
    if (argc !=3)
    {
        printf("外部传参错误\n");
        return -1;
    }
    int len=get_len(argv[1],argv[2]);

    File FFF[2]={{argv[1],argv[2],0,len/2},{argv[1],argv[2],len/2,len-(len/2)}};
    
    if(pthread_create(&tid1,NULL,copy_file,&FFF[0])!=0)
    {
        perror("ptcreat1");
        return -1;
    }
    if(pthread_create(&tid2,NULL,copy_file,&FFF[1])!=0)
    {
        perror("ptcreat1");
        return -1;
    }
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
return 0;
}

#include <myhead.h> 
 
// 定义四个信号量
sem_t sem1, sem2, sem3, sem4;
 
// 线程1的函数：打印“春”
void *fun1(void *ggg)
{
    while(1)
    {
        sem_wait(&sem4);  // 等待信号量sem4被释放
        printf("春\t");
        fflush(stdout);   // 确保输出立即刷新到屏幕
        sem_post(&sem3);  // 释放信号量sem3，唤醒线程2
    }
}
 
// 线程2的函数：打印“夏”
void *fun2(void *ggg)
{
    while(1)
    {
        sem_wait(&sem3);  // 等待信号量sem3被释放
        printf("夏\t");
        fflush(stdout);   // 确保输出立即刷新到屏幕
        sem_post(&sem2);  // 释放信号量sem2，唤醒线程3
    }
}
 
// 线程3的函数：打印“秋”
void *fun3(void *ggg)
{
    while(1)
    {
        sem_wait(&sem2);  // 等待信号量sem2被释放
        printf("秋\t");
        fflush(stdout);   // 确保输出立即刷新到屏幕
        sem_post(&sem1);  // 释放信号量sem1，唤醒线程4
    }
}
 
// 线程4的函数：打印“冬”
void *fun4(void *ggg)
{
    while(1)
    {
        sem_wait(&sem1);  // 等待信号量sem1被释放
        printf("冬\t");
        fflush(stdout);   // 确保输出立即刷新到屏幕
        sem_post(&sem4);  // 释放信号量sem4，唤醒线程1，形成循环
    }
}
 
int main(int argc, char const *argv[])
{
    pthread_t tid1, tid2, tid3, tid4;
 
    // 初始化信号量，初始值为0表示线程需等待其他线程的信号
    sem_init(&sem1, 0, 0);
    sem_init(&sem2, 0, 0);
    sem_init(&sem3, 0, 0);
    sem_init(&sem4, 0, 1);  // 初始化sem4为1，确保线程1最先执行
 
    // 创建线程1，执行fun1函数
    if (pthread_create(&tid1, NULL, fun1, NULL) != 0)
    {
        perror("pthread_create1");
        return -1;
    }
 
    // 创建线程2，执行fun2函数
    if (pthread_create(&tid2, NULL, fun2, NULL) != 0)
    {
        perror("pthread_create2");
        return -1;
    }
 
    // 创建线程3，执行fun3函数
    if (pthread_create(&tid3, NULL, fun3, NULL) != 0)
    {
        perror("pthread_create3");
        return -1;
    }
 
    // 创建线程4，执行fun4函数
    if (pthread_create(&tid4, NULL, fun4, NULL) != 0)
    {
        perror("pthread_create4");
        return -1;
    }
 
    // 主线程等待所有子线程完成（实际不会完成，因为线程在无限循环中）
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    pthread_join(tid4, NULL);
 
    // 销毁信号量，释放资源
    sem_destroy(&sem1);
    sem_destroy(&sem2);
    sem_destroy(&sem3);
    sem_destroy(&sem4);
 
    return 0;
}