简明Linux教程-Linux下的进程

最新推荐文章于 2022-09-06 23:49:19 发布
最新推荐文章于 2022-09-06 23:49:19 发布
阅读量338 收藏 1
点赞数
分类专栏： Linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Blunt_Du/article/details/122590365
版权

8 进程

8.1 程序/进程/CPU相关

程序：死的，只占用磁盘空间； ----剧本

进程：活的，运行起来的程序，占用内存/CPU等资源 ----演出

一个进程可以同时在多处进行运行；

并发：在操作系统中，一个时间段中由多个进程都处于已启动运行到运行完毕之后的状态；但同一个时刻点只有一个进行在运行；

单道程序设计（串行）/多道程序设计（并行）

多道程序设计必须由硬件设计基础作为保证

CPU的量级是ns级的，

时钟中断即为多道程序设计模型的基础；

存储介质，越往下，速度越慢，容量越大。

一个寄存器，4个字节,32位机器的情况下；

MMU在CPU内部，虚拟内存映射单元；用于将指针存储的虚拟地址转换成实际的地址

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l3qlcvRQ-1642599317427)(/home/daniel/.config/Typora/typora-user-images/image-20210514141826927.png)]

8.2 虚拟内存和真实内存之间的映射关系

0～4G的地址是虚拟地址，4G范围是可用范围；真实内存可以是小于等于 4G

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wcICWPbx-1642599317429)(/home/daniel/.config/Typora/typora-user-images/image-20210514142504513.png)]

虚拟地址>>>>>>>>>>>MMU>>>>>>>>>>内存（真实物理地址）

内存大小以4K为单位；映射是分块映射，单位是4K

一个进程除内核空间之外的内容会映射到内存中与其它进程不同的区域，而所有成的PCB控制块，都属于操作系统，会映射到同一片区域；

MMU还可以用来设置内存访问区权限（将空间分为内存空间和内核空间）

Linux系统映射分为两个级别，0级和3级，0级代表内核空间，3级代表用户空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hrY8grkI-1642599317429)(/home/daniel/.config/Typora/typora-user-images/image-20210514222150738.png)]

8.3 PCB进程控制块

linux中进程控制块的位置：/usr/src/linux-headers-5.4.0-72/include/sched.h

进程控制块的结构体名称：struct task_struct{…}

进程控制块需要重点掌握内容：

1）进程id。系统每个进程的都有独立的运行id，在C中用pid_t表示，其实是一个非负整数；

ps aux ps aux|grep content

2）进程状态，由就绪（初始化和就绪），运行，挂起，停止等状态；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qzd5lvFK-1642599317430)(/home/daniel/.config/Typora/typora-user-images/image-20210514151550770.png)]ec

3）进程切换时需要保存一些CPU寄存器；

4）描述虚拟地址空间的信息；

5）描述控制终端的信息；

6）当前目录（current working directory);（例如使用 ls .或者ls …）

7）umask 掩码 是进程的概念

比如：使用两个shell，一个shell的umask设置为003，另外一个shell的默认umask并不会改变，说明umask是shell的PCB中存储的属性；

8）文件描述符表，包含很多指向file结构体的指针；

文件描述符表>>>>>>文件描述符>>>>>>FILE

9) 和信号相关的信息；

10）用户id和组id；

11）会话（session)和进程组；

  1. 进程可以使用的资源上限（Resource Limit）

8.4 环境变量

特点：环境变量的实质时字符串，其字母一般是大写的

格式：name=value

作用：值用来描述环境信息；

LD_LIBRARY_PATH 指明动态连接库的位置；

PATH 记录可执行文件目录位置；

例如：使用shell中的各种命令，就是PATH规定了寻找位置

echo $PATH

SHELL 记录当前使用shell是哪个 echo $SHELL

TERM 当前终端类型 echo $TERM

LANG 语言和locale echo $LANG

HOME 家目录 echo $HOME

env 命令，查看所有环境变量

