进程在调度运行的时候,进程具有动态属性
见见系统调用
man getpid
测试代码:
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
while(1)
{
printf("我是一个进程!,我的ID是:%d\n",getpid());
sleep(1);
}
return 0;
}
每次重新运行程序pid都会改变
因为每次都需要重新加载到内存,就意味着操作系统都会重新创建task_struct,重新分配pid
ls /proc
“/proc/[pid]”目录,pid为进程的数字ID,是个数值,每个运行着的进 程都有这么一个目录。
查看父进程
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
while(1)
{
printf("我是一个进程!,我的ID是:%d\n,父进程ID是:%d\n",getpid(),getppid());
sleep(1);
}
return 0;
}
命令行上启动的进程,一般它的父进程没有特殊情况的话,都是bash
通过系统调用创建进程-fork初识
运行 man fork 认识fork
fork有两个返回值
父子进程代码共享,数据各自开辟空间,私有一份(采用写时拷贝)
创建进程
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
int ret = fork();
if(ret < 0){
perror("fork");
return 1;
}
else if(ret == 0){ //child
printf("I am child : %d!, ret: %d\n", getpid(), ret);
}else{ //father
printf("I am father : %d!, ret: %d\n", getpid(), ret);
}
sleep(1);
return 0;
}
进程状态
宏观概念
总结:
1.一个CPU一个运行队列
2.让进程入队列的本质是:将该进程的struct stsk_struct结构体对象放入运行队列中
3.进程PCB在runqueue,就是R–运行状态,而不是这个进程正在运行才叫运行状态
4.进程不只会等待(占用)CPU资源,也可能随时随地要外设资源
5.所谓的进程不同的状态,本质是进程在不同的队列中,等待某种资源
挂起状态
阻塞和挂起的区别
挂起了一定阻塞,阻塞了不一定挂起。阻塞时该进程的代码和数据都在内存中,当内存不足时,就会产生挂起状态该内存的数据和代码就会被操作系统放进磁盘中
Linux操作系统的的状态
static const char * const task_state_array[] = {
“R (running)”, /* 0 */
“S (sleeping)”, /* 1 */
“D (disk sleep)”, /* 2 */
“T (stopped)”, /* 4 */
“t (tracing stop)”, /* 8 */
“X (dead)”, /* 16 */
“Z (zombie)”, /* 32 */
};
R运行状态(running): 并不意味着进程一定在运行中,它表明进程要么是在运行中要么在运行队列里。
S睡眠状态(sleeping): 意味着进程在等待事件完成(这里的睡眠有时候也叫做可中断睡眠(interruptible sleep))。
**D磁盘休眠状态(Disk sleep):**有时候也叫不可中断睡眠状态(uninterruptible sleep),在这个状态的 进程通常会等待IO的结束。
T停止状态(stopped): 可以通过发送 SIGSTOP 信号给进程来停止(T)进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
**X死亡状态(dead):**这个状态只是一个返回状态,你不会在任务列表里看到这个状态。
进程状态查看
ps aux / ps axj 命令
R状态–运行状态
#include <stdio.h>
#include <unistd.h>
int main()
{
int a=0;
while(1)
{
a=1+2;
};
return 0;
}
S状态–阻塞状态
#include <stdio.h>
#include <unistd.h>
int main()
{
int a=0;
while(1)
{
a=1+2;
printf("当前a的值是:%d\n ",a);
};
return 0;
}
为什么是S状态?
因为printf会访问显示器,显示器是外设的输入输出速度比较慢,CPU就会等待显示器就绪。99%都是在等I/O就绪,1%才是执行打印代码。所以当我们去查的时候,几乎大概率都会是S状态
t状态 --停止状态
进程处于此状态表示该进程正在被追踪,比如 gdb 调试进程:
T状态–停止状态
测试代码
#include <stdio.h>
#include <unistd.h>
int main()
{
int a=0;
while(1)
{
a=1+2;
};
return 0;
}
kill -l
kill -19 [pid]–停止进程
后台运行
kill -18 [pid]–运行进程
后台运行–‘+’的消失
前台运行–有‘+’
用Ctrl+c不能杀死
就用kill -9 [pid]
总结:
先将该进程暂停后,再运行。进程状态前面的 + 号消失了,该进程变成了后台程序。但是对于后台进程来说,我们只能通过 kill 命令来杀死它。
D状态–深度睡眠
深度睡眠TASK_UNINTERRUPTIBLE:不可被信号唤醒;
浅度睡眠TASK_INTERRUPTIBLE:唤醒方式,等到需要的资源,响应信号;
深度睡眠场景:
有些场景是不能响应信号的,比如读磁盘过程是不能打断的,NFS也是;
执行程序过程中,可能需要从磁盘读入可执行代码,假如在读磁盘过程中,又有代码需要从磁盘读取,就会造成嵌套睡眠。逻辑做的太复杂,所以读磁盘过程不允许打断,即只等待IO资源可用,不响应任何信号;
应用程序无法屏蔽也无法重载SIGKILL信号,深度睡眠可以不响应SIGKILL kill-9信号;
注意:处于深度睡眠状态的进程既不能被用户杀掉,也不能被操作系统杀掉,只能通过断电,或者等待进程自己醒来。深度睡眠一般只会在高IO的情况发生下,且如果操作系统中存在多个深度睡眠状态的程序,那么说明该操作系统也即将崩溃了。
X–死亡状态
死亡状态代表着一个进程结束运行,该进程对应的PCB以及代码和数据全部被操作系统回收。
Z–僵尸状态
僵死状态(Zombies)是一个比较特殊的状态。当进程退出并且父进程(使用wait()系统调用,后面讲)没有读取到子进程退出的返回代码时就会产生僵死(尸)进程
僵死进程会以终止状态保持在进程表中,并且会一直在等待父进程读取退出状态代码。
所以,只要子进程退出,父进程还在运行,但父进程没有读取子进程状态,子进程进入Z状态
两个特殊的进程
Z(zombie)-僵尸进程
僵尸进程是处于僵尸状态的进程
脚本代码
while :; do ps axj | head -1 && ps axj |grep myprocess |grep -v grep; sleep 1; done
测试代码
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
//child
while(1){
printf("I am child process, pid: %d, ppid: %d\n", getpid(), getppid());
sleep(5);
exit(1);
}
}
else
{
//parent
while(1)
{
printf("I am parent proceass, pid: %d, ppid: %d\n", getpid(), getppid()); sleep(1);
}
}
return 0;
}
子进程:pid= 26655
父进程:ppid=26654
当运行一段时间后的显现,26654进程因为打印变成S状态,由于26655退出了该进程变成僵尸进程。
在上面测试代码中
if(id == 0)
{
//child
while(1){
printf(“I am child process, pid: %d, ppid: %d\n”, getpid(), getppid());
sleep(5);
exit(1);
}
}
子进程通过5秒后退出,结合观察得到再子进程(26655)退出后,父进程(26654)变成了僵尸状态。
26654 26655 26654 5238 pts/0 26654 Z+ 1005 0:00 [myprocess]
的意思失效
意味着该进程是失效的,死掉的
当我们再观察进程时,我们发现该进程不在了,其原因是关掉了父进程,该失效的子进程被系统回收了。
僵尸进程危害
进程的退出状态必须被维持下去,父进程需要一直知道子进程的状态,随时进行处理。可父进程如果一直不读取,那子进程就一直处于Z状态。
维护退出状态本身就是要用数据维护,也属于进程基本信息,所以保存在task_struct(PCB)中,换句话说,Z状态一直不退出,PCB一直都要维护。
那一个父进程创建了很多子进程,就是不回收,就会造成内存资源的浪费,因为数据结构对象本身就要占用内存,想想C中定义一个结构体变量(对象),是要在内存的某个位置进行开辟空间!–内存泄漏
孤儿进程
测试代码
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
//child
while(1){
printf("I am child process, pid: %d, ppid: %d\n", getpid(), getppid());
sleep(1);
}
}
else
{
//parent
while(1)
{
printf("I am parent proceass, pid: %d, ppid: %d\n", getpid(), getppid()); sleep(1);
}
}
return 0;
}
最开始代码跑起来时,父进程pid=8644,bash=5238;子进程的pid=8645,子进程的父进程8644;他们的运行状态都是S状态–因为在打印就会访问I/O;
当我们销毁子进程时,kill -9 8645;我们发现子打印进程不在了,但是子进程的状态还在,变成了Z状态,这个时候就只能等父进程退出,让操作系统进行回收。
当我们杀掉父进程时,子进程被操作系统领养了,这个过程就叫做孤儿进程
当整个进程变成孤儿了,我们发现我们用Ctrl + c 是不能退出的;我们细心就会发现最开始子进程是S+当变成孤儿进程了,它的状态就是S了。说明了该程序变成了后台程序。
那么这个时候我们就只有用kill -9 16866,杀掉子进程了
进程优先级
基本概念
cpu资源分配的先后顺序,就是指进程的优先权(priority)。
优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用,可以改善系统性能。 还可以把进程运行到指定的CPU上,这样一来,把不重要的进程安排到某个CPU,可以大大改善系统整体性能。
查看系统进程
在linux或者unix系统中,用ps –l命令则会类似输出以下几个内容:
我们很容易注意到其中的几个重要信息,有下:
UID : 代表执行者的身份
PID : 代表这个进程的代号
PPID :代表这个进程是由哪个进程发展衍生而来的,亦即父进程的代号
PRI :代表这个进程可被执行的优先级,其值越小越早被执行
NI :代表这个进程的nice值
PRI and NI
PRI也还是比较好理解的,即进程的优先级,或者通俗点说就是程序被CPU执行的先后顺序,此值越小进程的优先级别越高
那NI呢?就是我们所要说的nice值了,其表示进程可被执行的优先级的修正数值
PRI值越小越快被执行,那么加入nice值后,将会使得PRI变为:PRI(new)=PRI(old)+nice
这样,当nice值为负值的时候,那么该程序将会优先级值将变小,即其优先级会变高,则其越快被执行 所以,调整进程优先级,在Linux下,就是调整进程nice值
nice其取值范围是-20至19,一共40个级别
用top命令更改已存在进程的nice:
top
1.非root用户:sudo top 进入top
2.在top中按r
3.输入进程pid
4.输入nice值
这里是输入nice值为100,我们发现最大区间是99 -19
这里是输入nice值为-100,所以我们发现最小大区间是60-20
经过上面两个例子,我们就发现其实我们只能改变范围是-20至19,一共40个级别
我们再观察一个场景,当我们把nice值改9的时候,我们发现值变成89,那么就得出结论:每次改nice值都在默认nice值的基础上进行改动,而不是修改之后。
其他概念
竞争性: 系统进程数目众多,而CPU资源只有少量,甚至1个,所以进程之间是具有竞争属性的。为了高 效完成任务,更合理竞争相关资源,便具有了优先级 独立性: 多进程运行,需要独享各种资源,多进程运行期间互不干扰 并行: 多个进程在多个CPU下分别,同时进行运行,这称之为并行 并发: 多个进程在一个CPU下采用进程切换的方式,在一段时间之内,让多个进程都得以推进,称之为 并发
进程切换
测试代码
#include <stdio.h>
int main()
{
int a=10;
int b=10;
int c=b+a;
printf("%d\n",c);
a=20;
b=30;
c=b+a;
printf("%d\n",c);
return 0;
}
我们从该代码中不难看出,a,b,c都是临时变量,在以前c语言也知道,他们的数据都是存放在寄存器里的,这里我们发现寄存器里的数据是可以发生改变的。这里我们进入vs2013查看反汇编,数据都是加载到寄存器中的。
在这里有一个概念需要知道:CPU虽然只有一套寄存器,但是寄存器的数据是属于当前进程的。这里的寄存器其实更偏向于寄存器内的数据,而不是寄存器硬件。
在这个过程中运行的时候,占有CPU进程不是一直要占有到进程结束!因为CPU虽然只有一套寄存器而且还要对其他进程进行处理,进程在运行的时候,都会有自己的时间片
操作系统会对每个进程进行设置一个时间片,让CPU去读取进程数据进行处理,就会有进入/退出–进程的切换。在这个切换的过程中寄存器数据需要被保护和恢复。
进程在切换的时候,要进行进程的上下文保护,当进程在恢复运行的时候,要进行上下文的恢复。
在任何时刻,CPU里面的寄存器里面的数据,看起来是在大家都能看到的寄存器上,但是,寄存器内的数据,只属于当前运行的进程!
寄存器被所有进程共享,寄存器内的数据,是每个进程各自私有的—上下文数据
环境变量
基本概念
环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数 如:我们在编写C/C++代码的时候,在链接的时候,从来不知道我们的所链接的动态静态库在哪里,但是照样可以链接成功,生成可执行程序,原因就是有相关环境变量帮助编译器进行查找。 环境变量通常具有某些特殊用途,还有在系统当中通常具有全局特性
常见环境变量
PATH : 指定命令的搜索路径
我们直接输入test我们发现,编译不起
我们将我们写的可执行程序放入usr/sbin路径中,需要注意的这个文件目录只有root用户可以进去
这种是不支持的,会污染指令池;
sudo rm /usr/bin/test.o —删除
一般情况下,我们是选择用
exprot PATH=$PATH:
我们发现使用exprot PATH=$PATH: test.o 的路径还是在11-19中
总结:
1.PATH就是系统默认的搜索路径
2.系统的指令能被找到就是因为环境变量PATH本来就默认带了系统对于的路径搜索
3.which底层实现就使用环境变量PATH来进行路径搜索
系统会默认将.bash_profile执行一次,将环境变量导到shell中,也就是说环境变量的配置也就是.bash_profile 再启动的时候加载到bash中
vim .bash_profile–进入.bash_profile
HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)
用root和普通用户,分别执行 echo $HOME ,对比差异 . 执行 cd ~; pwd ,对应 ~ 和 HOME 的关系
SHELL : 当前Shell,它的值通常是/bin/bash。
和环境变量相关的命令
echo: 显示某个环境变量值
export: 设置一个新的环境变量
env: 显示所有环境变量
unset: 清除环境变量
set: 显示本地定义的shell变量和环境变
USER
测试代码
#include<stdio.h>
#include <string.h>
#include <stdlib.h>
#define USER "USER"
int main()
{
char *who =getenv(USER);
if(strcmp(who,"root")==0)
{
printf("hello world\n");
printf("hello world\n");
printf("hello world\n");
printf("hello world\n");
}
else{
printf("权限不足");
}
return 0;
}
这里说明不同的环境变量运用的场景不同
echo- export
测试代码
#include<stdio.h>
#include <string.h>
#include <stdlib.h>
#define USER "USER"
#define MY_ENV "myval"
int main()
{
char *myenv=getenv(MY_ENV);
if(NULL==myenv)
{
printf("%s,not found\n",MY_ENV);
return 1;
}
printf("%s=%s\n", MY_ENV, myenv);
return 0;
}
我们自己定义一个变量,但是我们用echo 查看发现在当前文件能查看,但是用env去找不到。因为是这里相当于是定义的局部变量
本地变量只会在当前进程(bash)内有效
我们用export将本地变量导成环境变量
然后我们在运行test.o,我们发现myval可以被test.c引用
这里我们就得出结论:环境变量具有全局性,是会被子进程下去。
bash是一个系统进程,myval也是一个进程(fork),那么为了满足不同的场景,bash会帮助我们找指令路径,身份认证;
set
用set显示本地定义的shell变量和环境变
unset
env
其他相关指令
通过代码如何获取环境变量
命令行前两个参数
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#define USER "USER"
#define MY_ENV "myval"
#define MYPWD "PWD"
int main(int argc, char *argv[])
{
if(argc != 2)
{
printf("Usage: \n\t%s [-a/-b/-c/-ab/-bc/-ac/-abc]\n", argv[0]);
return 1;
}
if(strcmp("-a", argv[1]) == 0)
{
printf("功能a\n");
}
if(strcmp("-b", argv[1]) == 0)
{
printf("功能b\n");
}
if(strcmp("-c", argv[1]) == 0)
{
printf("功能c\n");
}
if(strcmp("-ab", argv[1]) == 0)
{
printf("功能ab\n");
}
if(strcmp("-bc", argv[1]) == 0)
{
printf("功能bc\n");
}
return 0;
}
就好比同一个程序,有多个选项控制
命令行第三个参数
libc中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时 要用extern声明。
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#define USER "USER"
#define MY_ENV "myval"
#define MYPWD "PWD"
int main(int argc, char *argv[],char *env[] )
{
extern char **environ;
int i=0;
for ( i = 0; environ[i]; i++)
{
printf("%d:%s\n", i, environ[i]);
}
return 0;
}
getenv
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("%s\n", getenv("PATH"));
return 0;
}
在这个三个获取环境变量的方式:getenv,char*env,extren char **environ中一般推荐使用getenv;因为一般情况我们不需要把全部变量都获取,都是按照自己的需求来。
总结:
在操作系统中用来指定操作系统运行环境的一些参数,我们在启动系统的时候bash就会自动更新该数据,相应的环境变量都有相应的应用场景,一些简单的指令其实就是函数调用环境变量。
程序地址空间
用段代码感受父子进程地址
进程之间是相互独立,都有自己的pdb
测试代码
#include <stdio.h>
#include <unistd.h>
int global_value = 100;
int main()
{
pid_t id = fork();
if(id < 0)
{
printf("fork error\n");
return 1;
}
else if(id == 0)
{
int cnt = 0;
while(1)
{
printf("我是子进程, pid: %d, ppid: %d | global_value: %d, &global_value: %p\n", getpid(), getppid(), global_value, &global_value);
sleep(1);
cnt++;
if(cnt == 10)
{
global_value = 300;
printf("子进程已经更改了全局的变量啦..........\n");
}
}
}
else
{
while(1)
{
printf("我是父进程, pid: %d, ppid: %d | global_value: %d, &global_value: %p\n", getpid(), getppid(), global_value, &global_value);
sleep(2);
}
}
}
else
{
while(1)
{
printf("我是父进程, pid: %d, ppid: %d | global_value: %d, &global_value: %p\n", getpid(), getppid(), global_value, &global_value);
sleep(2);
}
}
sleep(1);
}
运行这段代码后, 我们发现运行一段时间后,子进程和父进程的地址是一样的,但是他们global_value值却发生了改变,这个是为什么呢?
这里我需要想一下,这里地址没变,那么这个地址是什么?如果是物理地址父子进程的必须是一样,不然硬件是无法执行。那么这里就很显然就不是物理地址,就是我们提到的程序地址空间
为了解决父子进程地址一样,值不一样的现象,我们必须将程序地址空间搞清楚
感性理解程序地址空间
每个进程都会认为自己是操作系统的第一把手,只要操作系统批准自己随时都可以独占整个系统资源,又因为进程是独立,每个进程也不会知道自己会有其他进程,但是实际上是有多个进程需要操作系统进行分配,进程是不知道系统资源的多少。为了满足进程独占这个系统资源的需求,操作系统就给进程给了一个虚拟的地址空间(好比花了一个饼)。如果这是进程想全部的系统资源,这个时候操作是老大,他说不,进程还有没有能力取代他。
尽管操作系统就给进程花了一个饼,但是后面操作系统会将这个饼实现,就好像一个公司老板给员工们构建一个蓝图,最后将它实现。老板在画饼之前,可能会需要想好:公司会有好多人,会挣好多钱,在什么时间上市。这个过程在计算机中我们称之为**描述,**描述我们就可以用数据结构,使用结构体进行描述:
struct 蓝图{
char *who;
vchar *when:
char *target;
char *money;//个岗位
}
那么操作系统对进程画的饼:是内核的一种数据结构:mm_struct
最全的Linux教程,Linux从入门到精通
======================
-
linux从入门到精通(第2版)
-
Linux系统移植
-
Linux驱动开发入门与实战
-
LINUX 系统移植 第2版
-
Linux开源网络全栈详解 从DPDK到OpenFlow
第一份《Linux从入门到精通》466页
====================
内容简介
====
本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷,并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本,循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘,内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件,供读者免费下载。
本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读,同时也非常适合准备从事Linux平台开发的各类人员。
需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论