Linux系统编程之线程

最新推荐文章于 2023-11-19 21:39:25 发布
最新推荐文章于 2023-11-19 21:39:25 发布
阅读量137 收藏
点赞数
分类专栏： Linux系统编程 文章标签： linux c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woweiwang007/article/details/129210194
版权

一、概述

  1. 典型的Unix和Linux进程可以看成一个控制的线程，这个进程在同一时刻只做一件事情；

  1. 当Unix和Linux进程有了多个控制线程之后，进程在同一时刻就不只做一件事情，每个线程都有各自处理的任务；

  1. 进程在程序运行的过程，是系统分配资源的基本单位，在线程设计的系统中，进程本身并不是基本运行的单位，而是线程的容器；

  1. 线程是操作系统能够进行运算调度的最小单位；

  1. 一个进程中可以并发多个线程，每条线程并行执行不同的任务。

二、创建子线程

  1. API原型

SYNOPSIS
    #include <pthread.h>
    
    int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                       void *(*start_routine) (void *), void *arg);

  1. API的参数

  • pthread_t *thread：子线程入口地址，创建一个pthread_t类型的子线程；

  • const pthread_attr_t *attr：线程的属性，一般使用NULL，具体可以在man手册查看；

  • void *(*start_routine) (void *)：子线程入口函数，注意函数的类型；

  • void *arg：子函数的入口参数；

  • 返回值：成功返回0，错误返回-1，并设置errno。

  1. API的demo_1(创建子线程，并获取线程ID)

#include <stdio.h>
#include <pthread.h>

void *fun1(void *arg){
    printf("task : thread is create\n");
    printf("task : %ld \n",(unsigned long)pthread_self());
    printf("task : param is %d \n",*((int *)arg));
}

int main()
{
    pthread_t task;
    int ret;
    int param = 100;

    ret = pthread_create(&task, NULL, fun1, (void *)&param);

    //返回值为0时创建成功
    if(ret == 0){
        printf("main : create success\n");
    }
    printf("main : %ld\n",(unsigned long)pthread_self());
    pthread_join(task, NULL);//等待子线程执行完成退出

    return 0;
}

  1. demo_1的运行

  1. API的demo_2（创建子线程，执行完子线程，并返回一个整数）

#include <stdio.h>
#include <pthread.h>

void *fun1(void *arg){
    static int ret = 10;        //退出码要使用静态变量
    printf("task : thread is create\n");
    printf("task : %ld \n",(unsigned long)pthread_self());
    printf("task : param is %d \n",*((int *)arg));
    pthread_exit((void *)&ret);
}

int main()
{
    pthread_t task;
    int ret;
    int param = 100;
    int *pret = NULL;
    ret = pthread_create(&task, NULL, fun1, (void *)&param);

    //返回值为0时创建成功
    if(ret == 0){
        printf("main : create success\n");
    }
    printf("main : %ld\n",(unsigned long)pthread_self());
    pthread_join(task, (void **)&pret);//等待子线程执行完成退出
               //子线程退出的状态码
    printf("main : t1 quit : %d\n",*pret);

    return 0;
}

  1. demo_2的运行

  1. API的demo_3（创建子线程，执行完子线程，并返回字符串）

#include <stdio.h>
#include <pthread.h>

void *fun1(void *arg){
    static char *p = "task is run out";        //退出码要使用静态变量
    printf("task : thread is create\n");
    printf("task : %ld \n",(unsigned long)pthread_self());
    printf("task : param is %d \n",*((int *)arg));
    pthread_exit((void *)p);
}

int main()
{
    pthread_t task;
    int ret;
    int param = 100;
    char *pret = NULL;
    ret = pthread_create(&task, NULL, fun1, (void *)&param);

    //返回值为0时创建成功
    if(ret == 0){
        printf("main : create success\n");
    }
    printf("main : %ld\n",(unsigned long)pthread_self());
    pthread_join(task, (void **)&pret);//等待子线程执行完成退出
               //子线程退出的状态码
    printf("main : t1 quit : %s\n",pret);

    return 0;
}

  1. demo_3的运行

三、多个线程共享内存

  1. demo

#include <stdio.h>
#include <pthread.h>

void *fun1(void *arg){
    printf("task_1 : thread is create\n");
    printf("task_1 : %ld \n",(unsigned long)pthread_self());
}

void *fun2(void *arg){
    printf("task_2 : thread is create\n");
    printf("task_2 : %ld \n",(unsigned long)pthread_self());
}

