嵌入式--软件--应用程序--C语言--进程--学习笔记（高级篇--线程篇）

已于 2022-09-18 14:42:06 修改
阅读量512 收藏
点赞数
文章标签： servlet c++ 数据结构 嵌入式实时数据库
于 2022-09-17 20:28:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56228140/article/details/126888219
版权

0-- 系列文章目录

1.进程篇：  （进程篇链接）（本文章）（多线程通信篇）

2.网络篇：  （文章链接）

3.数组篇：  （文章链接）

4.指针篇：  （文章链接）

5.内核篇：  （文章链接）

6.硬件篇：  （文章链接）（视频链接）

...........

 1--当前文章目录

  • 前言
  • 一、理论部分
  • 二、实际操作
    • 1.创建线程(pthread_create)
    • 2.线程间参数的传递（重难点
    • 3.线程回收（pthread_join，多线程会有点小问题）
    • 4.线程的分离（pthread_detach）
    • 5.线程的取消（pthread_cancel,pthread_testcancel，pthread_setcancelstate）
    • 6.线程的清理（pthread_cleanup_push）
    • 7.互斥锁（pthread_rwlock_unlock，pthread_rwlock_wrlock，，pthread_mutex_lock）
    • 8.死锁（两把以上会）
  • 总结

一.理论部分

线程

• 进程在切换时系统开销大
• 很多操作系统引入了轻量级进程LWP
• 同一进程中的线程共享相同地址空间
• Linux不区分进程、线程

特点

• 通常线程指的是共享相同地址（空间的多个任务）
• 使用多线程的好处（ 大大提高了任务切换的效率， 避免了额外的TLB & cache的刷新）

线程（共享）资源

        •可执行的指令，静态数据，进程中打开的文件描述符，

        •当前工作目录，用户ID，用户组ID

线程（私有）资源

• 线程ID (TID)，      PC(程序计数器)和相关寄存器
• 堆栈，错误号 (errno)，  优先级         执行状态和属性

 Linux线程库

•pthread线程库中提供了如下基本操作
        Ø 创建线程
        Ø 回收线程
        Ø 结束线程
•  同步和互斥机制
        Ø 信号量
        Ø 互斥锁

二.实际操作

1.创建线程

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

int *testThread(char *arg){
    printf("zhe shi zi xian cheng,pid=%d,tid=%lu\n",getpid(),pthread_self());
    return 0;
}

int main(){

    pthread_t tid;
    int ret;

    ret = pthread_create(&tid,NULL,(void *)testThread,NULL);
    printf("zhe shi zhu xian cheng\n");
    sleep(1);
}

 获取线程ID：两种方法

        1.。。pthread_create（）其中的第一个参数

        2.。。在线程里面调用 pthread_self 函数

2.线程间参数的传递（重难点）

两种方式：选择使用（有报警，但是程序是可以的）

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

int *testThread(void *arg){
    printf("zhe shi zi xian cheng,pid=%d,tid=%lu\n",getpid(),pthread_self());
    printf("shu ru wei: %d\n", *(int *)arg);    // chuan can shu 

    pthread_exit(NULL);
    printf("after pthread exit\n");
   
}

int main(){

    pthread_t tid;
    int ret;
    int arg=5;
    int i;

        ret = pthread_create(&tid,NULL,testThread,(void*)&arg);
        printf("zhe shi zhu xian cheng,tid=%lu\n",tid);
        sleep(1);
}


/*
void *testThread(void *arg){
    printf("This is a thread test,pid=%d,tid=%lu\n",getpid(),pthread_self());
   // return NULL;
    printf("input arg=%d\n",(int)arg);
    pthread_exit(NULL);
    printf("after pthread exit\n");
}

int main(){
    pthread_t tid;
    int ret;
    int arg = 5;
   
    ret = pthread_create(&tid,NULL,testThread,(void *)arg);

    printf("This is main thread,tid=%lu\n",tid);    
    sleep(1);
}

*/

 进阶版：多线程

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

void *testThread(void *arg){
    printf("This is a thread test,pid=%d,tid=%lu\n",getpid(),pthread_self());
   // return NULL;
    printf("This is %d thread.\n", (int)arg);
   // pthread_exit(NULL);
    while(1){
        sleep(1);
    }
    printf("after pthread exit\n");
}