环境变量和main函数的命令行参数均存放在3～4G之前的那块位置，就是栈的顶端

8.5 进程控制

8.5.1 fork()函数

函数名：pid_t fork(void)

功能：创建子进程

头文件：#include <sys/type.h> #include <unistd.h>

参数：void

返回值：成功创建进程，父进程返回子进程的pid，子进程返回0；创建失败，父进程返回-1，子进程未被创建，没有返回值，同时设置erron；

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

int main(int argc, char** argv)
{
    printf("-----Befor fork!-----\n");
    int pid;
    pid=fork();
    if(pid==-1){
        perror("fork failed!\n");
    }
    else if(pid==0){
        printf("----this is child process!-----\n");
        printf("my pid is %d\n",getpid());
        printf("my parent's pid is %d\n",getppid());

    }
    //主进程的父进程是//bin/bash
    else if(pid>0){
        printf("-----this is parent process!-----\n");
        printf("my pid is %d\n",getpid());
        printf("my parent's pid is %d\n",getppid());
    }
    printf("-----this is the end of file-----\n");
    return 0;
}

父进程在子进程之前，先执行。

daniel@daniel-Vostro-5471:~/文档/OS/test/fork$ ./fork
-----Befor fork!-----
-----this is parent process!-----
my pid is 25840
my parent's pid is 23741
-----this is the end of file-----
----this is child process!-----
my pid is 25841
my parent's pid is 25840
-----this is the end of file-----
daniel@daniel-Vostro-5471:~/文档/OS/test/fork$ ps aux | grep 23741
daniel     23741  0.0  0.0  13932  4616 pts/2    Ss   09:02   0:00 /bin/bash
daniel     25860  0.0  0.0  11992   664 pts/2    S+   09:38   0:00 grep 23741

函数: pid_t getpid(void) 获取本进程的id pid_t getppid(void) 获取本进程父进程的id

头文件: #include<sys/types.h> #include <unistd.h>

参数：void

返回值：总是成功，返回进程id

实际运行中可以把bash看成在bash运行程序的父进程；

8.5.2 进程并发

代码：创建5个子进程

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char **argv)
{
    int i;
    __pid_t pid;
    for (i = 0; i < 5; i++)
    {
        if (fork() == 0)
        {
            break;
        }
    }
    if (i == 5)
    {
        sleep(1);
        printf("我是父进程\n");
    }
    else
    {
        printf("我是进程%d\n", i);
    }
    return 0;
}

getuid() 获取用户id getgid() 获取组id

8.5.3 父子进程共享

父子进程在fork之后，有那些相同？那些不同？

fork之后，

父子相同之处：全局变量/.data/.text/栈/堆/环境变量/用户ID/宿主目录/进程工作目录/信号处理方式

不同之处：进程id/父进程ID/fork返回值/进程运行时间/闹钟（定时器）/未决信号集

父子进程共享：文件描述符，mmap建立的映射区

父子进程遵循 读时共享，写时复制 的原则 应用在全局变量时

fork之后，父子进程哪个先执行，或者多个子进程哪个先执行，不确定，取决于内部算法；

父子进程不共享全局变量

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int var=0;
int main(int argc, char** argv)
{
    __pid_t pid;
    pid=fork();
    if(pid<0){
        perror("create fork failed!\n");
    }
    if(pid==0){
        var=200;
        printf("child, var=%d\n",var);
        printf("my pid %d, my parent %d\n",getpid(),getppid());
    }
    if(pid>0){
        var=288;
        printf("parent,var=%d\n",var);
        printf("my pid %d, my parent %d\n",getpid(),getppid());
    }
    return 0;
}

8.5.4 gdb调试多进程程序

使用gdb对多进程程序进行调整的时候，gdb默认只能跟踪1个进程，可以在fork函数调用之前，通过指令设置gdb调试工具跟踪父进程或者跟踪子进程。默认跟踪父进程

set follow-fork-mode child 命令设置gdb在fork之后，跟踪子进程

