day07（IO进程）线程 Thread

已于 2024-08-30 00:23:02 修改
阅读量1.3k 收藏 11
点赞数 26
分类专栏： IO进程 文章标签： 嵌入式 嵌入式应用层开发 开发语言 IO进程 IO 线程 thread
于 2024-08-29 22:26:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QR70892/article/details/141688294
版权

一.什么是线程

1. 概念

线程是一个轻量级的进程，为了提高系统的性能引入线程。

线程和进程是参与统一的调度。

在同一个进程中可以创建的多个线程, 共享进程资源。

(Linux里同样用task_struct来描述一个线程）

2. 进程和线程区别

相同点：

都为系统提供了并发执行的能力

不同点：

调度和资源: 线程是系统调度的最小单位; 进程是资源分配的最小单位。

地址空间方面: 同一个进程创建的多个线程共享该进程的资源；进程的地址空间相互独立。

通信方面: 线程通信相对简单，只需要通过全局变量可以实现，但是需要考虑临界资源访问的问题；进程通信比较复杂，需要借助进程间的通信机制(借助3g-4g内核空间)

安全性方面: 线程安全性差一些，当进程结束时会导致所有线程退出；进程相对安全。

面试题：程序什么时候该使用线程？什么时候用进程？（深圳棱镜空间智能科技有限公司）（北京明朝万达）

对资源的管理和保护要求高，不限制开销和效率时，使用多进程。

要求效率高、速度快的高并发环境时，需要频繁创建、销毁或切换时，资源的保护管理要求不是很高时，使用多线程。

3. 线程资源

共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID

私有的资源：线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈(局部变量, 返回地址)、错误号 (errno)、信号掩码和优先级、执行状态和属性

二.函数接口

1. 创建线程: pthread_create

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                                void *(*start_routine) (void *), void *arg);
功能：创建线程
参数：      thread：线程标识
            attr：线程属性， NULL：代表设置默认属性
            start_routine：函数名：代表线程函数（自己写的）
            arg：用来给前面函数传参
返回值：成功：0
      失败：错误码
      
编译的时候需要加 -pthread 链接动态库

例子:

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

void *handler_thread(void *arg)
{
    printf("in handler_thread\n");
    while (1)
        ; //不让线程退出
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)  //创建线程
    {
        perror("phtread err");
        return -1;
    }
    printf("in main\n");
    while(1);  //让主线程不要结束
    return 0;
}

2. 退出线程: pthread_exit

void  pthread_exit(void *value_ptr) 
功能：用于退出线程的执行
参数：value_ptr：线程退出时返回的值
#include <stdio.h>
#include <pthread.h>

void *handler_thread(void *arg)
{
    printf("in handler_thread\n");
    pthread_exit(NULL);   //退出当前线程
    while (1)
        ; //不让线程退出
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0) //创建线程
    {
        perror("phtread err");
        return -1;
    }
    printf("in main\n");
    while (1)
        ; //让主线程不要结束
    return 0;
}

3. 回收线程资源  pthread _ join

int  pthread_join(pthread_t thread,  void **value_ptr) 
功能：用于等待一个指定的线程结束，阻塞函数
参数：thread：创建的线程对象,线程ID
     value_ptr：指针*value_ptr 用于指向线程返回的参数， 一般为NULL
返回值：成功 ： 0
       失败：errno

int pthread_detach(pthread_t thread);
功能：让线程结束时自动回收线程资源,让线程和主线程分离,非阻塞函数
参数：thread：线程ID
非阻塞式的，例如主线程分离(detach)了线程T2，那么主线程不会阻塞在pthread_detach()，pthread_detach()会直接返回，线程T2终止后会被操作系统自动回收资源



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

void *handler_thread(void *arg)
{
    printf("in handler_thread\n");
    sleep(2);
    pthread_exit(NULL); //退出当前线程
    while (1)
        ; //不让线程退出
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0) //创建线程
    {
        perror("phtread err");
        return -1;
    }

    // pthread_join(tid, NULL);   //阻塞等待指定的线程结束然后给其回收资源
    pthread_detach(tid);     //不阻塞，让指定线程结束时自动回收资源
    printf("in main\n");
    while (1)
        ; //让主线程不要结束
    return 0;
}
练习：输入输出，quit结束

通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。

  1. 全局变量进行通信
  2. 加上标志位(flag)，实现主线程输入一次，线程函数打印一次， int flag = 0;
#include <stdio.h>
#include <pthread.h>
#include <string.h>
char s[32];
int flag = 0; //为了进行线程间通讯，保证主线程先输入然后从线程再输出

