首页 > 系统相关 >IO进程_day5

IO进程_day5

时间：2024-10-24 23:46:29浏览次数：9  
标签：return int day5 线程 IO pthread 进程 mutex NULL

目录

线程 Thread

1.什么是线程

1.1 概念

1.2 进程和线程区别

1.3 线程资源

2.函数接口

2.1 创建线程: pthread_create

2.2 退出线程: pthread_exit

2.3 回收线程资源

练习: 通过父子进程完成对文件的拷贝(cp)

练习：输入输出，quit结束

3.同步

3.1 概念

3.2 同步机制

3.3 函数接口

练习：用信号量实现输入输出quit结束

4.互斥

4.1 概念

4.2 函数接口

例如：打印倒置数组功能

补充：死锁

死锁产生的四个必要条件

5. 条件变量

例如：打印和转置数组实现同步

线程 Thread

1.什么是线程

1.1 概念

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

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

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

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

1.2 进程和线程区别

相同点：

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

不同点：

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

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

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

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

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

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

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

1.3 线程资源

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

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

2.函数接口

2.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 <stdlib.h>
int test(int (*p)(int, int), int a, int b) //p=fun, a=3, b=4
{
    return p(a,b); //fun(3,4);
}
int fun(int n, int m)  //n=3, m=4
{
    return n * m;  //3*4=12
}

int main(int argc, char const *argv[])
{
      printf("%d\n", test(fun, 3, 4));  //12
      return 0;
}

例子:

#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.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;
}

2.3 回收线程资源

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;
}

练习: 通过父子进程完成对文件的拷贝(cp)
  1. 通过父子进程完成对文件的拷贝(cp)，父进程从文件开始到文件的一半开始拷贝，子进程从文件的一半到文件末尾。要求：文件IO cp src dest
  1. 文件长度获取: lseek
  2. 子进程定位到文件一半: lseek
  3. 父进程怎么准确读到文件一半的位置?
  4. fork之前打开文件，父子进程读写时，位置指针是同一个

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char const *argv[])
{
    int fd1, fd2;
    pid_t pid;
    char buf[32] = "";
    ssize_t n;
    if (argc != 3)
    {
        printf("err: %s <srcfile> <destfile>\n", argv[0]);
        return -1;
    }

    fd1 = open(argv[1], O_RDONLY);
    if (fd1 < 0)
    {
        perror("fd1 err");
        return -1;
    }
    fd2 = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0777);
    if (fd2 < 0)
    {
        perror("fd2 err");
        return -1;
    }

    //获取源文件长度的一半
    off_t len = lseek(fd1, 0, 2) / 2;

    //创建子进程
    pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) //拷贝后半段
    {
        //定位到一半的位置
        lseek(fd1, len, 0);
        lseek(fd2, len, 0);

        //读源文件，写入目标文件
        while ((n = read(fd1, buf, 32)) > 0)
        {
            write(fd2, buf, n);
            sleep(1);
        }
    }
    else //拷贝前半段
    {
        wait(NULL); //等子进程读写完父进程再拷贝
        //定位到文件开头
        lseek(fd1, 0, 0);
        lseek(fd2, 0, 0);

        //读源文件，写入目标文件
        while (len > 0)
        {
            if (len > 32)
                n = read(fd1, buf, 32);
            else
                n = read(fd1, buf, len);
            write(fd2, buf, n);
            len -= n;   //len保存的是剩余要读的字符个数
            sleep(1);
        }
    }
    close(fd1);
    close(fd2);

    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;
        // }
    }
}

3.同步

3.1 概念

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

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

3.2 同步机制

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

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

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

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

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

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

sem_init: 信号量初始化

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

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

3.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;
    }
}

4.互斥

4.1 概念

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

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

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

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

pthread_mutex_init

pthread_mutex_lock

pthread_mutex_unlock

4.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的资源。这样就形成了一个等待环路。

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

5. 条件变量

    条件变量(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;
}

标签：return,int,day5,线程,IO,pthread,进程,mutex,NULL
From： https://blog.csdn.net/weixin_63791423/article/details/143181908

