进程线程学习总结

最新推荐文章于 2024-10-19 16:02:10 发布
最新推荐文章于 2024-10-19 16:02:10 发布
阅读量104 收藏
点赞数
文章标签： 学习 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38296162/article/details/129216104
版权
这篇文章详细介绍了Linux环境下的进程管理，包括进程的概念、创建、退出、等待和守护进程的实现。同时，讨论了进程间通信的各种方法，如无名管道、有名管道、信号、共享内存和消息队列。此外，还涉及到了线程的创建、回收、同步（信号量）和互斥（互斥锁）的概念及其应用示例。
摘要由CSDN通过智能技术生成

一、进程

1、进程的基本概念

进程：程序的一次动态执行过程，包括创建、调度、消亡

进程是程序执行和资源管理的最小单位，

进程种类：交互进程、批处理进程、守护进程

进程状态：运行态、等待态（可中断/不可中断）、僵尸态（已终止的进程，但还在进程向量表中占一个task_struct）、停止态

2、进程的操作

创建：pid_t fork（void）

父进程中fork的返回值是子进程的pid；子进程中fork的返回值为0

退出：exit( int status) 和 _exit(int status ),子函数中调exit只是该进程结束，调return只是这个函数结束，进程并没有结束。

等待：

1、阻塞函数直到进程退出，wait返回，子进程被回收

pid_t wait（int *status）

2、可以指定等待某个子进程结束以及等待的方式（阻塞或非阻塞），

子进程退出返回子进程pid，使用选项WNOHANG且没有子进程结束时0

pid_t waitpid（pid_t pid，int *status,int options）

替换代码段：int execl（const char* path,const char*arg,）程序路径、命令行参数

3、守护进程

（1）创建子进程，父进程退出

（2）子进程中创建新会话pid_t setsid（）

（3）改变当前目录为根目录chdir("/")

（4）重设文件权限掩码umask（0）

（5）关闭文件描述符int getdtablesize();获取最大文件描述符

4、进程间通信

无名管道、有名管道、信号、共享内存、消息队列、信号灯、套接字

（1）无名管道：

半双工，只能用于父子进程、兄弟进程间通信

int pipe(int fd[2])

arr[0]读管道、arr[1]写管道

（2）有名管道：

管道文件test.fifo,为了两个互不相关的进程能够操作同一个管道

int mkfifo(const char*filename,mode_t mode) 管道文件的路径 管道文件的读写权限0666

（3）信号

信号注册函数 ：void (* signal（int signum , void(*handler)(int)) ) (int)

SIG_IGN:忽略该信号

SIG_DFL:用系统默认方式处理信号

自定义的信号处理函数指针

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

void sigFunc(int signum)
{
    if(SIGCHLD == signum)
    {
        int ret = waitpid(-1, NULL, WNOHANG);
        if(0 == ret)
        {
            printf("子进程状态发生改变但没结束！\n");
        }
        else if(ret > 0)
        {
            printf("子进程结束已被回收！\n");
        }
    }
}



int main()
{
    printf("11111111111111\n");
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork error!");
        return -1;
    }
    else if(pid > 0)
    {
        //注册信号
        //子进程状态改变时，父进程就会收到SIGCHLD这个信号
        signal(SIGCHLD, sigFunc);
        //父进程中fork的返回值是子进程的pid
        //父进程会进这个分支
        while(1)
        {
            printf("I am parent process!, pid = %d\n", getpid());
            sleep(1);
        }
    }
    else
    {
        //子进程中的fork的返回值为0
        //子进程会进这个分支
        int i = 0;
        while(1)
        {
            i++;
            printf("I am child process!pid = %d, ppid = %d\n", getpid(), getppid());
            sleep(1);
            if(20 == i)
            {
                printf("kkkkkkk");
                //return 0; main函数return
                _exit(5);
            }
        }
    }
    while(1);
    return 0;
}

