学习记录——day24 多线程编程

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
功能：在当前进程中，创建一个分支线程
参数1：用于接收创建好的线程ID
参数2：线程的属性，一般填NULL表示使用系统默认的属性创建线程
参数3：线程体函数，需要传递一个函数，参数为void*，返回值为void*
参数4：参数3的参数
返回值：成功创建返回0，失败返回一个错误码，注意，不是内核提供的错误码

#include <myhead.h>

struct Buf
{
    int num;
    double key;
};

void *task(void *arg)
{
    int num = (*((struct Buf*)arg)).num;
    double key = ((struct Buf*)arg)->key;
    while (1)
    {
        printf("分支线程  num = %d,key = %.2lf\n",num,key);
        sleep(1);
    }
}

int main(int argc, char const *argv[])
{
    int num = 2024;
    double key = 1024;

    struct Buf buf = {num,key};

    pthread_t tid = 1;

    if (pthread_create(&tid, NULL, task, &buf) != 0)
    {
        printf("pthread error");
        return -1;
    }

    printf("主线程 tid = %#lx\n",tid);

    getchar();
    while (1);

    return 0;
}

pthread -self：线程号获取

#include <pthread.h>

pthread_t pthread_self(void);
功能：获取当前线程的线程号
参数：无
返回值：当前线程的线程号

pthread_exit：线程退出函数

#include <pthread.h>

void pthread_exit(void *retval);
功能：退出当前的线程
参数：线程退出时的状态，一般填NULL
返回值：无

#include <myhead.h>

void *task(void *arg)
{
    printf("子线程线程号 = %#lx\n", pthread_self());
    
    //exit(EXIT_SUCCESS);  //再线程中进程退出  主线程也会结束
    pthread_exit(NULL);  //线程退出 不影响主线程
}

int main(int argc, char const *argv[])
{
    //定义变量存储线程号
    pthread_t tid = 1;

    //创建线程
    if (pthread_create(&tid, NULL, task, NULL) != 0)
    {
        printf("pthread error");
        return -1;
    }

    printf("主线程 tid = %#lx 线程号 = %#lx\n", tid, pthread_self());

    //阻塞函数  主线程结束进程结束，分支线程也终止
    getchar();

    return 0;
}

pthread_jion：线程资源回收

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);
功能：阻塞等待给定线程的退出，并回收该线程的资源
参数1：要回收的线程号
参数2：接收线程退出时的状态
返回值：成功返回0，失败返回错误码

#include <myhead.h>

void *task(void *arg)
{
    printf("子线程 线程号 = %#lx\n", pthread_self());
    
    sleep(3);
    //exit(EXIT_SUCCESS);  //再线程中进程退出  主线程也会结束
    pthread_exit(NULL);  //线程退出 不影响主线程
}

int main(int argc, char const *argv[])
{
    //定义变量存储线程号
    pthread_t tid = 1;

    //创建线程
    if (pthread_create(&tid, NULL, task, NULL) != 0)
    {
        printf("pthread error");
        return -1;
    }

    printf("主线程 tid = %#lx 线程号 = %#lx\n", tid, pthread_self());

    //阻塞回收分支线程的资源
    if(pthread_join(tid,NULL) == 0)
    {
        printf("成功回收%#lx的资源\n",tid);
    }

    //阻塞函数  主线程结束进程结束，分支线程也终止
    getchar();

    return 0;
}

pthred_detath：线程分离态

#include <pthread.h>

int pthread_detach(pthread_t thread);
功能：将线程设置成分离态，设置了分离态的线程，退出后，由系统回收其资源
参数：要被分离的线程id号
返回值：成功返回0，失败返回错误码

#include <myhead.h>

void *task(void *arg)
{
    printf("子线程 线程号 = %#lx\n", pthread_self());
    
    sleep(3);
    //exit(EXIT_SUCCESS);  //再线程中进程退出  主线程也会结束
    pthread_exit(NULL);  //线程退出 不影响主线程
}

int main(int argc, char const *argv[])
{
    //定义变量存储线程号
    pthread_t tid = 1;

    //创建线程
    if (pthread_create(&tid, NULL, task, NULL) != 0)
    {
        printf("pthread error");
        return -1;
    }

    printf("主线程 tid = %#lx 线程号 = %#lx\n", tid, pthread_self());

    // //阻塞回收分支线程的资源
    // if(pthread_join(tid,NULL) == 0)
    // {
    //     printf("成功回收%#lx的资源\n",tid);
    // }

    //将线程设置成分离态
    pthread_detach(tid);
    printf("线程已退出\n");

    //阻塞函数  主线程结束进程结束，分支线程也终止
    getchar();

    return 0;
}

pthread_cancel：线程取消函数

#include <myhead.h>