相关文章

  • WPF No imaging component suitable to complete this operation was found.
    System.NotSupportedExceptionHResult=0x80131515Message=Noimagingcomponentsuitabletocompletethisoperationwasfound.Source=PresentationCoreStackTrace:Thisisbecausetheimagefileisnotcompletedorcorrupted,thealternativeistoa......
  • 在 Windows Server 2008 R2 中，您可以使用批处理（.bat）文件来查询 Win32_NetworkAdapterC
    在WindowsServer2008R2中，Win32_NetworkAdapterConfiguration类是Windows管理工具（WMI）基础结构的一部分。它提供了有关服务器上网络适配器配置的详细信息。您可以使用此类查询各种网络设置，例如IP地址、子网掩码、DNS服务器和DHCP设置。Win32_NetworkAdapterConfigurat......
  • io流
    输入流：用于读取数据，输入源从数据库读取数据，如文件，网络连接等。常见的输入流类有fileInputStream,byterArrayInputStream.socketInputStream.输出流：用于读写数据,输出流将数据写入到目标，如文件，数据库等常见的有fileOutStream,ByteArrayOutSteaqm,SocketOutStream.IO场景：读写文件......
  • 使用 Windows Management Instrumentation (WMI) 更新用户的 DNS 设置可以通过几种方
    使用WindowsManagementInstrumentation(WMI)更新用户的DNS设置可以通过几种方法实现，主要是使用Win32_NetworkAdapterConfiguration类来修改网络适配器的DNS设置。以下是一个使用PowerShell脚本的示例，展示如何通过WMI更新DNS设置。使用PowerShell更新DNS设置......
  • [Coci2011]kamion 题解
    前言题目链接：Hydro&bzoj；黑暗爆炸。题意简述给你一张\(n\)个点\(m\)条边的有向图。有\(p\)种括号，每条边的边权可以是这\(p\)种括号中某一种的左括号或者右括号，也可以为空。问你有多少条从\(1\)开始到\(n\)的长度小于等于\(k\)的路径，满足括号匹配，或者剩余若干未......
  • 论文翻译 | Bounding the Capabilities of Large Language Models in Open Text Gener
    摘要        开放式生成模型的局限性尚不清楚，但却越来越重要。是什么让他们成功，又是什么让他们失败？在本文中，我们采用了一种以提示为中心的方法来分析和限定开放式生成模型的能力。我们提出了两种具有挑战性的提示约束类型的通用分析方法：结构和风格。这些约束类型被归......
  • SciTech-Mathmatics-Probability+Statistics-Bayes Formula: Application:
    SciTech-Mathmatics-Probability+StatisticsBayesFormula:Application:DescriptiveStatistics(ofSamples)\[\large\begin{array}{lll}\\\text{SamplesData}\begin{cases}\\\bm{Center\Tendency}\overset{\bm{Mean}}{\right......
  • mac scrcpy 报错 does not exist or is not a regular file，ERROR: Server connection
    scrcpymac与极空间冲突问题：➜~scrcpyscrcpy2.7<https://github.com/Genymobile/scrcpy>INFO:ADBdevicefound:INFO:-->(usb)8AJY0LU0QdevicePixel_3_XLstat:NosuchfileordirectoryERROR:'/Applications/极空间.ap......
  • Visual Studio 2022工作原理及相关配置参数（干货满满）——C++
    最近工作有点忙，毕业也没多久，确实在企业和学校还是有很大的差距的，这段时间学到了很多很多，也没时间顾及博客了，刚好趁着这个1024稍微放慢脚步，总结总结。最近用VisualStudio比较频繁，也学到了很多相关的内容，借此博文简单记录一下，全是个人理解，若有地方理解有误还请各位大佬评论......
  • Visual Studio 离线部署
    前言最近在在做一个移植项目，把代码从Unix移植到Windows上面，考虑两个编译链：（1）MINGW64-CRT（交叉编译）（2）VisualStudio。而VisualStudio社区版需保持在线使用，不然试用将存在过期时间。由于办公环境在内网内，所以考虑使用VisualStudio的生成工具配合CMake管理......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99