void *handler_thread(void *arg)
{
    while (1)
    {
        if (flag == 1) //主线程输入完将flag置1从线程再输出
        {
            if (strcmp(s, "quit") == 0)
                break;
            printf("%s\n", s);
            flag--;
        }
    }
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
    {
        perror("err");
        return -1;
    }

    while (1)
    {
        //scanf前也可以不加if判断，利用阻塞时间让从线程输出
        // if (flag == 0)  //从线程输出完将flag置0主线程再输入
        // {
            scanf("%s", s);
            flag++;

            if (strcmp(s, "quit") == 0)
                break;
        // }
    }
}

三.同步

1. 概念

同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情

(异步：异步则反之，并非一定需要一件事做完再做另一件事。）

2. 同步机制

通过信号量实现线程间同步。

信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待。

信号量代表某一类资源，其值表示系统中该资源的数量:

信号量的值>0, 表示有资源可以用, 可以申请到资源。

信号量的值<=0, 表示没有资源可以用, 无法申请到资源, 阻塞。

信号量还是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)

sem_init: 信号量初始化

sem_wait: 申请资源，P操作，如果没有资源可以用会阻塞等待，直到有资源可用结束阻塞资源-1。

sem_post: 释放资源，V操作，非阻塞，资源+1。

3. 函数接口

int  sem_init(sem_t *sem,  int pshared,  unsigned int value)  
功能：初始化信号量   
参数：sem：初始化的信号量对象
    pshared：信号量共享的范围(0: 线程间使用   非0:1进程间使用)
    value：信号量初值
返回值：成功 0
       失败 -1

int  sem_wait(sem_t *sem)  
功能：申请资源  P操作 
参数：sem：信号量对象
返回值：成功 0
       失败 -1
注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞

int  sem_post(sem_t *sem)   
功能：释放资源  V操作      
参数：sem：信号量对象
返回值：成功 0
      失败 -1
注：释放一次信号量的值加1，函数不阻塞

练习：用信号量实现输入输出quit结束
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>

char s[32];
sem_t sem1; //信号量对象
sem_t sem2;

void *handler_thread(void *arg)
{
    while (1)
    {

        //申请资源 sem1
        sem_wait(&sem1);
        if (strcmp(s, "quit") == 0)
            break;
        printf("%s\n", s);
        //释放资源sem2
        sem_post(&sem2);
    }
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    //初始化信号量
    if (sem_init(&sem1, 0, 0) != 0)
    {
        perror("sem_init err");
        return -1;
    }

    if (sem_init(&sem2, 0, 1) != 0)
    {
        perror("sem_init err");
        return -1;
    }

    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
    {
        perror("err");
        return -1;
    }

    while (1)
    {
        //申请资源sem2
        sem_wait(&sem2);
        scanf("%s", s);
        //释放资源sem1
        sem_post(&sem1);
        if (strcmp(s, "quit") == 0)
            break;
    }
}

四.互斥

1. 概念

互斥：多个线程在访问临界资源时，同一时间只能一个线程访问

临界资源：一次仅允许一个线程所使用的资源

临界区：指的是一个访问共享资源的程序片段

互斥锁（mutex）：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。

pthread_mutex_init

pthread_mutex_lock

pthread_mutex_unlock

2. 函数接口

int  pthread_mutex_init(pthread_mutex_t  *mutex, pthread_mutexattr_t *attr)  
功能：初始化互斥锁  
参数：mutex：互斥锁
    attr:  互斥锁属性  //  NULL表示缺省属性
返回值：成功 0
      失败 -1
      
int  pthread_mutex_lock(pthread_mutex_t *mutex)   
功能：申请互斥锁     
参数：mutex：互斥锁
返回值：成功 0
      失败 -1
注：和pthread_mutex_trylock区别：pthread_mutex_lock是阻塞的；pthread_mutex_trylock不阻塞，如果申请不到锁会立刻返回

int  pthread_mutex_unlock(pthread_mutex_t *mutex)   
功能：释放互斥锁     
参数：mutex：互斥锁
返回值：成功 0
      失败 -1
      
int  pthread_mutex_destroy(pthread_mutex_t  *mutex)  
功能：销毁互斥锁     
参数：mutex：互斥锁

例如：打印倒置数组功能
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;

void *handler_swap(void *arg)
{
    while (1)
    {
        pthread_mutex_lock(&lock);  //上锁
        for (int i = 0; i < 5; i++)
        {
            int t = a[i];
            a[i] = a[9 - i];
            a[9 - i] = t;
        }
        pthread_mutex_unlock(&lock); //解锁
    }
    return NULL;
}