（4）共享内存

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main()
{
    //创建并打开共享内存
    key_t key = ftok(".", 10);
    if(key < 0)
    {
        perror("ftok error!");
        return -1;
    }
    printf("key = %d\n", key);
    int shmId = shmget(key, 100, 0666 | IPC_CREAT);
    if(shmId < 0)
    {
        perror("shmget error!");
        return -1;
    }
    printf("shmId = %d\n", shmId);


    //将用户空间的虚拟内存映射到内核空间的物理内存
    void *p = shmat(shmId, NULL, 0);
    if((void *)-1 == p)
    {
        perror("shmat error!");
        //删除共享内存
        shmctl(shmId, IPC_RMID, NULL);
        return 0;
    }

    //操作共享内存
    printf("input int:");
    scanf("%d", (int *)p);

    //取消映射
    shmdt(p);
    //删除共享内存
    shmctl(shmId, IPC_RMID, NULL);
    
    return 0;
}

（5）消息队列

是一个消息的列表，用户可以在消息队列中添加消息、读取消息；由消息队列ID来唯一标识，可以按照类型来发送/接收消息

write：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#define N 100
typedef struct msg
{
    long mtype;
    char text[N];
}data_t;

int main()
{
    //创建并打开消息队列
    key_t key = ftok(".", 15);
    if(key < 0)
    {
        perror("ftok error!");
        return -1;
    }
    printf("key = %d\n", key);
    int msgId = msgget(key, 0666 | IPC_CREAT);
    if(msgId < 0)
    {
        perror("msgget error!");
        return -1;
    }

    printf("msgId = %d\n", msgId);
    data_t data = {0};
    int i;
    for(i = 0; i < 5; i++)
    {
        memset(&data, 0, sizeof(data));
        printf("mtype:");
        scanf("%ld", &data.mtype);
        printf("msg:");
        scanf("%s", data.text);
        //添加消息
        int ret = msgsnd(msgId, (const void *)&data, N, 0);
        if(ret < 0)
        {
            perror("msgsnd error!");
            msgctl(msgId, IPC_RMID, NULL);
            return -1;
        }
    }
    return 0;
}
read：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#define N 100
typedef struct msg
{
    long mtype;
    char text[N];
}data_t;

int main()
{
    //创建并打开消息队列
    key_t key = ftok(".", 15);
    if(key < 0)
    {
        perror("ftok error!");
        return -1;
    }
    printf("key = %d\n", key);

    int msgId = msgget(key, 0666 | IPC_CREAT);
    if(msgId < 0)
    {
        perror("msgget error!");
        return -1;
    }

    //读消息
    data_t data = {0};
    int ret = msgrcv(msgId, &data, sizeof(data.text), 3, 0);
    if(ret < 0)
    {
        perror("msgrcv error!");
        msgctl(msgId, IPC_RMID, NULL);
        return -1;
    }
    printf("mtype:%d, msg:%s\n", data.mtype, data.text);
    
    //删除消息队列
    //msgctl(msgId, IPC_RMID, NULL);
    return 0;
}

（6）套接字

二、线程

线程是系统调度的最小单位，线程就是轻量级的进程，对于OS而言进程与线程都是需要调度的任务，而且都在内核空间都有task_struct，线程共享进程的地址空间，不需要来回切换地址空间，开销更小

1、线程的创建与回收

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

char buf[] = "hello world!";

//线程执行的函数
void *threadFunc1(void *arg)
{
    int i = 0;
    while(1)
    {
        printf("thread1.......%s\n", buf);
        sleep(1);
        i++;
        if(5 == i)
        {
            //线程退出
            pthread_exit(buf);//内核中还有task_struct
            //return buf; //函数结束线程就结束
        }
    }
    return NULL;
}

void *threadFunc2(void *arg)
{
    while(1)
    {
        printf("thread2.......%s\n", buf);
        sleep(1);
    }
}
int main()
{
    //主线程
    //创建子线程
    pthread_t thId1, thId2;
    pthread_create(&thId1, NULL, threadFunc1, NULL);
    pthread_create(&thId2, NULL, threadFunc2, NULL);


    //void *th1_val = NULL;
    //pthread_join(thId1, &th1_val);
    //printf("th1 quit,return_val = %p\n", th1_val);
    //将子线程设置为游离态，分离
    //子线程退出，系统会自动回收子线程
    pthread_detach(thId1);
    pthread_detach(thId2);
    while(1)
    {
        printf("process......%s\n", buf);
        sleep(1);
    }
    return 0;
}

