Linux系统编程—线程

最新推荐文章于 2024-06-03 16:35:19 发布
最新推荐文章于 2024-06-03 16:35:19 发布
阅读量97 收藏
点赞数 1
分类专栏： LINUX系统编程 文章标签： linux 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44475311/article/details/115126907
版权

在将线程之前就不得不再讲一下进程

进程与线程之间的关系

进程是资源分配的最小单位，线程是程序执行的最小单位，进程可以看做是一个控制线程，一个进程在同一时间只能做同一件事，而有多个控制线程，就能在同一时间做不同的事。一个线程属于一个进程，而一个进程可以有多个线程。进程是程序化的实例，是担当分配系统资源的基本单位，是分配系统资源的基本单位，一条线程指的是进程中一个单一顺序的控制流。线程包含了进程内执行环境必须的信息。

使用线程的原因

1，和进程相比线程所需要的资源更少，每开辟一个进程就需要分配给他独立的地址空间，建立众多的数据表来维护它的代码段，堆栈段和数据段
2，对于进程来说他们有独立的数据空间，要进行数据传递必须通过通信的方式，而线程由于在同一进程下共享数据空间，所以一个线程可以为其他线程直接所用
3，多线程是一种多任务，并发的工作方式

Linux上线程开发API

Linux常用线程库 pthread,多线程开发的基本思想：线程，互斥锁，条件

线程

线程创建 ，退出，等待

函数原型：