int main(){
    pthread_t tid[5];
    int ret;
    int arg = 5;
    int i;
    for(i=0;i<5;i++){   
        ret = pthread_create(&tid[i],NULL,testThread,(void *)i);
     
//        sleep(1);   
        printf("This is main thread,tid=%lu\n",tid[i]);    
    }
    while(1){
        sleep(1);
    }
}

3.线程的回收（pthread_join，多线程会有点小问题）

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
void *func(void *arg){
    printf("This is child thread\n");
    sleep(25);
    pthread_exit("thread return");

}


int main(){
    pthread_t tid[100];
    void *retv;
    int i;
    for(i=0;i<100;i++){
        pthread_create(&tid[i],NULL,func,NULL);
    }
    for(i=0;i<100;i++){
       // pthread_join(tid[i],&retv);
       // printf("thread ret=%s\n",(char*)retv);
    }
    while(1){    
        sleep(1);
    } 

}

4.线程的分离（pthread_detach）

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
void *func(void *arg){
    printf("This is child thread\n");
    sleep(25);
    pthread_exit("thread return");

}


int main(){
    pthread_t tid[100];
    void *retv;
    int i;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

    for(i=0;i<100;i++){
        pthread_create(&tid[i],&attr,func,NULL);
       // pthread_detach(tid);
    }
    
    while(1){    
        sleep(1);
    } 

}

 用top查看，运行100个实时的内存变化

 (5)线程的取消与互斥（pthread_cancel,pthread_testcancel，pthread_setcancelstate）

取消的条件：需要取消点（sleep），，或者手动添加取消点（pthread_testcancel）

取消点的选择：（pthread_setcancelstate）哪里，不能取消，哪里可以取消

创建完成后，执行线程需要时间，

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


void *func(void *arg){
    printf("This is child thread\n");
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);    
//    while(1)
    {
        sleep(5);
        pthread_testcancel();
    }
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
    while(1){
        sleep(1);
    }


    pthread_exit("thread return");
}


int main(){
    pthread_t tid;
    void *retv;
    int i;
    pthread_create(&tid,NULL,func,NULL);
    sleep(1);
    pthread_cancel(tid);
    pthread_join(tid,&retv);
//    printf("thread ret=%s\n",(char*)retv);
    while(1){    
        sleep(1);
    } 

}

（6）线程的清理（pthread_cleanup_push）

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

void cleanup(void *arg){
    printf("cleanup,arg=%s\n",(char*)arg);

}
void cleanup2(void* arg){

    printf("cleanup2,arg=%s\n",(char*)arg);
}

void *func(void *arg){
    printf("This is child thread\n");
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    pthread_cleanup_push(cleanup,"abcd");
    pthread_cleanup_push(cleanup2,"efgh");
    //while(1)
    {
        sleep(1);
        
    }
//    pthread_cancel(pthread_self());
    //printf("Should not print\n");
    return "1234";

    while(1){
        printf("sleep\n");
        sleep(1);
    }
    pthread_exit("thread return");
    pthread_cleanup_pop(1);
    pthread_cleanup_pop(1);
    sleep(10);
    pthread_exit("thread return");
}


int main(){
    pthread_t tid;
    void *retv;
    int i;
    pthread_create(&tid,NULL,func,NULL);
    sleep(1);
//    pthread_cancel(tid);
    pthread_join(tid,&retv);
    printf("thread ret=%s\n",(char*)retv);
    while(1){    
        sleep(1);
    } 

}

（7）互斥锁（两个线程，写同一个文件的时候，排队，先后）

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


FILE *fp;
void *func2(void *arg){
    pthread_detach(pthread_self());
    printf("This func2 thread\n");
    
    char str[]="I write func2 line\n";
    char c;
    int i=0;
    while(1){
        pthread_mutex_lock(&mutex);
        while(i<strlen(str))
        {
            c = str[i];
            fputc(c,fp);
            usleep(1);
            i++;
        }
        pthread_mutex_unlock(&mutex);
        i=0;
        usleep(1);

    }

    pthread_exit("func2 exit");

}