2、线程的同步：信号量

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

sem_t sem1, sem2;

//线程执行的函数
void *getPicThread(void *arg)
{
    while(1)
    {
        //申请sem1的资源
        sem_wait(&sem1);
        printf("正在采集图片....\n");
        usleep(200);
        //释放sem2的资源
        sem_post(&sem2);
    }
    return NULL;
}

void *handlePicThread(void *arg)
{
    while(1)
    {
        //申请sem2的资源
        sem_wait(&sem2);
        printf("正在转换图片\n");
        usleep(100);
        //释放sem1的资源
        sem_post(&sem1);
    }
}

int main()
{
    //初始化信号量
    sem_init(&sem1, 0, 3);
    sem_init(&sem2, 0, 0);


    //主线程
    //创建子线程
    pthread_t thId1, thId2;
    pthread_create(&thId1, NULL, getPicThread, NULL);
    pthread_create(&thId2, NULL, handlePicThread, NULL);


    pthread_detach(thId1);
    pthread_detach(thId2);
    while(1);
    return 0;
}

3、线程的互斥：互斥锁

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


pthread_mutex_t mutex;

//共享资源
char buf[100] = {0};

void *threadFunc1(void *arg)
{
    char *p = (char *)arg;
    int i = 0;

    //加锁
    pthread_mutex_lock(&mutex);
    while(p[i] != '\0')
    {
        buf[i] = p[i];
        usleep(200);
        i++;
    }
    printf("th1 buf:%s\n", buf);
    //解锁
    pthread_mutex_unlock(&mutex);
}


void *threadFunc2(void *arg)
{
    char *p = (char *)arg;
    int i = 0;
    //加锁
    pthread_mutex_lock(&mutex);
    while(p[i] != '\0')
    {
        buf[i] = p[i];
        usleep(200);
        i++;
    }
    printf("th2 buf:%s\n", buf);
    //解锁
    pthread_mutex_unlock(&mutex);
}

int main()
{
    //申请互斥锁
    pthread_mutex_init(&mutex, NULL);

    pthread_t thId1, thId2;

    char strTh1[100] = "abcddefghk";
    char strTh2[100] = "1234567890";

    pthread_create(&thId1, NULL, threadFunc1, strTh1);
    pthread_create(&thId2, NULL, threadFunc2, strTh2);
    
    //pthread_detach(thId1);
    //pthread_detach(thId2);

    //while(1);
    pthread_join(thId1, NULL);
    pthread_join(thId2, NULL);
    return 0;
}

注意避免死锁发生