set follow-fork-mode parent 设置之后跟踪父进程

注意：一定要在fork函数调用之前，调用才有效；

8.5.5 exec函数族

有六种以exec开头的函数，统称为exec函数族；

fork创建子进程后，执行的是和父进程相同的程序（但有可能是不同的代码分支),子进程往往调用exec函数执行另外一个程序，当进程调用exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动历程开始执行。调用exec并不创建新的进程，所有调用exec之后，进程的id不会改变。

函数能够将当前进程的.text段和.data段，切换成所要加载程序的只读数据区和代码区，然后让进程从新的.text 第一条指令开始执行，但进程ID不便，换核不换壳。

其中有六种以exec开头的函数，统称为exec函数族；

函数：

int execl(const char *pathname, const char arg, … / (char *) NULL */);
int execlp(const char *file, const char arg, …/ (char *) NULL */);
int execle(const char *pathname, const char arg, …/, (char *) NULL, char *const envp[] */);
int execv(const char *pathname, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);

头文件：#include <unistd.h>

功能：在一个进程中执行另外一个程序

The  exec() family of functions replaces the current process image with a new process image.  The functions described in this manual  page  are front-ends  for execve(2).  (See the manual page for execve(2) for further details about the replacement of the current process image.)
The initial argument for these functions is the name of a file that  is to be executed.
The  functions can be grouped based on the letters following the "exec" prefix.

参数：char* pathname 代表程序路径 char* file 程序名字

​ arg 是程序执行的选项，可填写多个，是传递给第一个参数用的，注意从arg[0]开始填写；

​ NULL 必须要填写，是哨兵，帮助程序判断参数传递是否结束；

返回值：正常执行时，没有返回值；执行错误，返回-1，设置erron；

//execl函数
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
    int pid;
    pid=fork();
    if(pid==-1){
        perror("fork failed!\n");
    }
    else if(pid==0){
        //execl("./hello","hello",NULL);
        execl("/bin/ls","ls","-l",NULL);
        perror("exec error!\n");
        exit(1);
    }
    else if(pid>0){
        //使用sleep堵塞主进程，让子进程先执行
        sleep(1);
        printf("the pid of mine %d\n",getpid());
    }
    printf("-----this is the end of file-----\n");
    return 0;
}

//execlp函数
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
    int pid;
    pid=fork();
    if(pid==-1){
        perror("fork failed!\n");
    }
    else if(pid==0){
        //NULL  哨兵
        //execlp("ls","-l","-d","-h",NULL); 错误的写法，缺少argv[0]参数
        //execlp("ls","ls","-l","-h",NULL);  正确写法
        execlp("date","date",NULL);
        //如果上面执行成功，不会执行下面的程序
        perror("exec error\n");
        exit(1);
    }
    else if(pid>0){
        sleep(1);
        printf("the pid of mine %d\n",getpid());
    }
    printf("-----this is the end of file-----\n");
    return 0;
}

exec函数族一般规律：

1.一旦成功，执行新程序，不返回。只有失败，返回-1，所以通常值加添加perror或者exit，而不进行判断；

2.L(list) 命令行参数

​ P(path) 搜索file时，使用path变量

​ V(vector) 使用命令行参数数组

​ e(enviroment) 使用环境变量数组，不使用进程原有的环境变量，设置新加载程序运行的环境变量

​ 实际上，只有execve是真正的系统调用，其它均依赖于execve，

​ man 2 execve man 3 其它exec函数

8.5.6 孤儿进程&僵尸进程

孤儿进程：父进程先于子进程结束，则子程序成为孤儿进程。子进程的父进程成为init进程，称为init进程领养孤儿进程。

僵尸进程：进程终止，父进程尚未回收，子进程残留资源（PCB）存放在内核中，变成僵尸进程； kill命令对子进程无效

ps ajx 查看进程，包括进程的父进程；

孤儿进程demo：

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