void *handler_print(void *arg)
{
    while (1)
    {
        pthread_mutex_lock(&lock); //上锁
        for (int i = 0; i < 10; i++)
            printf("%d ", a[i]);
        printf("\n");
        pthread_mutex_unlock(&lock); //解锁
        sleep(1); //锁里面减少耗时大的操作
    }
    return NULL;
}

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

    //初始化互斥锁
    if (pthread_mutex_init(&lock, NULL) != 0)
    {
        perror("lock err");
        return -1;
    }

    if (pthread_create(&tid1, NULL, handler_swap, NULL) != 0)
    {
        perror("err");
        return -1;
    }

    if (pthread_create(&tid2, NULL, handler_print, NULL) != 0)
    {
        perror("err");
        return -1;
    }

    pthread_join(tid1, NULL); //为了让整个进程不要结束
    pthread_join(tid2, NULL);

    return 0;
}

补充：死锁

是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

死锁产生的四个必要条件

1. 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2. 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3. 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4. 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

五.条件变量

条件变量(cond)用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。

一般和互斥锁搭配使用，实现同步机制:

pthread_cond_init(&cond,NULL); //初始化条件变量

使用前需要上锁:

pthread_mutex_lock(&lock); //上锁

判断条件

pthread_cond_wait(&cond, &lock); //阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当条件产生时结束阻塞，再次上锁

//执行任务

pthread_mutex_unlock(&lock); //解锁

pthread_cond_signal(&cond); //产生条件，不阻塞

pthread_cond_destroy(&cond); //销毁条件变量

注意： 必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件

例如：打印和转置数组实现同步
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;
pthread_cond_t cond;
void *handler_swap(void *arg)
{
    while (1)
    {
        pthread_mutex_lock(&lock); //上锁

        pthread_cond_wait(&cond, &lock);//如果没条件产生解锁并阻塞，等条件产生后结束阻塞并上锁

        for (int i = 0; i < 5; i++)
        {
            int t = a[i];
            a[i] = a[9 - i];
            a[9 - i] = t;
        }
        pthread_mutex_unlock(&lock); //解锁
    }
    return NULL;
}

void *handler_print(void *arg)
{
    while (1)
    {
        sleep(2);
        pthread_mutex_lock(&lock); //上锁
        for (int i = 0; i < 10; i++)
            printf("%d ", a[i]);
        printf("\n");

        pthread_cond_signal(&cond); //产生条件

        pthread_mutex_unlock(&lock); //解锁
        sleep(1);                    //锁里面减少耗时大的操作
    }
    return NULL;
}

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

    //初始化互斥锁
    if (pthread_mutex_init(&lock, NULL) != 0)
    {
        perror("lock err");
        return -1;
    }

    //初始化条件变量
    if (pthread_cond_init(&cond, NULL) != 0)
    {
        perror("cond err");
        return -1;
    }

    if (pthread_create(&tid1, NULL, handler_swap, NULL) != 0)
    {
        perror("err");
        return -1;
    }

    if (pthread_create(&tid2, NULL, handler_print, NULL) != 0)
    {
        perror("err");
        return -1;
    }

    pthread_join(tid1, NULL); //为了让整个进程不要结束
    pthread_join(tid2, NULL);
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);

    return 0;
}