#include <pthread.h>
int pthread_creat(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
//成功返回0，失败返回-1
void pthread_exit(void* retval);
//用pthread_exit()来调用线程的返回值，用来退出线程，但是退出线程所占用的资源不会随着线程的终止而得到释放 
int pthread_join(pthread_t thread, void **retval);
//参数 ：thread: 线程标识符，即线程ID，标识唯一线程。retval: 用户定义的指针，用来存储被等待线程的返回值。
//成功返回0，失败返回-1

示例代码

{
#include <stdio.h>
#include <pthread.h>
void *func1(void *arg)
{
    static char *p = "t1 is run out";
    printf("%ld thread is creat\n",(unsigned long)pthread_self());
    printf("param is %d\n",*((int *)arg));
    pthread_exit((void *)p);
}

int main(）
{
    int ret;
    pthread_t t1;
    int param = 100;
    char *pret = NULL;
    ret = pthread_create(&t1, NULL,func1, (void *)&param);
    if(ret == 0){
    printf("creat t1 success\n");
    }
    printf("main:%ld\n",(unsigned long)pthread_self());
    pthread_join(t1,(void **)&pret);
    printf("main: t1 quit:%s\n",pret);
    return 0;
}

互斥量

定义：
互斥量从本质上来说像一把锁，在访问共享资源前对互斥量进行加锁，在访问完之后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞到当前线程，直到当前线程释放该互斥锁，在设计时需要规定所以所有线程必须遵守相同的数据访问规则。

互斥量作用：
大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况变量归属单个线程，其他线程无法获得变量。但有的时候，线程间需要共享很多变量，通过数据的共享，完成线程间的交互。如果多个线程并发地共享变量，会出现数据不一致的问题，而互斥量可以使共享资源被唯一访问，能很好地解决这个问题。

1，创建及销毁互斥锁

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t mutex);
//返回：若成功返回0，否则返回错误编号

示例代码：

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

void *func1(void *arg)

{
    static char *p = "t1 is run out";
    printf("%ld thread is creat\n",(unsigned long)pthread_self());
    printf("param is %d\n",*((int *)arg));
    pthread_exit((void *)p);
}


int main()
{
    int ret;
    pthread_t t1;
    int param = 100;
    char *pret = NULL;
    ret = pthread_create(&t1, NULL,func1, (void *)&param);
    if(ret == 0){
    printf("creat t1 success\n");
    }
    printf("main:%ld\n",(unsigned long)pthread_self());
    pthread_join(t1,(void **)&pret);
    printf("main: t1 quit:%s\n",pret);
    return 0;
}

2，加锁及解锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex mutex);
int pthread_mutex_trylock(pthread_mutex_t mutex);
int pthread_mutex_unlock(pthread_mutex_t mutex);
//返回：若成功返回0，失败返回错误编码

示例代码：

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

int g_data = 0;

pthread_mutex_t mutex;

void *func1(void *arg)
{

    int i;
    pthread_mutex_lock(&mutex);
    for(i=0;i<5;i++){
       printf("t1:%ld thread is creat\n",(unsigned long)pthread_self());
       printf("t1:param is %d\n",*((int *)arg));
       sleep(1);
    }
    pthread_mutex_unlock(&mutex);
}

void *func2(void *arg)
{
    printf("t2:%ld thread is creat\n",(unsigned long)pthread_self());
    printf("t2:parm is %d\n",*((int *)arg));
}


int main()
{
    int ret;
    pthread_t t1;
    pthread_t t2;


    pthread_mutex_init(&mutex, NULL);

    int param = 100;
    char *pret = NULL;

    ret = pthread_create(&t1, NULL,func1, (void *)&param);
    if(ret == 0){
    printf("creat t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0){
    printf("creat t2 success\n");
    }
    printf("main:%ld\n",(unsigned long)pthread_self());

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);

    pthread_mutex_destroy(&mutex);

    return 0;
}

3，互斥锁对共享内存的影响

示例代码

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

int g_data = 0;

pthread_mutex_t mutex;

void *func1(void *arg)
{
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("ti:parm is %d\n",*((int *)arg));
    pthread_mutex_lock(&mutex);
    while(1){
       printf("t1: %d\n",g_data++);
       sleep(1);
    }
    if(g_data == 3){
       pthread_mutex_unlock(&mutex);//只有满足条件才能解锁
       pthread_exit(NULL);
    }
}

void *func2(void *arg)
{
    printf("t2:%ld thread is creat\n",(unsigned long)pthread_self());
    printf("t2:parm is %d\n",*((int *)arg));
    while(1){
            printf("t2: %d\n",g_data);
            pthread_mutex_lock(&mutex);
            g_data++;
            pthread_mutex_unlock(&mutex);
            sleep(1);
    }
}


int main()
{
    int ret;
    pthread_t t1;
    pthread_t t2;

    pthread_mutex_init(&mutex, NULL);
int param = 100;
    char *pret = NULL;

    ret = pthread_create(&t1, NULL,func1, (void *)&param);
    if(ret == 0){
    printf("creat t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0){
    printf("creat t2 success\n");
    }
    printf("main:%ld\n",(unsigned long)pthread_self());
    while(1){
          printf("main: %d\n",g_data++);
          sleep(1);
    }
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

在这里插入图片描述

测试结果：
可以使用下面的解决方案：互斥量保存在共享内存中，在初始化该锁的时候，设置为进程间共享，这样两个进程连接到共享内存后，都可以获得这个互斥锁，因为已经设置了进程间共享，所以对锁的访问的冲突问题，系统已经解决了。

4，死锁的情况

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

int g_data = 0;

pthread_mutex_t mutex;
pthread_mutex_t mutex2;

void *func1(void *arg)
{

    int i;
    pthread_mutex_lock(&mutex);
    pthread_mutex_lock(&mutex2);
    for(i=0;i<5;i++){
       printf("t1:%ld thread is creat\n",(unsigned long)pthread_self());
       printf("t1:param is %d\n",*((int *)arg));

       sleep(1);
    }
    pthread_mutex_unlock(&mutex);
}

void *func2(void *arg)
{

    pthread_mutex_lock(&mutex2);
    pthread_mutex_lock(&mutex);
    printf("t2:%ld thread is creat\n",(unsigned long)pthread_self());
    printf("t2:parm is %d\n",*((int *)arg));
    pthread_mutex_unlock(&mutex2);
}


int main()
{
    int ret;
    pthread_t t1;
    pthread_t t2;

   pthread_mutex_init(&mutex, NULL);

    int param = 100;
    char *pret = NULL;

    ret = pthread_create(&t1, NULL,func1, (void *)&param);
    if(ret == 0){
    printf("creat t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0){
    printf("creat t2 success\n");
    }
    printf("main:%ld\n",(unsigned long)pthread_self());

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);

    pthread_mutex_destroy(&mutex);
    pthread_mutex_destroy(&mutex2);
    return 0;
}

运行结果：
在这里插入图片描述

线程条件控制实现线程同步

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

int g_data = 0;

pthread_mutex_t mutex;
pthread_cond_t cond; 
 
void *func1(void *arg)
{
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("ti:parm is %d\n",*((int *)arg));
    static int cnt = 0;
    while(1){   
            pthread_cond_wait(&cond,&mutex); 
            printf("t1  run\n");
            printf("t1: %d\n",g_data);
            g_data = 0;
            sleep(1);
            if(cnt++ == 10){
            exit(1);
            }
    }
}

void *func2(void *arg)
{
    printf("t2:%ld thread is creat\n",(unsigned long)pthread_self());
    printf("t2:parm is %d\n",*((int *)arg));
  
    while(1){
            printf("t2: %d\n",g_data);
            pthread_mutex_lock(&mutex);
            g_data++;
            pthread_mutex_unlock(&mutex);
            if(g_data == 3){
              pthread_cond_signal(&cond);
            }
            sleep(1);
    }
}


int main()
{
    int ret;
    pthread_t t1;
    pthread_t t2;    
    
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond,NULL);
    int param = 100;

    ret = pthread_create(&t1, NULL,func1, (void *)&param);
    if(ret == 0){
    printf("creat t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2,(void *)&param);
    if(ret == 0){
    printf("creat t2 success\n");
    }
    printf("main:%ld\n",(unsigned long)pthread_self());
    while(1){
          printf("main: %d\n",g_data++);
          sleep(1);
    }
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

运行结果：
在这里插入图片描述

本文存在不足会后续补充，仅作为学习记录

xyf haha~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux中的多线程
BuZiShuoquoto的博客
07-18 171
线程概念 什么是线程（面试必考） （1）进程 进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。 （2）线程 线程是CPU调度和分派的基本单位，它可与同属一个进程的其他的线程共享进程所拥有的全部资源。 （3）联系 线程是进程的一部分，一个线程只能属于一...
Linux系统编程-线程
weixin_47609911的博客
06-19 357
进程与线程 典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。 有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。 进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。 在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。 程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是
Linux系统编程之线程
weixin_44708428的博客
01-26 117
1.线程概念 LWP：light weight process, 本质上仍是进程（在Linux环境下） 进程：独立地址空间，拥有PCB 线程：也有PCB，但没有独立的地址空间（共享） 区别：在于是否共享地址空间。 Linux下，线程是最小的执行单位；进程是最小的分配资源单位，可看成是只有一个线程的进程。 2.Linux内核线程实现原理 （1）轻量级进程，也有PCB，创建线程使用的底层函数和进程一样，都是clone； （2）从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页
Linux系统编程——线程
qq_37233070的博客
02-07 1225
一、线程概念 基础 线程又称LWP：light weight process 轻量级的进程，（在linux环境下）本质仍是进程。 进程：独立地址空间，拥有PCB 线程：有独立的PCB，但没有独立的地址空间（共享） 区别： 在于是否共享地址空间。 独居（进程）；合租（线程） Linux下： 线程：最小的执行单位 进程：最小分配资源单位，可看成是只有一个线程的进程 GDB和信号诞生时间比线程早，故配合使用会很麻烦。 线程越多的程序理论上越可能争夺到cpu资源，但不是一味的扩展线程数，会有
Linux多线程编程
C_Trip的博客
11-19 2906
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
linux系统编程
蓝创精英团队
03-30 859
系统调用：系统调用是操作系统提供给用户程序的一组“特殊”接口，用户程序可以通过这组特殊的接口来获得操作系统内核提供的特殊服务。在linux中用户程序不能直接访问内核提供的服务，为了更好的保护内核，将程序的运行空间分为内核空间和用户空间，他们运行在不同的级别上。1.FILE 2.TCP/IP socket TCP UDP 3.进程 进程：一个处于活动状态的程序 进程的运行状态：执行、...
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 3042
线程创建、线程退出、线程等待、线程同步、线程池、进程与线程
Linux系统编程概述
Darren_Chen_的博客
02-06 1520
操作系统的任务是什么？系统编程是什么？
Linux系统下的多线程编程入门.pdf
12-20
Linux系统下的多线程编程入门
Linux系统编程之线程同步
05-08
所以，互斥锁实质上是操作系统提供的一把“建议锁”（又称“协同锁”），建议程序中有多线程访问共享资源的时候使用该机制。但，并没有强制限定。 因此，即使有了mutex，如果有线程不按规则来访问数据，依然会造成...
Linux系统编程学习笔记
02-21
Linux系统编程涵盖了众多领域，从基础的文件操作到高级的网络通信和多线程编程，为开发者提供了广泛的功能和灵活性。在这个领域工作的开发者需要深入了解Linux内核和系统底层的工作原理。 Linux 系统编程是指在 ...
Linux CFS调度器简介
小立仔
05-30 789
Linux CFS调度器简介
CentOS 7基础操作05_Linux查看及切换目录
IT_zhangsan
05-31 1005
pwd命令用于显示用户当前所在的工作目录位置,工作目录是用户操作文件或其他子目录的默认位置起点。使用pwd命令可以不添加任何选项或参数。
linux 之dma_buf (4)- mmap
z20230508的博客
05-28 931
前面几篇都是在 kernel space 对 dma-buf 进行访问的，本篇我们将一起来学习，如何在 user space 访问 dma-buf。当然，user space 访问 dma-buf 也属于 CPU Access 的一种。
RHCE （Linux进阶） Ubuntu 操作系统安装教程
2302_76161836的博客
06-02 307
学会安装ubuntu操作系统
【linux】无root权限下载7z解压软件并安装到指定路径
最新发布
weixin_44502754的博客
06-03 282
【linux】无root权限下载7z解压软件并安装到指定路径
【Linux】进程（2）：进程状态
qq_75000174的博客
05-31 722
如果没有父进程读取，该进程虽然已经运行完毕但task_struct会一直存在，即僵尸进程，task_struct占的空间非常大，这就导致内存泄漏。因为直接在命令行中启动的进程，它的父进程是bash，bash会自动读取新进程的退出信息，然后由操作系统释放。编译.c文件，运行进程，通过每秒显示的进程信息中我们发现，进程处于S+状态，而非R状态（运行状态），这是为什么？
linux 线程编程
10-20
Linux线程编程可以通过调用pthread库中提供的函数来实现。使用pthread库可以方便地创建和管理多个线程。在Linux中，每个线程都有自己的ID、寄存器和堆栈空间，线程之间可以共享进程中的资源，如文件描述符、内存等。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值