两个进程，一个循环打印字符串，另一个循环倒置打印

1、要求定义一个全局变量 char buf[] = "1234567"，创建两个线程，不考虑退出条件。

A线程循环打印buf字符串，

B线程循环倒置buf字符串，即buf中本来存储1234567，倒置后buf中存储7654321. B线程中不打印！！

倒置不允许使用辅助数组。

要求A线程打印出来的结果只能为 1234567 或者 7654321 不允许出现7634521 7234567等乱序情况

不允许使用sleep函数

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
 
char buf[] = "1234567";
 
 
//线程的执行体
void* A(void* arg) //arg:create函数第四个参数的值
{
    for(int i=0;buf[i]!='\0';i++)
    {
        printf("%c ",buf[i]);
    //  sleep(1);
    }
    printf("\n");
    static int a = 10;
    //(void*)&a =(void*)&ptr
    pthread_exit((void*)&a);
}
 
void* B(void* arg)
{
    int len = strlen(buf);
    for(int i=0;i<len/2;i++)
    {
        char temp = buf[i];
        buf[i] = buf[len-i-1];
        buf[len-i-1] = temp;
    }
    //延长生命周期，防止子线程结束后，局部变量被销毁
    static int b = 20;
    pthread_exit((void*)&b);
 
}
 
int main(int argc, const char *argv[])                                               
{
    //创建线程
    pthread_t tid;
    pthread_create(&tid,NULL,A,NULL);
    void* ptr = NULL;
    //等到子线程的退出状态值传回，则继续向下运行代码，
    //否则join函数起阻塞作用
    pthread_join(tid,&ptr);
    printf("a=%d ptr=%p\n",*(int*)ptr,ptr);
    printf("子线程A运行结束\n");
 
    pthread_t tid2;
    pthread_create(&tid2,NULL,B,NULL);
    void* ptr2 = NULL;
    pthread_join(tid2,&ptr2);
    for(int i=0;buf[i]!='\0';i++)
    {
        printf("%c ",buf[i]);
    }
    printf("\n");
    printf("b=%d ptr2=%p\n",*(int*)ptr2,ptr2);
    printf("子线程B运行结束\n");
 
    printf("hahha\n");
    return 0;
}
                                                                                     
                                                                                     
                                                                                     

2、完成图片拷贝，要求一个线程拷贝一半，另一个线程拷贝另一半。

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
typedef struct
{
    int fd_r;
    int fd_w;
    off_t size;
}ThreadData;

pthread_mutex_t mutex;; 
 
 
void* pht1(void* arg) {

    ThreadData* data = (ThreadData*)arg;
    int fd_r = data->fd_r;
    int fd_w = data->fd_w;
    off_t size = data->size;
	//上锁
pthread_mutex_lock(&mutex);

    //修改文件偏移量到文件开头位置
    lseek(fd_r,0,SEEK_SET);
    lseek(fd_w,0,SEEK_SET);
    char c;
    for(int i=0;i<size/2;i++)
    {
        read(fd_r,&c,sizeof(c));
        write(fd_w,&c,sizeof(c));
    }
	//解锁
	pthread_mutex_unlock(&mutex);

    printf("复制完成\n");
    static int a = 10;
    pthread_exit((void*)&a);

}
 
void* pht2(void* arg)
{
 
    ThreadData* data = (ThreadData*)arg;
    int fd_r = data->fd_r;
    int fd_w = data->fd_w;
    off_t size = data->size;

 	//上锁
	pthread_mutex_lock(&mutex);
    //修改文件偏移量到文件中间位置
    lseek(fd_r,size/2,SEEK_SET);
    lseek(fd_w,size/2,SEEK_SET);
    char c;
    for(int i=size/2;i<size;i++)
    {
        read(fd_r,&c,sizeof(c));
        write(fd_w,&c,sizeof(c));
    }
	//解锁
	pthread_mutex_unlock(&mutex);
	printf("复制完成\n");
    //延长生命周期，防止子线程结束后，局部变量被销毁
    static int b = 20;
    pthread_exit((void*)&b);
 
}
 
int main(int argc, const char *argv[])
{

	//互斥锁初始化
	pthread_mutex_init(&mutex,NULL);
    //打开读文件
 
    int fd_r = open("./1.jpg",O_RDONLY);
    if(fd_r < 0)
    {
        perror("open_r");
        return -1;
    }
 
    //打开写文件
    int fd_w = open("./2.jpg",O_WRONLY|O_CREAT|O_TRUNC,0664);
    if(fd_r < 0)
    {
        perror("open_w");
        return -1;
    }
    //求文件大小
    off_t size = lseek(fd_r,0,SEEK_END);
 
    ThreadData data = {fd_r,fd_w,size};
 
    //子线程1
    pthread_t tid;
    pthread_create(&tid,NULL,pht1,(void*)&data);
    void* ptr = NULL;
    //等到子线程的退出状态值传回，则继续向下运行代码，
    //否则join函数起阻塞作用
    pthread_join(tid,&ptr);
   
 
    //子线程2
    pthread_t tid2;
    pthread_create(&tid2,NULL,pht2,(void*)&data);
    void* ptr2 = NULL;
    pthread_join(tid2,&ptr2);
    
    close(fd_r);
    close(fd_w);

    return 0;
}