void *func(void *arg){
    pthread_detach(pthread_self());
    printf("This is func1 thread\n");
    char str[]="You read func1 thread\n";
    char c;
    int i=0;
    while(1){
        pthread_mutex_lock(&mutex);
        while(i<strlen(str))
        {
            c = str[i];
            fputc(c,fp);
            i++;
            usleep(1);
        }
        pthread_mutex_unlock(&mutex);
        i=0;
        usleep(1);

    }
    pthread_exit("func1 exit");
}


int main(){
    pthread_t tid,tid2;
    void *retv;
    int i;
    fp = fopen("1.txt","a+");
    if(fp==NULL){
        perror("fopen");
        return 0;
    }


    pthread_create(&tid,NULL,func,NULL);
    pthread_create(&tid2,NULL,func2,NULL);
    while(1){    
        sleep(1);
    } 

}

读取的锁，可以多个读取，写的时候阻塞

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


pthread_rwlock_t rwlock;

FILE *fp;
void * read_func(void *arg){
    pthread_detach(pthread_self());
    printf("read thread\n");
    char buf[32]={0};
    while(1){
        //rewind(fp);
        pthread_rwlock_rdlock(&rwlock);
        while(fgets(buf,32,fp)!=NULL){
            printf("%d,rd=%s\n",(int)arg,buf);
            usleep(1000);
        }
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }

}



void *func2(void *arg){
    pthread_detach(pthread_self());
    printf("This func2 thread\n");
    
    char str[]="I write func2 line\n";
    char c;
    int i=0;
    while(1){
        pthread_rwlock_wrlock(&rwlock);
        while(i<strlen(str))
        {
            c = str[i];
            fputc(c,fp);
            usleep(1);
            i++;
        }
        pthread_rwlock_unlock(&rwlock);
        i=0;
        usleep(1);

    }

    pthread_exit("func2 exit");

}

void *func(void *arg){
    pthread_detach(pthread_self());
    printf("This is func1 thread\n");
    char str[]="You read func1 thread\n";
    char c;
    int i=0;
    while(1){
        pthread_rwlock_wrlock(&rwlock);
        while(i<strlen(str))
        {
            c = str[i];
            fputc(c,fp);
            i++;
            usleep(1);
        }
        pthread_rwlock_unlock(&rwlock);
        i=0;
        usleep(1);

    }
    pthread_exit("func1 exit");
}


int main(){
    pthread_t tid1,tid2,tid3,tid4;
    void *retv;
    int i;
    fp = fopen("1.txt","a+");
    if(fp==NULL){
        perror("fopen");
        return 0;
    }
    pthread_rwlock_init(&rwlock,NULL);
    pthread_create(&tid1,NULL,read_func,1);
    pthread_create(&tid2,NULL,read_func,2);
    pthread_create(&tid3,NULL,func,NULL);
    pthread_create(&tid4,NULL,func2,NULL);
    while(1){    
        sleep(1);
    } 

}

（8）死锁

概念：

避免方法：

  1. 锁越少越好，最好使用一把锁
  2. 调整好锁的顺序
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

FILE *fp;
void *func2(void *arg){
    pthread_detach(pthread_self());
    printf("This func2 thread\n");
    
    char str[]="I write func2 line\n";
    char c;
    int i=0;
    while(1){
        pthread_mutex_lock(&mutex);
        printf("%d,I got lock2\n",(int)arg);
        sleep(1);
        pthread_mutex_lock(&mutex2);
        printf("%d,I got 2 locks\n",(int)arg);

        pthread_mutex_unlock(&mutex2);
        pthread_mutex_unlock(&mutex1);
        sleep(10);

    }

    pthread_exit("func2 exit");

}

void *func(void *arg){
    pthread_detach(pthread_self());
    printf("This is func1 thread\n");
    char str[]="You read func1 thread\n";
    char c;
    int i=0;
    while(1){
        pthread_mutex_lock(&mutex);
        printf("%d,I got lock1\n",(int)arg);
        sleep(1);
        pthread_mutex_lock(&mutex2);
        printf("%d,I got 2 locks\n",(int)arg);

        pthread_mutex_unlock(&mutex2);
        pthread_mutex_unlock(&mutex);
        sleep(10);

    }
    pthread_exit("func1 exit");
}