嵌新程
关注
专栏目录
python多进程与多线程
Z__legend的博客
08-07 654
多任务：同一时间执行多个任务，有并发和并行两种表现形式 并发：在一段时间内交替执行多个任务 并行：在一段时间内真正的同时执行多个任务 多进程 进程（Process）是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位；通俗理解：一个正在运行的程序就是一个进程。 多进程的作用，如下图： 多进程的创建 这里使用的是跨平台的多进程模块multiprocessing 导入进程包 import multiprocessing import time def sing(num, name):
IO进程-进程/线程/进程间通信
zhong_hua210231的博客
02-20 711
初学者的笔记（IO进程）
day06（IO进程）进程 process
QR70892的博客
08-28 1159
（IO进程）进程 process
IO进程day04（进程）
dghbs的博客
08-28 1525
程序：编译好的可执行文件存放在磁盘上的指令和数据的有序集合（文件）程序是静态的，没有任何执行的概念进程：一个独立的可调度的任务执行一个程序分配资源的总称进程是程序执行的一次过程进程是动态的，包括创建、调度、执行、消亡（1）守护进程是一个生存周期较长的进程，通常独立于控制终端并且周期性的执行某种任务或者等待处理某些待发生的事件（2）大多数服务都是通过守护进程实现的（3）关闭终端，相应的进程都会被关闭，而守护进程却能够突破这种限制今天的分享就到这里结束啦，如果有哪里写的不好的地方，请指正。
IO进程Day03_进程
weixin_49064660的博客
07-07 473
IO进程Day03_进程
【C++11】多线程+IO流
学了就忘是正常现象
04-30 2011
C++11多线程+C++IO流
Linux系统编程【文件IO、进程、进程间通信、信号、线程、互斥】
weixin_45045804的博客
09-29 1732
个人通过学习，手打了一份48000字的Linux系统编程的笔记，包含了【文件IO、进程、进程间通信、信号、多线程、互斥】等知识点，并给出了大量的代码案例对每个重要的知识点进行了代码演示，通过理论和实操的结合，更好的透析每个知识点，为后续的unix网络编程打下基础。
Day42并发编程进程 线程 协程 综合
Tao.的博客
08-11 487
进程 线程 协程
day08（IO进程）进程间的通信---管道
QR70892的博客
08-30 1276
（IO进程）进程间的通信---管道
使用JAVA.IO流线程的JAVA课设项目万年历记事本
03-08
在Java编程语言中，IO（Input/Output）流和线程是两个重要的概念，它们在构建复杂的系统中扮演着至关重要的角色。在这个“万年历记事本”课设项目中，开发者结合了这两个概念来创建一个功能丰富的应用程序。下面我们...
Linux学习 IO进程与线程： day4
haogewudi666的博客
06-11 458
【复习】 库：可执行代码的二进制形式 静态库：编译时 动态库(共享库)：运行时 便于复用 进程： 和程序的区别： 三段：数据段、正文段、堆栈段 分类：交互进程、批处理、守护进程 状态：运行态R、等待态、暂停态T、死亡态x、僵尸态Z 命令：ps -aux/-ef、top、kill、bg\fg 函数：fork、wait/waitpid、exit/_exit、execvpe 守护进程：1.fork 2.setsid 3.chdir...
多线程 IO流
zqb960924的博客
11-27 262
多线程 IO流
Day01_Python_线程与进程
Hiraphael的博客
08-24 285
python中数据类型 数字： int float 复数 bool 列表 字典 元组 集合 numpy 数据类型：ndarray， 可以定义任何维度 pandas 一维：series 二维：dataframe 三维：multindex 或者叫做 panel 为什么数据分析中不用python内置的数据类型，而使用 numpy 或者 pandas numpy和pandas的数据结构是要 优于 python内置的结构 numpy中默认采用多进程的方式处理数据 numpy底层是采用c来处
Python day14--进程与线程
qq_36983538的博客
02-10 928
Python 进程与线程
第六届蓝桥杯嵌入式省赛程序设计题解析（基于HAL库）
weixin_51089092的博客
09-28 937
数据发送是一个字节一个字节的发送，当第一个数据k发送出去时，开始启动计时，给定一个接收数据的时间，在此时间内，接收到的所有数据都会放入环形缓冲区。，还需要一段时间去处理环形缓冲区内接收到的数据，判断是否符合题目要求的格式，不符合就不处理,符合就回应ok，并使用。0标志亮，1标志灭，控制时间设置界面的待设置值的闪烁功能，设置延时时间，时间到达状态翻滚，以此达到闪烁功能。函数的入口参数分别是（内容读出之后放入的数组，要读出内容的地址，读出的个数）函数的入口参数分别是（要写的内容的数组，写入的地址，写入的个数）
项目管理-信息技术发展
最新发布
GAVIN
10-04 215
对称加密：DES 3DES AES RC5 IEDA SM1 SM4。2）分类：PAN LAN MAN WAN 公用网 专用网。4）数据结构模型 层次模型 网状模型 关系模型。1)存储 分类：DAS FAS NAS SAN。物联网（IoT） 感知层 网络层 应用层。8） 5G 高速率 低时延 大连接。设备安全 数据安全 内容安全 行为安全。4.信息安全 保密性 完整性 可用性。3）网络协议 语法 语义 时许。5）IEEE 802 规范。6）TCP/IP 协议。4）网络标准协议 7层。
【STM32单片机_(HAL库)】4-3-4【定时器TIM】测量按键按下时间实现3
labvvv的博客
10-01 628
测量按键按下时间
【STM32单片机_(HAL库)】4-3【定时器TIM】定时器输入捕获实验配置步骤
labvvv的博客
10-01 232
定时器输入捕获实验配置步骤
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值