void *task(void *arg)
{
    int n =0;
    while (1)
    {
        printf("子线程 线程号 = %#lx\n", pthread_self());
        n++;
        sleep(1);
        if (n == 10)
        {
            break;
        }
        
    }
    
    
    
    //exit(EXIT_SUCCESS);  //再线程中进程退出  主线程也会结束
    pthread_exit(NULL);  //线程退出 不影响主线程
}

int main(int argc, char const *argv[])
{
    //定义变量存储线程号
    pthread_t tid = 1;

    //创建线程
    if (pthread_create(&tid, NULL, task, NULL) != 0)
    {
        printf("pthread error");
        return -1;
    }

    printf("主线程 tid = %#lx 线程号 = %#lx\n", tid, pthread_self());

    // //阻塞回收分支线程的资源
    // if(pthread_join(tid,NULL) == 0)
    // {
    //     printf("成功回收%#lx的资源\n",tid);
    // }

    //将线程设置成分离态
    pthread_detach(tid);
   

    
    sleep(5);
    //向分支线程发送取消请求
    pthread_cancel(tid);
    printf("线程已退出\n");

    //阻塞函数  主线程结束进程结束，分支线程也终止
    getchar();

    return 0;
}

pthread_sercancelstate：设置取消属性

#include <pthread.h>

int pthread_setcancelstate(int state, int *oldstate);
功能：设置是否接收取消指令
参数1：新的状态
PTHREAD_CANCEL_ENABLE：可接受状态
PTHREAD_CANCEL_DISABLE：不可接收状态
参数2：线程的旧的状态容器，如果不愿意要之前的状态，填NULL即可
返回值：成功返回0，失败返回错误码

#include <myhead.h>

void *task(void *arg)
{
    //设置线程不可取消状态
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    
    int n =0;
    while (1)
    {
        printf("子线程 线程号 = %#lx\n", pthread_self());
        n++;
        sleep(1);
        if (n == 10)
        {
            break;
        }
        
    }
    
    
    
    //exit(EXIT_SUCCESS);  //再线程中进程退出  主线程也会结束
    pthread_exit(NULL);  //线程退出 不影响主线程
}

int main(int argc, char const *argv[])
{
    //定义变量存储线程号
    pthread_t tid = 1;

    //创建线程
    if (pthread_create(&tid, NULL, task, NULL) != 0)
    {
        printf("pthread error");
        return -1;
    }

    printf("主线程 tid = %#lx 线程号 = %#lx\n", tid, pthread_self());

    // //阻塞回收分支线程的资源
    // if(pthread_join(tid,NULL) == 0)
    // {
    //     printf("成功回收%#lx的资源\n",tid);
    // }

    //将线程设置成分离态
    pthread_detach(tid);
    printf("线程已退出\n");

    
    sleep(5);
    //向分支线程发送取消请求
    pthread_cancel(tid);

    //阻塞函数  主线程结束进程结束，分支线程也终止
    getchar();

    return 0;
}

多线程允许使用同一个线程体函数

#include <myhead.h>

void *task(void *arg)
{
    if (strcmp((char*)arg,"hello") == 0)
    {
        int num = 10;
        while (num--)
        {
            printf("线程1\n");
            sleep(1);
        }
        pthread_exit(NULL);
    }
    else if (strcmp((char*)arg,"world") == 0)
    {
        sleep(5);
        printf("     线程2\n");
       
    }
    pthread_exit(NULL);

}

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

    if (pthread_create(&tid1,NULL,task,"hello") != 0)
    {
        printf("tid1 error");
        return -1;
    }

    if (pthread_create(&tid2,NULL,task,"world") != 0)
    {
        printf("tid2 error");
        return -1;
    }

    //阻塞等待线程结束
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);


    return 0;
}

作业

1、使用两个线程完成两个文件的拷贝，分支线程1拷贝前一半，分支线程2拷贝后一半，1主线程回收两个分支线程的资源

#include <myhead.h>

// 定义结构体存储信息
struct Buf
{
    int len;
    int s;
    const char *o_file;
    const char *n_file;
};

// 拷贝函数
void copy_file(const char *srcfile, const char *destfile, int start, int len)
{
    // 以只读的形式打开源文件
    int sfd = open(srcfile, O_RDONLY);
    if (sfd == -1)
    {
        perror("open srcfile error");
        return;
    }

    // 以创建的形式打开目标文件
    int dfd = open(destfile, O_WRONLY);
    if (dfd == -1)
    {
        perror("open destfile error");
        return;
    }

    // 移动光标位置
    lseek(sfd, start, SEEK_SET);
    lseek(dfd, start, SEEK_SET);

    // 定义搬运工
    char buf[128] = "";
    int sum = 0; // 记录拷贝的总个数
    while (1)
    {
        // 从源文件中读取数据
        int res = read(sfd, buf, sizeof(buf));
        sum += res; // 将读取的个数累加

        if (res == 0 || sum > len) // 表示文件读取结束
        {
            write(dfd, buf, res - (sum - len)); // 父进程将最后一次拷贝结束
            break;
        }
        // 写入到目标文件中
        write(dfd, buf, res);
    }

    // 关闭文件
    close(sfd);
    close(dfd);

    printf("拷贝成功\n");
}