int main()
{
    pthread_t task_1;
    pthread_t task_2;
    int ret;
    int param = 100;

    ret = pthread_create(&task_1, NULL, fun1, (void *)&param);
    if(ret == 0){
        printf("main : task_1 create success\n");
    }
    
    ret = pthread_create(&task_2, NULL, fun2, (void *)&param);
    if(ret == 0){
        printf("main : task_2 create success\n");
    }

    printf("main : %ld\n",(unsigned long)pthread_self());
  
    while(1);//防止主线程退出

    return 0;
}

  1. demo的运行

  1. 从运行结果来看，并不存在先执行线程1，再执行线程2，这里两个线程为同等优先级，两个线程会相互争夺CPU的使用权；

四、互斥量限制共享资源

  1. API原型

SYNOPSIS
    #include <pthread.h>
    
    //创建锁   
    int pthread_mutex_init(pthread_mutex_t *mutex,
                           const pthread_mutexattr_t  *mutex‐attr);
    //销毁锁
    int pthread_mutex_destroy(pthread_mutex_t *mutex);
    //上锁
    int pthread_mutex_lock(pthread_mutex_t *mutex);
    //解锁
    int pthread_mutex_unlock(pthread_mutex_t *mutex);

  1. API参数

  • pthread_mutex_t *mutex：创建的锁（互斥量），类型为pthread_mutex_t；

  • const pthread_mutexattr_t *mutex‐attr：锁的属性，当为NULL时，默认为互斥锁；

  • 返回值：都是成功返回0，错误返回-1，设置错误码。

  1. API的demo

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t mutex;

void *fun1(void *arg){
    pthread_mutex_lock(&mutex);//上锁
    for(int i=0;i<3;i++){
        printf("task_1 : thread is create\n");
        printf("task_1 : %ld \n",(unsigned long)pthread_self());
    }
    pthread_mutex_unlock(&mutex);//解锁
}

void *fun2(void *arg){
    usleep(1);
    printf("task_2 : thread is create\n");
    printf("task_2 : %ld \n",(unsigned long)pthread_self());
}

int main()
{
    pthread_t task_1;
    pthread_t task_2;
    int ret;
    int param = 100;
   
    pthread_mutex_init(&mutex, NULL);    //创建锁

    ret = pthread_create(&task_1, NULL, fun1, (void *)&param);
    if(ret == 0){
        printf("main : task_1 create success\n");
    }
    
    ret = pthread_create(&task_2, NULL, fun2, (void *)&param);
    if(ret == 0){
        printf("main : task_2 create success\n");
    }
    printf("main : %ld\n",(unsigned long)pthread_self());
    
    pthread_join(task_1,NULL);
    pthread_join(task_2,NULL);
    pthread_mutex_destroy(&mutex);        //销毁锁
    return 0;
}

  1. demo的运行

  1. 在task_1上锁之后，会先执行完线程1里面的内容，不被打断

五、死锁

  1. 死锁是相对一个概念，就是两个线程互锁住了，僵持不下；

  1. 我们要避免出现死锁，所以在使用锁的时候要格外注意是否出现死锁；

  1. 死锁的demo

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t mutex_1;
pthread_mutex_t mutex_2;

void *fun1(void *arg){
    pthread_mutex_lock(&mutex_1);//上锁
    sleep(1);
    pthread_mutex_lock(&mutex_2);

    for(int i=0;i<3;i++){
        printf("task_1 : thread is create\n");
        printf("task_1 : %ld \n",(unsigned long)pthread_self());
    }
    pthread_mutex_unlock(&mutex_1); //解锁
}

void *fun2(void *arg){
    pthread_mutex_lock(&mutex_2);//上锁
    sleep(1);
    pthread_mutex_lock(&mutex_1);
    for(int i=0;i<3;i++){
        printf("task_2 : thread is create\n");
        printf("task_2 : %ld \n",(unsigned long)pthread_self());
    }
    pthread_mutex_unlock(&mutex_2);//解锁
}

int main()
{
    pthread_t task_1;
    pthread_t task_2;
    int ret;
    int param = 100;

    pthread_mutex_init(&mutex_1, NULL);    //创建锁1
    pthread_mutex_init(&mutex_2, NULL);    //创建锁2

    ret = pthread_create(&task_1, NULL, fun1, (void *)&param);
    if(ret == 0){
        printf("main : task_1 create success\n");
    }
    
    ret = pthread_create(&task_2, NULL, fun2, (void *)&param);
    if(ret == 0){
        printf("main : task_2 create success\n");
    }
    printf("main : %ld\n",(unsigned long)pthread_self());
    
    pthread_join(task_1,NULL);              //等待线程1
    pthread_join(task_2,NULL);              //等待线程2
    pthread_mutex_destroy(&mutex_1);        //销毁锁1
    pthread_mutex_destroy(&mutex_2);        //销毁锁2
    return 0;
}

  1. demo的运行

  1. 如上图所示，两个线程被相互锁住，进程卡住运行不了。

