Linux：进程（二）
目录
一、cwd的理解
cwd（current working directory）。译为当前工作目录。
在C语言中，使用fopen函数打开文件时，第一个参数为当前目录下的某个文件的文件名，那么如何理解“当前目录”。
我们已经知道在/proc目录下，以文件的形式存放着每一个进程。
需要注意的是，只有当一个可执行程序被执行后，对应的进程文件才会在/proc目录下出现。
[euto@VM-4-13-centos 24915]$ ./myprocess
i am a process! id: 3800,fid: 2963
i am a process! id: 3800,fid: 2963
i am a process! id: 3800,fid: 2963
i am a process! id: 3800,fid: 2963
···········同时在/proc目录下，出现一个进程目录3800。
[euto@VM-4-13-centos 24915]$ ls /proc
1 16 264 36 560 acpi kallsyms scsi
10 170 265 3647 562 buddyinfo kcore self
1005 17110 269 37 563 bus keys slabinfo
1071 18 27 3721 568 cgroups key-users softirqs
1074 1825 275 376 575 cmdline kmsg stat
1077 19 28 38 6 consoles kpagecount swaps
11 196 28150 3800 637 cpuinfo kpageflags sys
1100 2 285 4 638 crypto loadavg sysrq-trigger
1196 20 28704 400 639 devices locks sysvipc
12 21 28720 403 640 diskstats mdstat timer_list
1206 22 28721 407 641 dma meminfo timer_stats
1207 23 29 4452 65 driver misc tty
1218 23737 290 46 671 execdomains modules uptime
1219 24 291 48 7 fb mounts version
13 25 2959 49 8 filesystems mtrr vmallocinfo
1347 259 2962 50 9 fs net vmstat
1354 25995 2963 51 9648 interrupts pagetypeinfo xpmem
1373 26 30772 516 9684 iomem partitions zoneinfo
14 262 3123 5375 9802 ioports sched_debug
14075 263 35 5421 9803 irq schedstat
我们可以查看进程3800的目录。
[euto@VM-4-13-centos 24915]$ ll /proc/3800
total 0
dr-xr-xr-x 2 euto euto 0 Sep 18 10:20 attr
-rw-r--r-- 1 euto euto 0 Sep 18 10:20 autogroup
-r-------- 1 euto euto 0 Sep 18 10:20 auxv
-r--r--r-- 1 euto euto 0 Sep 18 10:20 cgroup
--w------- 1 euto euto 0 Sep 18 10:20 clear_refs
-r--r--r-- 1 euto euto 0 Sep 18 10:17 cmdline
-rw-r--r-- 1 euto euto 0 Sep 18 10:20 comm
-rw-r--r-- 1 euto euto 0 Sep 18 10:20 coredump_filter
-r--r--r-- 1 euto euto 0 Sep 18 10:20 cpuset
lrwxrwxrwx 1 euto euto 0 Sep 18 10:17 cwd -> /home/euto/linux/24915
-r-------- 1 euto euto 0 Sep 18 10:17 environ
lrwxrwxrwx 1 euto euto 0 Sep 18 10:17 exe -> /home/euto/linux/24915/myprocess
dr-x------ 2 euto euto 0 Sep 18 10:17 fd
dr-x------ 2 euto euto 0 Sep 18 10:20 fdinfo
-rw-r--r-- 1 euto euto 0 Sep 18 10:20 gid_map
-r-------- 1 euto euto 0 Sep 18 10:20 io
·······················需要注意两个信息，exe所指向的就是该进程对应的可执行程序所在目录。
这里还有一个信息就是cwd，不难总结出来，cwd和进程是深深绑定的，换句话说，我们平时说讲的“当前目录”，其实就是和进程绑定的cwd。因此，在C语言中使用fopen打开当前目录下某个文件的操作，其实就是可执行程序运行起来后，对应的进程中cwd所指目录下的某个文件。
下面对这个结论作验证，通过执行指令chdir来演示，chdir的功能用来改变当前的工作目录。
CHDIR(2) Linux Programmer's Manual CHDIR(2)
NAME
chdir, fchdir - change working directory
SYNOPSIS
#include <unistd.h>
int chdir(const char *path);
int fchdir(int fd);
······修改源文件为以下内容。
[euto@VM-4-13-centos 24915]$ cat myprocess.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
printf("当前进程pid:%d\n",getpid());
printf("修改目录前\n");
sleep(30);
printf("修改目录后\n");
chdir("/home/euto/");
sleep(30);
FILE* fp = fopen("test.txt","w");
fclose(fp);
return 0;
}演示结果应该为：修改目录前，cwd为当前文件所在的目录24915。修改目录后，cwd更改为/home/euto，执行fopen打开文件test.txt时，由于test.txt文件并不存在，所以新建一个文件test.txt，新建文件所在的目录是/home/euto。
[euto@VM-4-13-centos 24915]$ ./myprocess
当前进程pid:16846
修改目录前
[euto@VM-4-13-centos 24915]$ ll /proc/16846
total 0
dr-xr-xr-x 2 euto euto 0 Sep 18 10:43 attr
-rw-r--r-- 1 euto euto 0 Sep 18 10:43 autogroup
-r-------- 1 euto euto 0 Sep 18 10:43 auxv
-r--r--r-- 1 euto euto 0 Sep 18 10:43 cgroup
--w------- 1 euto euto 0 Sep 18 10:43 clear_refs
-r--r--r-- 1 euto euto 0 Sep 18 10:43 cmdline
-rw-r--r-- 1 euto euto 0 Sep 18 10:43 comm
-rw-r--r-- 1 euto euto 0 Sep 18 10:43 coredump_filter
-r--r--r-- 1 euto euto 0 Sep 18 10:43 cpuset
lrwxrwxrwx 1 euto euto 0 Sep 18 10:43 cwd -> /home/euto/linux/24915
-r-------- 1 euto euto 0 Sep 18 10:43 environ
lrwxrwxrwx 1 euto euto 0 Sep 18 10:43 exe -> /home/euto/linux/24915/myprocess
dr-x------ 2 euto euto 0 Sep 18 10:43 fd
dr-x------ 2 euto euto 0 Sep 18 10:43 fdinfo
·······程序执行chdir修改目录后。
[euto@VM-4-13-centos 24915]$ ./myprocess
当前进程pid:16846
修改目录前
修改目录后
[euto@VM-4-13-centos 24915]$ ll /proc/16846
total 0
dr-xr-xr-x 2 euto euto 0 Sep 18 10:43 attr
-rw-r--r-- 1 euto euto 0 Sep 18 10:43 autogroup
-r-------- 1 euto euto 0 Sep 18 10:43 auxv
-r--r--r-- 1 euto euto 0 Sep 18 10:43 cgroup
--w------- 1 euto euto 0 Sep 18 10:43 clear_refs
-r--r--r-- 1 euto euto 0 Sep 18 10:43 cmdline
-rw-r--r-- 1 euto euto 0 Sep 18 10:43 comm
-rw-r--r-- 1 euto euto 0 Sep 18 10:43 coredump_filter
-r--r--r-- 1 euto euto 0 Sep 18 10:43 cpuset
lrwxrwxrwx 1 euto euto 0 Sep 18 10:43 cwd -> /home/euto
-r-------- 1 euto euto 0 Sep 18 10:43 environ
lrwxrwxrwx 1 euto euto 0 Sep 18 10:43 exe -> /home/euto/linux/24915/myprocess
dr-x------ 2 euto euto 0 Sep 18 10:43 fd
········查看/home/euto目录，发现test.txt文件新建在了这个目录，和预期符合。
[euto@VM-4-13-centos 24915]$ ls /home/euto/
linux test.txt
二、fork的理解
运行man fork查看fork的相关介绍。
FORK(2) Linux Programmer's Manual FORK(2)
NAME
fork - create a child process
SYNOPSIS
#include <unistd.h>
pid_t fork(void);
fork这个函数用来创建一个子进程。
父进程和子进程的关系：一个父进程可以有多个子进程，而一个子进程的父进程是唯一的。
fork的返回值介绍。
RETURN VALUE
On success, the PID of the child process is returned in the parent,
and 0 is returned in the child. On failure, -1 is returned in the parent,
no child process is created, and errno is set appropriately.
子进程创建失败，返回负数。
子进程创建成功，给父进程返回子进程的pid，给子进程返回0。（pid都是大于0的整数）
1.代码共享
- 结论：使用fork创建子进程后，父进程和子进程共享代码。
解释：
在目录24918下编辑源文件myprocess.c的内容。
[euto@VM-4-13-centos 24918]$ cat myprocess.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
printf("fork之前:i am a process ,pid:%d,ppid:%d",getpid(),getppid());
fork();
printf("fork之后:i am a process ,pid:%d,ppid:%d",getpid(),getppid());
return 0;
}
运行结果显示。
[euto@VM-4-13-centos 24918]$ ./myprocess
fork之前:i am a process ,pid:16709,ppid:6682
fork之后:i am a process ,pid:16709,ppid:6682//父进程
fork之后:i am a process ,pid:16710,ppid:16709//子进程
第二句printf被打印了两次的原因是，父进程和子进程分别进行了打印。在执行fork这个函数后，子进程就已经在内存中存在了，子进程和父进程指向同一个可执行程序，在fork函数后需要执行的代码被父子进程共享。
其中，一条打印结果的ppid是另一条打印结果的pid，说明这是父子进程。
关于子进程的PCB，大部分内容和父进程相同。
关于共享的可执行程序，代码和数据都只有一份。
2.各司其职
- 结论：一般而言，父进程和子进程完成的功能是不同的，源文件的代码只有一份，但是通过条件判断语句让父进程和子进程可以实现不同的功能。
解释：编辑源文件myprocess.c的内容如下。
int main()
{
printf("fork之前i am a process,pid:%d ,ppid:%d\n",getpid(),getppid());
sleep(5);
printf("开始创建子进程\n");
pid_t id = fork();
if(id < 0){
return 1;
}
else if(id == 0)
{
//子进程
while(1)
{
printf("fork之后，我是子进程，pid:%d,ppid:%d,id:%d\n",getpid(),getppid(),id);
sleep(1);
}
}
else{
//父进程
while(1)
{
printf("fork之后，我是父进程，pid:%d,ppid:%d,id:%d\n",getpid(),getppid(),id);
sleep(1);
}
}
return 0;
}
运行结果如下。
[euto@VM-4-13-centos 24918]$ ./myprocess
fork之前i am a process,pid:32557 ,ppid:30035
开始创建子进程
fork之后，我是父进程，pid:32557,ppid:30035,id:32570
fork之后，我是子进程，pid:32570,ppid:32557,id:0
fork之后，我是父进程，pid:32557,ppid:30035,id:32570
fork之后，我是子进程，pid:32570,ppid:32557,id:0
fork之后，我是父进程，pid:32557,ppid:30035,id:32570
fork之后，我是子进程，pid:32570,ppid:32557,id:0
fork之后，我是父进程，pid:32557,ppid:30035,id:32570
fork之后，我是子进程，pid:32570,ppid:32557,id:0
······程序运行成功后，父进程和子进程执行各自的代码，但是源文件的代码在内存中只有一份，数据也是只有一份。
如果子进程在执行的过程中修改某一个变量，实际上并不是修改变量本来的内存空间，而是在修改之前，完成一个“写时拷贝”的操作，拷贝一份新的空间用来给子进程操作，父进程也是如此。
3.fork的返回值
- 为什么fork返回时，给父进程返回子进程的pid，给子进程返回0？
如果作为子进程，只需要调用getppid即可获取到父进程，因为父进程是唯一的；如果作为父进程，是没有办法直接获取到子进程的pid的，因为子进程不唯一，可以有多个。
- fork给两个进程返回了不同的值，众所周知，函数不可能返回两个值，因此，可以判断，fork函数返回了两次，那么fork是如何返回两次的？
我们假设这是fork函数的函数体。
在return语句之前，fork处理创建子进程相关的操作，且执行return这一行代码之前，子进程就已经被创建出来并活跃在内存中，return语句的本质就写入到不同的进程，可以看作是特殊的返回，执行两次return分别返回到不同的进程中。
- 源代码中的id是一个变量，为什么一个变量可以有两个值？
操作系统在设计进程的时候，就保证了进程之间是彼此独立的，互相不影响。且利用了虚拟内存等其他技术，使得在Linux下，用一个变量表示了不同的内存空间。
编写一次创建多个进程的源程序，代码如下。
const int num = 10;
void worker()
{
int cnt = 10;
while(cnt)
{
printf("child %d is running,cnt:%d\n",getpid(),cnt);
--cnt;
sleep(1);
}
}
int main()
{
for(int i =0;i < num; ++i)
{
pid_t id = fork();
if(id<0)
{
break;
}
if(id == 0)
{
worker();
exit(0);
}
printf("父进程成功创建子进程,id:%d\n",id);
sleep(1);
}
sleep(10);
return 0;
}
三、进程状态
1.进程排队
- 为什么存在进程排队这样的现象？
进程出现了排队，一定是在等待某个资源，毕竟硬件资源有限。
- 进程不是一直在运行的。进程在CPU上，也不是一直在运行的。
比如，当程序执行到scanf这一行的时候，程序在等待键盘的输入，即在等待硬件资源（也可能是软件资源），因此进程不是一直在运行的。
在CPU上，由于时间片的设计，CPU也不是一直在运行同一个进程。
- 进程=PCB + 可执行程序，所谓的进程排队是可执行程序在排队还是PCB在排队？
排队一定是利用了队列这种数据结构，那么单位类型是可执行程序的话消耗将会巨大无比，因此涉及排队，都是利用队列对PCB作排队。
- 不难发现，一个task_struct，既要利用链表这种数据结构，又要利用队列这种数据结构，那么底层是怎么实现的呢，是存储两份数据吗？
并不是下面这样的实现。
而是在task_struct内部封装链表结点或者队列结点，因此一个task_struct可以被链入到多个数据结构中。
那么，在已知listnode地址的情况下，如何操作task_struct其他数据呢，这就和偏移量有关。
2.进程状态
进程的三种状态：运行，阻塞，挂起。
- 状态是什么
本质上，就是task_struct中的一个整型变量。
struct task_struct
{
int status;
····
}用整型变量表示不同的状态就类似define定义。
#define new 1
#define ready 2
#define running 3
#define block 4
·····- 设计状态这一个属性的意义。
通过进程的状态来决定下一步进程要做的动作。
运行状态
一个CPU对应一个运行队列。当进程在运行队列中排队时，即为运行状态。
原文地址：https://blog.csdn.net/weixin_74098337/article/details/142326020
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！