qq_38296162
关注
基本概念理解：程序、进程、线程及其关系
weixin_43178406的博客
08-12 2万+
本文主要介绍了基本概念理解：程序、进程、线程及其关系，希望能对学习的同学有所帮助。 文章目录 1. 基本概念：程序、进程、线程
Win32 多线程学习总结
bcbobo21cn的专栏
04-03 2085
Win32多线程编程学习心得 http://blog.csdn.net/jonathan321/article/details/50782832 博客原文地址：http://jerkwisdom.github.io/study/thread/thread-Summary/ 此处博客不再更新。 为什么多线程？ 多线程并不一定是最好的，合适才是最好的。 多线程主要的优点是价
Java多线程学习总结
2303_80645080的博客
04-09 1050
Java多线程学习总结
操作系统 之 进程 学习总结
chenyfan_blog
06-18 3133
Linux 操作系统 之 进程 学习总结
操作系统-进程和线程的学习总结
Linn的博客
12-18 1229
操作系统的设计，可以归结为三点： - 以多进程形式，允许多个任务同时运行； - 以多线程形式，允许单个任务分成不同的部分运行； - 提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。 进程和线程的区别：进程是程序在执行过程中分配和管理资源的基本单位，线程是CPU调度和分派的基本单位 进程和线程上下文切换区别 Java中创建的线程是用户级还是内核级 用户态线程和内核态线程 进程间的通信方式 线程间的通信方式 创建进程的开销比线程大在了哪里？
进程、线程总结（Linux）
qq_48757526的博客
06-02 2488
进程：一个正在运行的程序；线程：进程中的一条执行路径。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
进程和线程实验总结
坏鱼儿恋夏的博客
08-06 5070
看了线程一个礼拜，我觉得最能考验知识就是这次实验题，让我知道了学习中很多的不足 一、进程原题/* POSIX 下进程控制的实验程序残缺版 */ #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <signal.h> #include <ctype.h> /* 允许建立的子进程个数最大值 */ #d
java多线程学习总结
qq_41784749的博客
12-24 1万+
1.进程与线程的区别 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位； 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文件和信 号等)，某进程内的线程在其他进程不可见； 调度和切换：线程上下文切换比进程上下文切换要快得多 2.创建线程的三种方法： 1.创建线程方式一：继承Thread类，重写run方法，调用start开启线程 publ
Linux系统编程之进程线程
qq_52531759的博客
10-10 1859
本文主要介绍的是线程和进程的概念及常用函数。
第二次学习总结-多线程多进程学习.docx
06-10
以上知识点涵盖了多线程多进程编程的基本要素，包括进程线程的创建与管理、同步机制、进程间通信方式以及工程构建和库的使用。理解并掌握这些内容，能够帮助开发者编写高效、稳定的多线程多进程应用程序。
进程&线程查看器2.0.rar_Process_c 查看进程_进程线程
09-20
4. **进程线程查看器的作用**："进程&线程查看器2.0"是一个实用的工具，它能实时显示系统中所有进程及其对应的线程信息，包括进程ID、优先级、内存使用情况、线程数量等。这对于开发者调试程序、排查系统问题或监控...
Java多线程学习总结.pdf
10-31
在操作系统层面，进程是系统资源分配的基本单位，每个进程都有独立的内存空间，而线程是执行单元，是进程内的一个执行路径，线程之间可以共享同一进程的资源，比如内存。相比进程，线程具有更高的并发性和更低的切换...
C#从零开始学习(类型和引用)(4)
最新发布
Hikigaya_Hachi的博客
10-19 1035
C#类型和引用学习
【PHP小课堂】一起学习PHP中的反射（一）
硬核项目经理
10-14 1202
一起学习PHP中的反射（一）反射这个名词相信大家不会陌生，但反过来说，这个反射到底是一个什么概念呢？其实反射，就是通过一些方法函数，来获得一个类或者一个实例化对象中的一些信息。当然，更重要的是，它可以是在运行时来动态获取这些信息的。这样的话，有很多功能就可以通过反射来实现了。比如说 Java 中的注解，在一些 PHP 的框架中，要实现类似的注解功能，就是通过反射来获得注释中的信息来实现的。大家可以...
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
10-15 1276
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
stm32单片机个人学习笔记9（TIM输入捕获）
2302_80867398的博客
10-13 316
从模式选择Reset模式可以实现自动清零计数器CNT。
学习笔记——交换——STP（生成树）基本概念
灵韵的博客
10-16 1081
端口收到一个BPDU报文后，抽取该BPDU报文中累计根路径开销字段的值，加上该端口本身的路径开销即为累计根路径开销。从一个非根桥到达根桥的路径可能有多条，每一条路径都有一个总的开销值，此开销值是该路径上所有接收BPDU端口的端口开销总和(即BPDU的入方向端口)。STP交换机每一个端口都对应一个开销值，这个值表示数据通过端口发送时的开销，这个值与端口带宽有关，带宽越高，开销值越小。根路径开销是根据交换机之间的网段来说的，本地路径的开销也叫端口开销是针对本地的物理链路来说的相关的IETF的规定为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值