二灰酱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux系统编程之线程同步
05-08
Linux中提供一把互斥锁mutex（也称之为互斥量）。 每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。 资源还是共享的，线程间也还是竞争的， 但通过“锁”就将资源的访问变成互斥操作...
Linux系统编程——线程
m0_67407774的博客
11-21 320
第一个参数为互斥变量，用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量）pthread_cond_signal和pthread_cond_broadcast：参数为条件变量。pthread_mutex_lock和pthread_mutex_unlock：参数都为互斥变量。pthread_mutex_destroy：参数为互斥变量。第二个参数为保护条件所对应的互斥锁的互斥变量的地址。
Linux多线程编程（6.4）
安静的美男子
06-08 485
线程：轻量级的进程，是调度的最小单位， 线程是共享同一进程地址空间多个可独立被调度运行的任务 一 多线程  与 多进程的区别  1.在一个进程中创建的多个线程，共享同一个进程的资源，各线程独立被内核调度  2.多个进程是独立地址空间 相同点: 1.都参与统一的调度  2.都有自己的ID,一组寄存器的值   不同点:线程间共享统一个进程的地址空间 ，进
linux系统编程之线程
z1zyy的博客
03-29 613
linux系统编程之线程、锁等
【Linux篇】第十四篇——多线程（一）（线程概念+线程控制）
m0_58367586的博客
10-05 6309
Linux下的线程线程的概念需要明确的是，一个进程的创建实际上伴随着其进程控制块(task_struct),进程地址空间(mm_struct)以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的。每个进程都有自己独立的进程地址空间和独立的页表，也就意味着所有进程在运行时本身就具有独立性。但如果我们在创建"进程"时，只创建task_struct,并要求创建出来的task_struct和父task_struct共享进程地址空间和页表，那么创建出来的结果就是下面这样"
Linux线程编程
最新发布
weixin_42136255的博客
11-19 179
Linux线程编程
linux系统编程之线程.zip
05-05
线程ID：pthread_t类型，本质：在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现 线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同) 注意：不应使用全局变量 pthread_t tid，在子线程中通过...
Linux系统下的多线程编程入门.pdf
12-20
Linux系统下的多线程编程入门
Linux系统编程-线程
11-04
Linux系统编程-线程
Linux多线程编程
C_Trip的博客
11-19 2848
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
Linux多线程编程手册
12-25
Linux多线程编程手册，介绍了Linux下pthread的使用方法
Linux下的多线程编程.pdf
09-24
Linux下的多线程编程.pdf 很好的一本书，值得看一看
linux环境下的多线程编程（一）
qq_56673429的博客
05-01 2416
一，线程概述 线程是轻量级的进程（LWP：light weight process），在 Linux 环境下线程的本质仍是进程。在计算机上运行的程序是一组指令及指令参数的组合，指令按照既定的逻辑控制计算机运行。操作系统会以进程为单位，分配系统资源，可以这样理解，进程是资源分配的最小单位，线程是操作系统调度执行的最小单位。 二，线程函数 每一个线程都有一个唯一的线程 ID，ID 类型为 pthread_t，这个 ID 是一个无符号长整形数，如果想要得到当前线程的线程 ID，可以调用如下函数： pt
Linux C 线程编程
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-24 2994
线程创建、线程退出、线程等待、线程同步、线程池、进程与线程
Linux多线程编程实例解析
热门推荐
知秋一叶
12-14 2万+
Linux系统下的多线程遵循POSIX线程接口，称为 pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux 下pthread的实现是通过系统调用clone（）来实现的。clone（）是 Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下
Linux下的多线程编程一（系统编程）
snow_5288的博客
06-11 8148
一，线程的基本概念 1，线程的定义： 线程也被称为轻量进程（LWP）计算机科学术语，指运行中的程序的调度单位。线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；它与父进程的其它线程共享该进程所拥有的全部资源。线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。 在多中央处理器的系统里，不
Linux多线程编程常用系统接口
05-28
Linux提供了许多常用的系统接口来进行多线程编程。下面列出一些常用的接口： 1. pthread_create：创建线程的接口； 2. pthread_join：等待线程的结束，以便回收线程资源； 3. pthread_mutex_init、pthread_mutex_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

二灰酱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值