int main(){
    pthread_t tid,tid2;
    void *retv;
    int i;
    fp = fopen("1.txt","a+");
    if(fp==NULL){
        perror("fopen");
        return 0;
    }


    pthread_create(&tid,NULL,func,1);
    pthread_create(&tid2,NULL,func2,2);

    while(1){    
        sleep(1);
    } 

}

卡尔-TONY
关注
《ARM Cortex-R 学习指南》-【第十章】-内存排序
baron-周贺贺-代码改变世界ctw
09-03 1232
早期的ARM架构实现（如ARM7TDMI）按照程序顺序执行所有指令。在开始下一条指令之前，每条指令都会被完全执行。较新的处理器采用了许多优化技术，这些技术涉及指令执行顺序和内存访问方式的调整。如我们所见，内核执行指令的速度显著高于外部内存的速度。为了部分隐藏这种速度差异带来的延迟，使用了缓存和写缓冲区。这种做法的一个潜在影响是内存地址可能会被重新排序。这意味着内核执行加载和存储指令的顺序不一定与外部设备所看到的访问顺序相同。在上图中，我们按照程序顺序列出了三条指令。
C语言笔记(三)-进程线程/printf/存储区/static/可重入与不可重入函数
weixin_44186910的博客
06-01 482
1.进程与线程 二者是对CPU工作时间段的描述。进程的时间段是：CPU加载程序上下文的时间+CPU执行时间+CPU保存程序上下文的时间。
c语言线程 学习笔记
wqy00803的博客
06-15 215
一、线程和进程得区别 进程是资源分配的最小单位，线程是CPU调度的最小单位 线程在进程下行进（单纯的车厢无法运行） 一个进程可以包含多个线程（一辆火车可以有多个车厢） 不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘） 同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易） 进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源） 进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢.
进程与线程笔记
hd51cc的博客
04-16 237
进程Process是程序的一次执行。 每个进程都有自己的地址空间、内存、数据栈以及记录运行轨迹的辅助数据，操作系统管理运行的所有进程，并为这些进程公平分配时间。 线程Thread运行在同一个进程中，共享运行环境。 线程有开始、顺序执行和结束3部分。线程之间可以比进程之间更方便地共享数据和相互通信。 线程一般是并发执行的。 多进程模式最大的优点是稳定性高，因为一个子进程崩溃不会影响主进程和其他子进程。多进程模式的缺点是创建进程的代价大。 多线程模式通常比多进程快一点，但是也快不了多少。多线程模
嵌入式开发基础之线程间通信
06-16 871
在裸机编程中，经常会使用全局变量进行功能间的通信，如某些功能可能由于一些操作而改变全局变量的值，另一个功能对此全局变量进行读取，根据读取到的全局变量值执行相应的动作，达到通信协作的目的。而实时操作系统往往采用邮箱、消息队列、信号用于线程间的通信。邮箱服务是实时操作系统中一种典型的线程间通信方法。 邮箱用于线程间通信，特点是开销比较低，效率较高。典型的邮箱也称作交换消息。 非阻塞方式的邮件发送过程能够安全的应用于中断服务中，是线程、中断服务、定时器向线程发送消息的有效手段。通常来说，邮件收取过程可能是阻塞的，
课堂笔记九之嵌入式C多线程开发
qq_46413242的博客
04-28 520
一、信号 1、信号是一种向进程发送通知，告诉其某件事情发生了的一种简单通信机制 2、信号的产生 （1）另一个进程发送信号 （2）内核发送信号底层硬件发送信号 （3）底层硬件发送信号 3、信号列表 （1）常用信号 4、信号发送 #include <sys/types.h> #include <signal.h> int kill(pid_t pid, int sig); ...
icat-paper-ma开发笔记
06-08
C语言是一种强大的、低级的编程语言，常用于系统编程、嵌入式系统以及各种软件开发。它的效率高，可移植性好，是许多现代编程语言的基础。 icat_paper-ma项目可能是一个用C语言实现的项目，涉及数据处理、算法实现...
618节日CM-2023C-m开发笔记
06-05
在接下来的内容中，我们将深入探讨C语言在软件开发中的应用，以及可能涉及的关键技术和最佳实践。 C语言是一种强大的、低级别的编程语言，因其高效和灵活性而被广泛用于系统级编程和嵌入式系统。在"CM-2023C-m"项目...
c 课设-mai开发笔记
最新发布
06-21
C语言是一种强大的、基础的编程语言，被广泛应用于系统编程、嵌入式开发以及各种软件工程。在这个课设中，我们可能会涉及到以下几个核心主题： 1. **基本语法**：C语言的语法简洁而严谨，包括变量声明、数据类型...
ARM-IMX6U:IMX6U学习笔记
04-09
1. **软件环境**：通常搭配Linux或Android操作系统，开发者可利用丰富的开源工具链进行应用程序开发，如GCC编译器、GDB调试器等。 2. **开发板与工具**：市面上有多种基于IMX6U的开发板，如ARM-IMX6U-master，提供...
Linux多线程
xurongxin2006的博客
10-21 360
由于进程的地址空间是私有的，因此在进程间上下文切换时，系统开销比较大；为了提高系统的性能，许多操作系统规范里引入了轻量级进程的概念，也被称为线程。4、同样情况下： 多线程的资源消耗要小于多进程， 特别是在一些手持设备中，这个表现的比较明显 CPU 和内存之间的缓存。线程在栈里面是不同的，线程的空间叫栈帧，每个线程的栈帧是私有的。在同一个进程中创建的线程共享该进程的地址空间，线程和进程统一调度；当线程切换的时候，由于同一进程中的所有线程都是共享同一。在同一个进程中创建的线程共享该进程的地址空间。
【C语言】详解线程 — 开启两个线程
Fanjufei的博客
06-29 1945
开启两个线程，如下： 第一个子线程执行到 i = 65 时，开始执行第二个线程；开启两个线程，添加参数信息： 在这里我们用到了 pthread_create 函数的第四个参数，把值传递到 myFunc 形参中去。......
TLB与cache的深入分析
jeiwt的专栏
09-28 7934
<br />转帖于<br />http://blog.csdn.net/hangbing0203/archive/2010/05/17/5600759.aspx<br /><br />一)TLB <br />1)TLB的概述<br />TLB是一个内存管理单元用于改进虚拟地址到物理地址转换速度的缓存.<br />TLB是位于内存中的页表的cache，如果没有TLB，则每次取数据都需要两次访问内存,即查页表获得物理地址和取数据.<br />2)tlb的原理<br />当cpu对数据进行读请求时,CPU根据虚拟
进程与线程及通信总结
u011651799的专栏
08-10 704
进程与线程及通信总结 一： 进程，程序与线程的区别： 程序：是静态的，存储在磁盘上，是指令与数据的有序集合。 进程：是动态的，一个程序执行一次就是一个进程，包括创建，执行，调度与消亡。 用fork()函数创建进程时，实现的是对程序的拷贝。不同的进程之间有各自的空间。 线程：是轻量级的进程，与进程的不同点是，不同纯程之间，共用进程相同的地址空间。 程
TLB刷新的深入理解
Netfilter
02-09 8099
为何linux内核的leave_mm中最后有一个load_cr3，这样的话岂不是又加载了cr3，这样岂不是违背了懒惰模式懒惰刷新tlb的初衷吗？这是邮件列表中很多人问的一个问题，要回答这一个问题，还要从2.6.18内核谈起。在2.6.18以及以前的内核中，leave_mm中是没有laod_cr3的，可是后来就有了，到底为什么？这一个要从cpu硬件的预取谈起。 每个cpu为了效率，几乎都会提前好几
IO&Process基础知识
weixin_34204057的博客
12-02 351
一．文件IO和标准IO特点 库函数：方便程序员开发，可能会存在一些问题（C库除外）。 系统调用：有内核提供的函数接口，更加的稳定高效。 文件IO：无缓冲/低级磁盘IO 无缓冲：增加磁盘的访问次数，不利于保护磁盘。 优点：可以保证数据的实时写入。 IO的操作方式：看程序的应用场合。 标准IO：带缓冲的/高级磁盘IO 缓冲IO就是可以减少对磁盘的访问次数，提高系统效率，有利于保护磁盘...
嵌入式C编程之错误处理（附代码例子）！
11-27 747
作者：clover-toeic原文：https://www.cnblogs.com/clover-toeic/p/3919857.html前言本文主要总结嵌入式系统C语言编程中，主要的错...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值