int main(int argc, char **argv)
{
    printf("-----Befor fork!-----\n");
    int pid;
    pid = fork();
    if (pid == -1)
    {
        perror("fork failed!\n");
    }
    else if (pid == 0)
    {
        while (1)
        {
            //父进程运行完毕，但是子进程一直在运行
            //子进程成为了孤儿进程
            sleep(1);
            printf("my pid is %d\n", getpid());
            printf("my parent's pid is %d\n", getppid());
        }
    }
    else if (pid > 0)
    {
        printf("-----this is parent process!-----\n");
        sleep(9);
        printf("my pid is %d\n", getpid());
        printf("my parent's pid is %d\n", getppid());
    }
    printf("-----this is the end of file-----\n");
    return 0;
}
//使用kill -9 子进程pid	可以把子进程kill掉

僵尸进程：

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

int main(int argc, char **argv)
{
    printf("-----Befor fork!-----\n");
    int pid;
    pid = fork();
    if (pid == -1)
    {
        perror("fork failed!\n");
    }
    else if (pid == 0)
    {
        printf("----this is child process!-----\n");
        sleep(10);
        printf("my pid is %d\n", getpid());
        printf("my parent's pid is %d\n", getppid());
    }
    else if (pid > 0)
    {
        //子进程运行完毕之后，父进程一直在运行，没有时间回收子进程PCB
        //子进程变为僵尸进程
        while (1)
        {
            printf("-----this is parent process!-----\n");
            printf("my pid is %d\n", getpid());
            printf("my parent's pid is %d\n", getppid());
            sleep(1);
        }
    }
    printf("-----this is the end of file-----\n");
    return 0;
}
//使用 kill -9 父进程id	将父进程杀死，让init将僵尸进程回收

8.5.7 wait函数回收子进程

函数：pid_t wait(int *wstatus)

头文件：#include <sys/types.h> #include <sys/wait.h>

作用：1)堵塞父进程，等待子进程执行完毕；

​ 2)将wstatus传出，并且返回子进程id；

​ 3)让父进程回收子进程的pid;

参数： int *wstatus 传出参数 整型变量的指针

返回值：pid_t 子进程的pid号

demo:

使用处理wstatus的宏，

W_IFEXITED() W_EXITSTATUS() 判断是否正常退出，及子进程的返回值；

W_IFSIGNALED() W_TERMSIG() 判断是否信号终止，及终止信号的类型

W_IFSTOPPED() WSTOPSIG() WIFCONTINUED() 判断是否挂起，以及挂起信号，和挂起之后是否正常运行

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

int main(int argc, char **argv)
{
    printf("-----Befor fork!-----\n");
    pid_t pid, w_pid;
    int state;
    pid = fork();
    if (pid == -1)
    {
        perror("fork failed!\n");
    }
    else if (pid == 0)
    {
        printf("----this is child process!-----\n");
        printf("my pid is %d\n", getpid());
        printf("my parent's pid is %d\n", getppid());
        sleep(20);
        printf("I am going to die\n");
        //子进程的返回的状态
        return 68;
    }
    else if (pid > 0)
    {
        //wait参数可以为NULL，说明父进程不关心子子进程终止原因
        w_pid = wait(&state);
        printf("child is finished,the id of child %d\n", w_pid);
        if (WIFEXITED(state))
        {//如果正常退出，返回子进程的退出状态，也就是子进程返回的value
            printf("the child exit status %d\n", WEXITSTATUS(state));
        }
        if (WIFSIGNALED(state))
        {//如果被信号终止，打印终止程序运行的信号值
            printf("the terminate signal is %d\n", WTERMSIG(state));
        }
    }
    printf("-----this is the end of file-----\n");
    return 0;
}

kill -l命令可以查看所有的中断信号类型；一共由64种；

daniel@daniel-Vostro-5471:~/文档/OS/test/fork$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

函数： pid_t waitpid(pid_t pid,int *wstatus, int options)

头文件：#include <sys/type.h> #include <sys/wait.h>

参数：