// 线程功能
void *task(void *arg)
{
    printf("线程开始\n");

    //读取数据
    int n = ((struct Buf *)arg)->len;
    int start = ((struct Buf *)arg)->s;
    printf("%d\n",start);
   
     //调用拷贝函数
    copy_file(((struct Buf *)arg)->o_file, ((struct Buf *)arg)->n_file, start, n);
    //线程退出
    pthread_exit(NULL);
}

int get_file_len(const char *o_file, const char *n_file)
{
    int ofd = open(o_file, O_RDONLY);
    if (ofd < 0)
    {
        perror("82ofd open error");
        exit(EXIT_SUCCESS);
    }

    umask(0000);

    int nfd = open(n_file, O_WRONLY | O_CREAT | O_TRUNC, 0664);
    if (nfd < 0)
    {
        perror("89nfd open error");
        exit(EXIT_SUCCESS);
    }

    int len = lseek(ofd, 0, SEEK_END);

    close(ofd);
    close(nfd);

    return len;  
}

int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("终端输入错误\n");
        return -1;
    }

    struct Buf buf1, buf2; // 定义信息传输结构体

    int res = get_file_len(argv[1], argv[2]);

    buf1.len = res / 2;
    buf1.o_file = argv[1];
    buf1.n_file = argv[2];
    buf1.s = 0;

    buf2.len = res - res / 2;
    buf2.o_file = argv[1];
    buf2.n_file = argv[2];
    buf2.s = res / 2;

    pthread_t tid1, tid2;

    if (pthread_create(&tid1, NULL, task, &buf1) != 0)
    {
        printf("tid1 error");
        return -1;
    }


    if (pthread_create(&tid2, NULL, task, &buf2) != 0)
    {
        printf("tid2 error");
        return -1;
    }

    // 将线程设置成分离态
    pthread_detach(tid1);
    pthread_detach(tid2);
    printf("线程已退出\n");

    // 阻塞等待线程结束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("回收结束\n");
    getchar();

    return 0;
}

原文地址：https://blog.csdn.net/weixin_64918301/article/details/140845535

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Conda一些常用命令
下一篇：魔术方法的优缺点和实现原理

leetcode289:生命游戏
根据，简称为，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。给定一个包含m × n个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1即为（live），或0即为
阅读更多2024-10-20
MongoDB数据恢复
注意：两个MongoDB的版本要一致，本文使用的是mongo:4.2.24。先把K8S上面的MongoDB 容器停止（可以把副本改成0）。1、将容器挂载MongoDB的数据目录备份到本地。经常是数据文
阅读更多2024-10-20
C#中实现事务
C#中实现事务
阅读更多2024-10-20
【LeetCode每日一题】——560.和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。
阅读更多2024-10-20
「漏洞复现」满客宝智慧食堂系统 selectUserByOrgId 未授权访问漏洞
请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任。工具来自网络，安全性自测，如有侵权请联系删除。本次
阅读更多2024-10-20
React面试题目（从基本到高级）
React前端面试常见题目涵盖了React的基础概念、组件、状态管理、生命周期、性能优化等多个方面。
阅读更多2024-10-20
12.个人博客系统（Java项目基于spring和vue）
1 在校学习的学生，可用于日常学习使用或是毕业设计使用 2 毕业一到两年的开发人员，用于锻炼自己的独立功能模块设计能力，增强代码编写能力。 3 亦可以部署为商化项目使用。 4 需要完整资料及源码
阅读更多2024-10-20
YoloV8改进策略：注意力改进|DeBiFormer，可变形双级路由注意力|引入DeBiLevelRoutingAttention注意力模块（全网首发）
本次改进的核心在于将DeBiLevelRoutingAttention模块嵌入到YoloV8的主干网络中，具体位置是在SPPF（Spatial Pyramid Pooling Fast）模块之后。这一
阅读更多2024-10-20
word取消自动单词首字母大写
情况说明：在word输入单词后首字母会自动变成大写取消单词首字母大写步骤：（1）点击菜单栏文件（2）点击“更多”——>“选项”（3）点击“校对”——>“自动更正选项”（4）取消“句首字母大
阅读更多2024-10-20
web前端网页用户注册页面
【代码】web前端网页用户注册页面。
阅读更多2024-10-20

学习记录——day24 多线程编程

多线程局部概念

线程支持函数（多线程编程）

pthread_create：创建线程

pthread -self：线程号获取

pthread_exit：线程退出函数

pthread_jion：线程资源回收

pthred_detath：线程分离态

pthread_cancel：线程取消函数

pthread_sercancelstate：设置取消属性

多线程允许使用同一个线程体函数

作业

相关文章