​ 一次wait/waitpid函数调用，只能回收一个字进程；

​ pid_t pid 指定回收的进程pid，有几个不同的值

	0：meaning  wait  for  any child process whose process group ID is equal to that of the calling process at the time of the call to waitpid().
	>0:meaning wait for the child whose process ID is equal  to  the  value  of pid.

​ -1：meaning wait for any child process.

	<0:	meaning wait for the child whose process ID is equal  to  the  value  of pid.

​ 默认父进程分裂出的子进程属于一个组，但是可以通过系统待调用进行更改；

​ status:传出回收进程的状态

​ options:WNOHANG 指定回收方式：非阻塞

返回值：

​ >0:表示成功回收子进程pid；

​ 0：函数调用时，参3指定了WNOHANG，并且没有子进程结束；

​ -1：失败，errno[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GKb3e5M6-1642599317431)(/home/daniel/.config/Typora/typora-user-images/image-20210516172726360.png)]

DEMO：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>
int main(int argc, char **argv)
{
    int i;
    __pid_t pid, pid_w,pid_temp;
    for (i = 0; i < 5; i++)
    {
        if ((pid_w=fork()) == 0)
        {
            break;
        }
        if(i==2){
            pid_temp=pid_w;
        }
    }
    if (i == 5)
    {
        //读时共享，写时复制，所以父进程读取不到pid_w的值
        printf("我是父进程,我在等待回收子进程%d\n",pid_temp);
        //wpid=waitpid(-1,NULL,WNOHUNG);
        waitpid(pid_temp,NULL,0);//阻塞回收
        //waitpid(pid_temp,NULL,WNOHANG);//不阻塞回收
        printf("我回收子进程成功\n");
    }
    else
    {
        printf("我是进程%d,我的pid是%d\n", i,getpid());
    }
    return 0;
}

总结：不论wait和还是waitpid，一次调用只能回收一个子进程

想要回收多个子进程，可以通过循环调用waitpid()函数；循环回收子进程DEMO：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>
int main(int argc, char **argv)
{
    int i;
    __pid_t pid, pid_w, pid_temp;
    for (i = 0; i < 5; i++)
    {
        if ((pid_w = fork()) == 0)
        {
            break;
        }
        if (i == 2)
        {
            pid_temp = pid_w;
        }
    }
    if (i == 5)
    {
        /*while((pid_w=waitpid(-1,NULL,0))!=-1){
            printf("回收进程%d成功\n",pid_w);
        }*/
        while ((pid_w = waitpid(-1, NULL, WNOHANG)) != -1)
        {
            sleep(1);
            printf("回收进程%d成功\n", pid_w);
        }
    }
    else
    {
        printf("我是进程%d,我的pid是%d\n", i, getpid());
    }
    return 0;
}

8.5.8 练习题代码

//一个父进程fork三个子进程
//一个调用ps命令
//一个调用自定义程序1
//一个调用自定义程序2（出现段错误）
//使用waitpid进行回收
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char **argv)
{
    __pid_t pid, pid_w;
    int i = 0, state,ret;
    for (; i < 3; i++)
    {
        //创建三个进程，当fork
        if ((pid = fork()) == 0)
        {
            break;
        }
    }//进程1执行ps命令  正常
    if ((i == 0) && pid == 0)
    {
        printf("I'm child %d,my pid is %d\n",i+1,getpid());
        execlp("ps", "ps", NULL);
    }//进程2执行hello   正常
    else if ((i == 1) && (pid == 0))
    {
        printf("I'm child %d,my pid is %d\n",i+1,getpid());
        execl("./hello", "hello", NULL);
    }//进程3执行error   出现段错误
    //error是一个试图修改只读字符串的小程序
    else if ((i == 2) && pid == 0)
    {
        printf("I'm child %d,my pid is %d\n",i+1,getpid());
        ret=execl("./error", "error", NULL);
        perror("execl error\n");
    }//父进程
    if (pid>0)
    {//堵塞回收三个进程
        while ((pid_w = waitpid(-1, &state, 0))!=-1)
        {
            printf("I'm recycle %d\n", pid_w);
            if (WIFEXITED(state))
            {
                printf("exit state:%d\n", WEXITSTATUS(state));
            }
            else if (WIFSIGNALED(state))
            {
                printf("signal:%d\n", WTERMSIG(state));
            }
        }
    }
    return 0;
}

程序执行结果：

daniel@daniel-Vostro-5471:~/文档/OS/test/fork$ ./wait_prac
I'm child 1,my pid is 29028
I'm child 2,my pid is 29029
I'm child 3,my pid is 29030
hello_world!
hello_exec!
hello, I'm error!
I'm recycle 29029
exit state:0
    PID TTY          TIME CMD
   4481 pts/2    00:00:00 bash
  29027 pts/2    00:00:00 wait_prac
  29028 pts/2    00:00:00 ps
  29030 pts/2    00:00:00 error
I'm recycle 29028
exit state:0
I'm recycle 29030
signal:11

CPPlusQt
关注
专栏目录
linux下进程管理
江南又一春
03-01 553
1、linux下启动进程的两种方式： (1)方式一 手动启动:即用户输入命令直接启动。 分为前台运行和后台运行。 (2)方式二 调度启动:即系统根据事先的设定自行启动进程。 at命令：在指定时刻运行某一个进程。 cron命令：周期性的执行相关进程。 2、at命令 启动进程 (1)at命令功能简介 在指定的时刻执行相关的进程。 (2)使用at命令需要具备的条件 需要开启atd服务。 检查atd...
Linux下的进程
h___q的博客
11-15 231
什么是进程？ 当我们写好一份代码时，编译生成可执行程序，将这个可执行程序运行起来，在运行期间，这就是一个进程。在Linux系统下，任何一个可以运行的软件，包括操作系统自己，都可以称之为进程。 操作系统如何管理进程 一台计算机中有数不清的进程，操作系统的作用就是要将这些进程有序的管理起来。既然要管理，那就离不开先描述，后组织，在现实生活中，公司管理员工，学校管理学生，都是先将要管理的对象用一个统一的...
Linux进程基础
weixin_33750452的博客
09-20 120
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！   计算机实际上可以做的事情实质上非常简单，比如计算两个数的和，再比如在内存中寻找到某个地址等等。这些最基础的计算机动作被称为指令 (instruction)。所谓的程序(program)，就是这样一系列指令的所构成的集合。通过程序，我们可以让计算机完成复杂的操作。程序大多数时...
Linux下进程
SkinWhite的博客
07-17 544
进程 01.进程是什么？ 1.进程是什么？其实当你点开网易云音乐的时候你就会发现的你的任务管理器上有多了一个进程。Linux下也是一样的当你运行一段代码，你也可以通过查看进程从而观察到多了一个进程。但是你可以不要以为进程就是一段代码，代码是“死的”，而进程则是真真切切的“活着的”。 2.从内核来讲，进程是资源分配的最小单位，同样在没有线程的情况下，进程也是程序执行的最小单位。 ...
ubunt---linux命令行简明教程--
11-11
总结，Ubuntu Linux命令行简明教程涵盖了Linux操作系统的基础知识和常用命令，是学习和提升Linux技能的重要资料。通过熟练掌握这些命令，你将能够更高效地管理和使用Linux系统。这个PDF教程将是你宝贵的参考资料，...
简明Linux入门教程1
08-03
【简明Linux入门教程1】 Linux是一个开源的UNIX兼容操作系统，最初由Linux Torvalds于1991年创建。它的开发与进步得益于全球Linux社区的共同努力，遵循GNU通用公共许可证（GPL），允许用户自由获取和修改源代码，但...
linux简明教程.rar
08-29
Linux简明教程是一个针对初学者和有一定基础的学习者设计的教育资源，主要涵盖了Linux操作系统的基础知识、常用命令、系统管理以及服务器配置等内容。Linux是一种开源、免费的操作系统，它以其稳定性和安全性在...
Python简明教程-沈洁元.docx
最新发布
06-12
《Python简明教程-沈洁元》是一份旨在帮助初学者快速掌握Python基础知识的文档。教程作者沈洁元力求简洁明了，逐步引导无编程背景的读者进入Python的世界。本教程主要关注Python 2.7的基础语法，并指出与Python 3.x...
Linux简明教程.rar
07-09
本教程使用Ubuntu 10.04 LTS - Lucid Lynx做演示，其他版本皆大同小异，有特殊的相异之处， 我会特别指出，旨在为大家提供方便，勿做其他商业用途。 Ubuntu，Linux for human being ！ 献给全人类的 Linux！ ...
【Linux】进程入门详解
就爱摆烂
02-14 2192
配合Linux环境学习进程
Linux简明教程
you are sherlocked by me!
12-25 1756
一文入门Linux，多年开发经验大佬的简明教程，帮助你快速学习Linux，以便更深入学习
Linux简明教程-进程通信
Blunt_Du的博客
01-19 523
9 进程间通信 9.1 绪论 进程间通信（interprocess communication,简称IPC），Linux环境下进程空间相互独立，每个进程都有各自不同用户的地址空间，任何一个进程的全局变量在另外一个进程都看不到，所以进程之间不能相互访问，想要交换数据必须通过内核，在内核中将进程1把数据从用户空间拷贝到用户缓冲区，进程2再从用户缓冲区将数据拷贝走，内核提供的这种通信叫做IPC。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Ob77hxm-16425994326
linux系统的进程
Lijueqi001的博客
09-06 849
linux系统的进程
Linux下进程控制
wakelee14122的博客
09-10 285
1.进程创建  利用fork函数，在Linux中fork函数是一个非常重要的函数，它从已存在的进程中创建一个新进程，新进程为子进程而原进程为父进程。当进程调用fork函数，控制转移到内核中的fork代码后，内核： 1.分配新的内存块和内存数据结构给子进程 2.将父进程部分数据结构内容拷贝给子进程 3.添加子进程到系统进程列表中 4.fork返回，调度器开始调度 当一个进程调用fork后...
linux系统进程(1)
Garfield777的博客
07-15 253
1.什么是进程 进程就是系统未完成且正在进行的工作 2.查看进程 图形方式查看 gnome-system-monitor 进程查看命令 ps -A 所有进程 -a 在环境中的所有进程，不包含环境信息 -u 显示进程用户信息 a 显示当前环境中运行的进程，包含环境信息 x 列出系统中所有运行包含tty（字符）输出设备 f 显示进程的父子关系 如图PID为2...
Linux 简明教程
weixin_44062380的博客
05-29 823
文章目录Linux安装SSH 远程连接Linux 目录结构Linux 用户用户介绍查看用户信息创建用户删除用户口令（密码）管理Linux 常用命令查看目录 ls切换目录 cd显示当前目录 pwd创建目录删除目录文件操作查看文件catmoreless创建文件 touch写入文件 echo拷贝文件 cp移动文件 mv删除文件 rm打包与拆包其他命令查看进程快照管道VIM 编辑器（重要）命令模式输入模式底线命令模式Linux 文件权限文件权限修改文件权限mode 方式数字方式Linux 网络操作主机名查询系统完整
linux 进程教程,Linux教程－进程查看
weixin_29609679的博客
05-09 70
linux是个多用户系统，有时候也要了解其他用户现在在干什么，所以在本节中还将接触多用户方面的内容。同时Linux是一个多进程系统，经常需要对这些进程进行一些调配和管理；而要进行管理，首先就要知道现在的进程情况：究竟有哪些进程？进程情况如何？等等。所以需要进程查看方面的工作。who命令该命令主要用于查看当前在线上的用户情况。这个命令非常有用。如果用户想和其他用户建立即时通讯，比如使用talk命令，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值