linux查看进程端口号，进程idlinux操作系统

下面是小编精心整理的linux查看进程端口号，进程idlinux操作系统，本文共13篇，仅供参考，大家一起来看看吧。本文原稿由网友“西省”提供。

篇1：linux查看进程端口号，进程idlinux操作系统

1 netstat -nlp 查看占用端口号的服务

2 找到该端口号的进程

3 找到该进程id

4 kill它

如何查看进程的端口号？

netstat -lnp | grep exf

tcp  0  0 0.0.0.0:9101    0.0.0.0:*     LISTEN     5791/exfilter

注释：上面命令中的exfilter是进行名称.上面的9101就是监控的端口号，5791是进程的进程id。

如果进程没有像exfilter一样监控一个端口，如何查看进程的id？

ps aux | grep exfilter

root     5791 0.0 2.2 59184 11256 ?       Ss  02:11  0:00 ./exfilter/bin/exfilter -f default -d

root     5823 0.0 0.1 61220  732 pts/1   R+  02:23  0:00 grep exfilter

注释：第一行，第二列的5791就是进程id，

第一行的最后列出了启动时的命令和参数。

端口号查找对应进程的ID，操作进程

若已知端口号为15000，则对应查找命令为lsof -i | grep 15000

本机显示结果为：

host   3386 trinea   4u IPv4 16907     0t0 TCP *:15000 (LISTEN)

其中的3386 便为进程号，然后使用相应操作命令便可操纵进程，如kill

kill -9 3386

篇2：windows查看进程

在windows命令行窗口下执行：

看到了吗，端口被进程号为2448的进程占用，继续执行下面命令：

很清楚吧，thread占用了你的端口

篇3：wmiprvse.exe是什么进程_操作系统

wmiprvse.exe是什么进程_操作系统

进程名称/wmiprvse.exe

Microsoft Windows Management Instrumentation

描述/wmiprvse.exe

出品者： Microsoft

属于： Microsoft Windows Operating System

系统进程： 是

后台程序： 是

使用网络： 否

硬件相关： 否

常见错误： 未知N/A

内存使用： 未知N/A

安全等级 (0-5): 0

间谍软件： 否

Adware: 否

病毒： 否

木马： 否

Windows Management Instrumentation (WMI) is a component of the Microsoft Windows operating system that provides management information and control in an enterprise environment. By using industry standards, managers can use WMI to query and set information on desktop systems, applications, networks, and other enterprise components. Developers can use WMI to create event monitoring applications that alert users when important incidents occur.

In earlier versions of Windows, providers were loaded in-process with the Windows Management service (winmgmt.exe), running under the LocalSystem security account. Failure of a provider caused the entire WMI service to fail. The next request to WMI restarted the service.

Beginning with Windows XP, WMI resides in a shared service host with several other services. To avoid stopping all the services when a provider fails, providers are loaded into a separate host process named Wmiprvse.exe. Multiple instances of Wmiprvse.exe can run at the same time under different accounts: LocalSystem, NetworkService, or LocalService. The WMI core WinMgmt.exe is loaded into the shared Local Service host named Svchost.exe.

Note: wmiprvsw.exe is the Sasser worm!

Note: The wmiprvse.exe file is located in the C:WINDOWSSystem32WBEM folder. In other cases, wmiprvse.exe is a virus, spyware, trojan or worm! Check this with Security Task Manager.

Virus with same name:

W32/Sonebot-B - sophos.com

ntsd杀不死的进程(分大小写):WMIPRVSE.EXE

文件位置：

C:WINDOWSsystem32wbemwmiprvse.exe

C:WINDOWSsystem32dllcachewmiprvse.exe

以下是翻译：

Windows 管理仪器工作(WMI) 是Microsoft 的组分; Windows 提供管理信息和控制在企业环境里的操作系统。由使用业界标准, 经理能使用WMI 询问和设置信息关于桌面系统、应用、网络, 和其它企业组分。开发商可能使用WMI 创造事件机敏的用户的监视应用当重要事件发生。

在窗口的更加早期的版本, 提供者是被装载的在过程以窗口管理服务(WinMgmt.exe), 运行在LocalSystem 证券帐户之下。提供者的失败导致整个WMI 服务失败。下个请求对WMI 重新开始了服务。

开始从Windows XP, WMI 居住在一个共有的服务主人以几其它服务。避免停止所有服务当提供者失败, 提供者被装载入一个分开的主人过程被命名Wmiprvse.exe 。Wmiprvse.exe 多个事例可能同时运行在不同的帐户之下: LocalSystem 、NetworkService, 或LocalService 。WMI 核心WinMgmt.exe 被装载入共有的地方服务主人被命名Svchost.exe 。

注: wmiprvsw.exe 是Sasser 蠕虫!

注: wmiprvse.exe 文件寻找，正常的因该在C:WINDOWSSystem32Wbem 文件夹。如果在其它文件, wmiprvse.exe 就是病毒、spyware 、特洛伊人或蠕虫! 检查这与安全任务经理。

病毒处理

表现为不停调用wmiprvse.exe，或使wmiprvse.exe进程达到数十个。或许不是病毒，只是xp的系统问题。

解决方法如下

1。建议使用XDelBox删除以下文件(如果存在)： (使用说明：解压安装在系统盘区根目录，删除时一次过复制所有要删除文件的路径，在待删除文件列表里点击右键选择剪贴板导入不检查路径，导入后在要删除文件上点击右键，选择立刻重启删除，这个时候系统会重启并进入到XDelBox 启动菜单。不用自己选中。让XDelBox自己执行。删除完毕会再次重启进入正常系统。运行xdelbox前最好卸载所有可移动存储设备) C：WINDOWSsystem32driversKnlrun。sys C：WINDOWSsystem32driversEntech。sys

2。删除重启后使用SREng修复下面各项： 启动项目 -- 服务--驱动程序之如下项删除：(使用说明：SREng-启动项目-服务-驱动程序中“选中”隐藏已认证的微软项目“然后删除下面名称的驱动程序(选中有问题的驱动后，点”删除服务“，点”设置“按钮即可。注意弹出的窗口中要点”否NO“才是确认删除服务) knlrun/knlrun ENTECH/ENTECH

有2个wmiprvse。exe且占用很多CPU资源

这个一般不是病毒，wmiprvse。exe，一个好像是管理声卡的，你右键点我的电脑，再点管理里面的服务和应用程序―》服务，看是哪一个禁用掉就好了，或是看一下开机启动里面有没有，有就删掉，可以装360，或瑞星的卡卡等辅助你。

[wmiprvse.exe是什么进程_操作系统]

篇4：Linux操作系统如何杀死进程

在当今的社会，电脑越来越普及，我们应用电脑，可我们知道电脑是怎样工作的么?电脑中必不可少的就是操作系统，而Linux操作系统的发展非常迅速，有赶超微软的趋势。这里介绍Linux操作系统的知识，让你学好应用Linux操作系统。今天一讲Linux操作系统下杀死进程全权讲解，希望你记住Linux操作系统下杀死进程全权讲解。经过搜集和整理相关的Linux操作系统杀死进程的材料，在这里给大家推荐本篇文章，希望大家看后会有不少收获。

1. kill

作用：根据进程号杀死进程

用法： kill [信号代码] 进程ID

举例：

[root@localhost ~]# ps auxf |grep httpd

注意：kill -9 来强制终止退出

举例 [root@localhost ~]# ps aux |grep gaim

或者 [root@localhost ~]# pgrep -l gaim 5031 gaim

5031 gaim

[root@localhost ~]# kill -9 5031

特殊用法：

kill -STOP [pid]

发送SIGSTOP (17,19,23)停止一个进程，而并不Linux操作系统杀死进程。

kill -CONT [pid]

发送SIGCONT (19,18,25)重新开始一个停止的进程，

kill -KILL [pid]

发送SIGKILL (9)强迫进程立即停止，并且不实施清理操作。

kill -9 -1

终止你拥有的全部进程。

2. killall

作用：通过程序的名字，直接杀死所有进程

用法：killall 正在运行的程序名

举例：

[root@localhost beinan]# pgrep -l gaim 2979 gaim

[root@localhost beinan]# killall gaim

注意：该命令可以使用 -9 参数来强制杀死进程

3. pkill

作用：通过程序的名字，直接杀死所有进程

用法：#pkill 正在运行的程序名

举例：

[root@localhost beinan]# pgrep -l gaim 2979 gaim

[root@localhost beinan]# pkill gaim

篇5：linux 批量删除进程与查看进程详解linux操作系统

1. 在 LINUX 命令平台输入 1-2 个字符后按 Tab 键会自动补全后面的部分(前提是要有这个东西，例如在装了 tomcat 的前提下, 输入 tomcat 的 to 按 tab)。

2. ps 命令用于查看当前正在运行的进程。

grep 是搜索

例如： ps -ef | grep java

表示查看所有进程里 CMD 是 java 的进程信息

ps -aux | grep java

-aux 显示所有状态

ps

3. kill 命令用于终止进程

例如： kill -9 [PID]

-9 表示强迫进程立即停止

通常用 ps 查看进程 PID ，用 kill 命令终止进程

网上关于这两块的内容

4.批量删除进程

介绍两种方法。要kill的进程都有共同的字串。

代码如下复制代码[plain]

kill -9 `ps -ef |grep xxx|awk '{print $2}' `

kill -9后面的符号是Tab键上方那个。

如上就是kill -9 `列出进程，找到包含xxx的行，输出pid的列`

kill、ps、grep都是很常用的命令了。

awk的作用是输出某一列，{print $2}就是输出第二列，如上即是pid这一列。这里有一篇awk的教程

代码如下复制代码[plain]

ps -ef | grep xxx | grep -v root | awk '{print $2}' | xargs kill -9

grep -v这个参数的作用是排除某个字符。所以这里排除了root执行的命令。

之后也利用awk找到pid这一列。

最后的xargs是从标准输出获取参数并执行命令的程序，即从前面的命令获取输出作为参数来执行下一个命令。

5.清理僵尸进程

例

今天在维护服务器的时候，发现有5个nova-novncproxy的僵尸进程。

?

26327 ?       S     0:05 _ /usr/bin/python /usr/bin/nova-novncproxy --config-file=/etc/nova/nova.conf

4765 ?       Z     0:00     _ [nova-novncproxy]

4766 ?       Z     0:00     _ [nova-novncproxy]

4767 ?       Z     0:00     _ [nova-novncproxy]

4768 ?       Z     0:00     _ [nova-novncproxy]

4769 ?       Z     0:00     _ [nova-novncproxy]

一般僵尸进程很难直接kill掉，不过您可以kill僵尸爸爸，

父进程死后，僵尸进程成为”孤儿进程”，过继给1号进程init，init始终会负责清理僵尸进程．它产生的所有僵尸进程也跟着消失。

代码如下复制代码

ps -e -o ppid,stat | grep Z | cut -d” ” -f2 | xargs kill -9

或

kill -HUP `ps -A -ostat,ppid | grep -e ’^[Zz]‘ | awk ’{print $2}’`

当然您可以自己编写更好的shell脚本，欢迎与大家分享。

我将nova-novncproxy stop后再start，僵尸进程即消失，问题解决。

另外子进程死后，会发送SIGCHLD信号给父进程，父进程收到此信号后，执行waitpid函数为子进程收尸。就是基于这样的原理：就算父进程没有调用wait，内核也会向它发送SIGCHLD消息，而此时，尽管对它的默认处理是忽略，如果想响应这个消息，可以设置一个处理函数。

6.如何避免僵尸进程呢？

处理SIGCHLD信号并不是必须的。但对于某些进程，特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束，子进程将成为僵尸进程（zombie）从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影响服务器进程的并发性能。在Linux下 可以简单地将 SIGCHLD信号的操作设为SIG_IGN。

signal(SIGCHLD,SIG_IGN);

这样，内核在子进程结束时不会产生僵尸进程。这一点与BSD4不同，BSD4下必须显式等待子进程结束才能释放僵尸进程

或者

用两次fork()，而且使紧跟的子进程直接退出，是的孙子进程成为孤儿进程，从而init进程将负责清除这个孤儿进程。

篇6：什么是进程，如何查看进程网络技巧

什么是进程？

进程是程序在计算机上的一次执行活动，当运行一个程序，就启动了一个进程。显然，程序是死的(静态的)，进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程，就是处于运行状态下的操作系统本身;用户进程就是所有启动的进程。进程是操作系统进行资源分配的单位。

如何查看进程？

可以通过快捷键Ctrl+alt+del打开任务管理器来查看进程标签，

也可以在任务栏的空白处点击鼠标右键选择“任务管理器”并查看其中的进程标签。

危害较大的可执行病毒同样以“进程”形式出现在系统内部(一些病毒可能并不被进程列表显示，如“宏病毒”)，那么及时查看并准确杀掉非法进程对于手工杀毒有起着关键性的作用。

因此，学会查看和管理进程，对系统的稳定以及安全都有极其深刻的意义。

什么是系统进程？

在系统当前运行的进程里包括：系统管理计算机个体和完成各种操作所必需的进程;用户开启、执行的额外程序进程，当然也包括用户不知道，而自动运行的非法进程(它们就有可能是病毒程序)。 在这些进程里面，有些进程是系统运行所必须调用的进程称之为关键进程。了解了哪些是关键进程后，有助于找出分辨“黑白”查杀病毒。

篇7：linux查看并终止进程

1,查看端口被那个进程占用

例如： netstat -anp | grep 1160

ps:查看端口1169被那个进程占用，

2，查找进程

例如 ：ps -ef | grep 'tomcat'

ps：查找出进程名里含有 tomcat的进程

3，终止进程

一般终止进程的方法是如：

kill 8080

ps:终止进程号为8080的进程

如果上面的命令终止不了进程可以使用 killall命令进程终止

如：killall -KILL 8080

ps:强制终止进程号为8080的进程

篇8：Windows netstat查看端口、进程占用

目标：在Windows环境下，用netstat命令查看某个端口号是否占用，为哪个进程所占用.

操作：操作分为两步：（1）查看该端口被那个PID所占用;方法一：有针对性的查看端口，使用命令

Netstat –ano|findstr “<端口号>”,如图，最后一列为PID，

Windows netstat查看端口、进程占用

。图中的端口号为1068，所对应的PID为3840。

(a)图

方法二：查看所有的，然后找到对应的端口和PID。

(b)图

第一幅图中的5列就是上面(a)图对应的5列

（2）查看该PID对应的进程名称。

方法一：一直用命令查找，tasklist|findstr “

”

(c)图

从 (c)图 可以看出，PID为3840所对应的进程名字为msnmsgr.exe。

方法二：用任务管理器查看。

调出任务管理器，选择列，如d图。

(d)图

查看PID对应的进程名称。如(e)图中的msnmsgr.exe

(e)图

附录：在命令行中输入netstat /? 可以查看netstat的相关信息。

C:\\Documents and Settings\\Administrator>netstat /?

显示协议统计信息和当前 TCP/IP 网络连接。

NETSTAT [-a] [-b] [-e] [-n] [-o] [-p proto] [-r] [-s] [-t] [-v] [interval]

-a 显示所有连接和监听端口。

-b 显示包含于创建每个连接或监听端口的

可执行组件，

在某些情况下已知可执行组件

拥有多个独立组件，并且在这些情况下

包含于创建连接或监听端口的组件序列

被显示。这种情况下，可执行组件名

在底部的 [] 中，顶部是其调用的组件，

等等，直到 TCP/IP 部分。注意此选项

可能需要很长时间，如果没有足够权限

可能失败。

-e 显示以太网统计信息。此选项可以与 -s

选项组合使用。

-n 以数字形式显示地址和端口号。

-o 显示与每个连接相关的所属进程 ID。

-p proto 显示 proto 指定的协议的连接；proto 可以是

下列协议之一: TCP、UDP、TCPv6 或 UDPv6。

如果与 -s 选项一起使用以显示按协议统计信息，proto 可以是下列协议之一:

IP、IPv6、ICMP、ICMPv6、TCP、TCPv6、UDP 或 UDPv6。

-r 显示路由表。

-s 显示按协议统计信息。默认地，显示 IP、

IPv6、ICMP、ICMPv6、TCP、TCPv6、UDP 和 UDPv6 的统计信息；

-p 选项用于指定默认情况的子集。

-t 显示当前连接卸载状态。

-v 与 -b 选项一起使用时将显示包含于

为所有可执行组件创建连接或监听端口的

组件。

interval 重新显示选定统计信息，每次显示之间

暂停时间间隔(以秒计)。按 CTRL+C 停止重新

显示统计信息。如果省略，netstat 显示当前

配置信息(只显示一次)

篇9：Linux常用的进程管理和查看指令

&背景工作做符

ctrl+ z 暂停

ctrl + c 停止

jobs [-l(list) , r(running jobs) ,-s(stop jobs)] 观察背景工作的状态

fg %jobnumber 将背景工作拿到前景执行

bg %jobnumber 让工作在背景的状态变成运作中(被ctrl暂停在背景的工作)

=========================================================

kill -l ===>列出q能够使用的signal有哪些

常用的kill的signal

-1 重新读取一次参数的排位置文件(类似reload)

-2 与ctrl的的i一样

-9 立即强制停止一个工作( .filename.swap 文件会被遗在系统中)

-15 正常停止一个工作

kill signal PID或者[%jobnumber] (给该进程发送一天命令)

====================================

上面的求导背景中去的工作都是你登陆是派生出来的子孙进程,在退出登陆后劲不能继续执行了

脱机管理

如果工作需要很长时间,你不能直到它执行完才下机,可以用at来处理, at是将工作放置到系统背景下,而与终端机无关

====================

程序管理

找出最耗系统的程序

找出内存中又问题的程序

设置程序的优先级

程序的观察

ps 将某个时间点得进程运作情况获取下来

ps 不加-a 或者-A参数仅仅列出与自己相关的process信息

aux 观察系统中所有进程的数据

-A 所有process都显示出来 与-e一样

-a 不与terminal有关的所有程序

-u 有效使用者(effective user )的相关process

-l 列出叫详细的信息,包括pid

===============================================

[root@Sweety /]# ps -l

F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD

4 S 0 2685 2683 0 80 0 - 27117 wait pts/1 00:00:00 bash

4 S 0 3232 1 0 80 0 - 27050 wait pts/1 00:00:00 mysqld_safe

4 R 0 3647 2685 0 80 0 - 27033 - pts/1 00:00:00 ps

F : 代表这个程序的旗标(flag) ,说明这个程序的总结权限

4代表root

S: 代表程序的状态

R(Running)

S(sleep)

T(stop)

Z(Zombie)

C: 代表Cup的使用率

ADDR(address) : 是kernel function 指出程序在内存中的那个部分如果是running的程序,一般会显示 -

SZ (size) : 程序用掉的内存

WCHAN : 表示程序是否在运行中 - 表示正在运行

TIME+: 使用的cpu累加时间

CMD : 触发进程的命令

RSS : 进程占用固定内存的大小

=================================================

top: 动态观察程序的变化

-d 数字 动态更新的时间差

-b : 以批次的方式执行top(通常搭配重定向和-n使用)

-n : 与-b一起使用, 意义是需要执行几次top 输出的结果

-p 进程的pid : 观察指定pid的进程

top在执行过程中可以使用按键

? : 显示可以在top中输入的按键指令

P : 以cpu占用率排序(默认)

M: 以Memory的使用排序

N: 以pid来排序

T : 以该process占用的cpu积累时间排序

r : 给PID重新定一个nice值 (按下r 然后输入要修改的pid号码)

1 : 切换查看不同cpu的负载率

q : 离开

=====================================================

pstree

-u : 同时列出每个process的PID

-p : 同时列出每个process的所属账号

======================================================

priority 和nice

PRI值是有核心动态调整的用户无法直接调整PRI的值;如果用户想调整PRI 的值,就得透过nice的值,一般来说,PRI和NI 的相关性如下

PRI(new) = PRI(old) + nice(可以是-20~19之间)

不过,如果原本饿PRI得值是50 ,并不是我们给一个nice=5 就会让PRI变成55 ,因为PRI是系统动态决定的,nice的值可以影响PRI,但最终的PRI值仍是要经过系统分析后才决定的;(nice的值有正负 郑表示降低优先级,符表示增加优先级)

一般用户只可以调整自己的process的nice值,且只能调高nice的值

调整process的优先级就是调整process的nice值

如何调整某个程序的nice值

1一开始执行程序就给予一个特定的nice值: 用nice指令

nice -n 数值 命令(启动程序的命令)

-n 后面接一个数值 (-20~ 19)

2已经存在的进程的nice重新调整(或者top) : renice

renice 数值(需要调整到饿nice值) PID(调整的process的PID)

==========================================================

我们可以使用top观察到很多的系统资源和状态,还有其他的一些工具也可以查看系统资源

free [-m 以M为单位显示]

===========================================================

uname : 查看系统的核心相关信息

-a : all 所有

-s : 系统核心名(Linux)

-r : 核心版本 ( 2.6.32-358.el6.x86_64 )

-p : cpu类型 ( x86_64 )

-i : 硬件平台 (x86_64)

==========================================================

uptime : 观察系统启动时间与负载工作 (其实酒红色显示出top命令的第一行)

==========================================================

netstat : 追踪网络或插槽文件

-a : 所有

-t : 列出tcp网络封包的数据

-u : 列出UDP蒸包的数据

-l : 列出目前正在监听的服务

-p 显示PID

==========================================================

------第一部分----相关字段意义----------

proto : 网络封包协议 ,主要为tcp何udp

Recv-Q : 由非远程主机链接到此socket的复制的中bytes数

Send-Q : 非远程主机传送过来的acknowledged 总bytes数

Local Address : 本地端的IP:port情况

Foreign Adresses :远程主机的IP:Port情况

state : 联机状态 ,主要有建立(ESTABLISHED) 和监听(LISTEN)

/proc/* 代表的意义

进程都是在内存中的,而内存当中的数据有都是写到/proc/*这个目录下的,所以我们可以直接观察/proc这个目录当中的档案

==========================================================

fuser: 找出正在使用该档案的程序

有时候我们想知道一个程序在这次启动过程中到底开启了多少档案,可以利用fuser来擦看

example : fuser -uvm /proc ==>查看偶遇多少程序在进行/proc文件系统的存取

===========================================================

lsof : 列出被程序开启的档案文件名

===========================================================

pidof : 列出某个正在执行的程序的pid

pidof [-sx] program_name

-s : 仅列出一个PID而不是列出所有

-x : 同时列出program name 可能的PPID 那个程序的PID

篇10：操作系统实验报告+进程调度+作业调度等

操作系统实验报告+进程调度+作业调度等

操作系统实验报告

1、进程调度

2、作业调度

3、主存空间的分配与回收 4、文件系统

学生学院______计算机学院______ 专业班级____网络工程(3)班_____ 学 号______3107007062_____ 学生姓名________张菲__ _____ 指导教师_______胡欣如 _______

年 12 月 20 日

班_____ 姓名 张菲 协作者 无 教师评定_________________ 实验题目 进程调度

一、实验目的

用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

二、实验内容和要求

编写并调试一个模拟的进程调度程序，采用“简单时间片轮转法”调度算法对五个进程进行调度。

每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已运行时间、进程状态等等。

进程的到达时间及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪 W（Wait）、运行R（Run）两种状态之一。

就绪进程获得 CPU后都只能运行一个时间片。用运行时间加1来表示。

如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应分配时间片给就绪队列中排在该进程之后的进程，并将它插入就绪队列队尾。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。

重复以上过程，直到所要进程都完成为止。 三、实验主要仪器设备和材料

硬件环境：IBM-PC或兼容机 软件环境：C语言编程环境 四、实验原理及设计方案

1、进程调度算法：采用多级反馈队列调度算法。其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推。

2、实验步骤:

（1）按先来先服务算法将进程排成就绪队列。

（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。

（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插

入到下一个逻辑队列的队尾。

（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。 （5）重复步骤（2）、（3）、（4），直到就绪队列为空。

五、流程图

六、结果过程及截图 初始化队列

按Y键继续运行进程：

按Y键继续运行进程：

运行若干次后的状态：

添加新的进程：

七、所遇困难的解决以及心得体会

在这个多级反馈的实验中，我采取了用一条实际上的链表队列来模拟多个逻辑上的队列，通过维护几个链表的状态信息来找到每个进程运行完后应该插入的地方，还有一个标志位Fend用来表明新插入的队列的位置。虽然实验原理很简单，但是在编写代码的过程中遇到了不少的问题，在两个小时之内已经完成的大体代码的编写，但是之中存在不少的问题，导致了用了差不多四个小时的时间去调试才把它弄好，

这主要归咎于在开始设计代码的不太

合理，在后期使得代码结构有些混乱，使得调试更加的麻烦，以及对编程的不熟悉。通过这个实验不仅使我对进程的调度算法有了更深的认识，使得理论知识得到的实践，也使我的编程能力得到了进一步提高。 七、思考题

1、分析不同调度算法的调度策略，比较不同调度算法的优缺点，总结它们的适用范围。 答：动态有限权算法：动态优先权是指在创建进程时所创建的优先权，会随进程的推进或者等待时间的增加而改变，以便获得更好的调度性能。处理机为每个进程分配一定的时间片，在就绪队列中，优先权高的进程将优先获得处理机，进程在进去运行完响应的时间片后，如没完成，优先权减1，从新回到就绪队列等待分配处理机。

时间片的轮转法：系统将所有进程排成一个队列，按照先来先服务的原则，对队列首的进程进行处理，每个进程在用完自己的时间片后，从新回到队尾进行排队。每运行一次，进程的需要时间减1，直到就绪队列为空！ 八、源代码

#include #include

#include

#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0

#define TIME 2//时间片长度

typedef struct pcb{//进程管理块 char name[10];//进程名字 char state; //进程状态

int queue; int ntime; int rtime; int etime;

//进程所在的队列

//进程需要运行的时间

//进程已经运行的时间

//进程在本队列可运行的时间片

struct pcb *link;

}PCB;

PCB *ready = NULL, *pinsert = NULL, *pfend = NULL,*p =NULL; 位置的变量

int geti //使用户仅能输入整数 {

char ch; int i = 0; fflush(stdin); ch = getchar(); while(ch == '\\n'){

//就绪队列，进程插入

printf(

fflush(stdin); ch = getchar(); }

while(ch != '\\n'){

if(ch >'9' || ch

fflush(stdin); i = 0; ch = getchar();

}else{ i = i*10 + (ch - '0'); }

ch = getchar();

}

return i;

}

void findpos()//更新状态量 {

PCB *ps = pfend;

if(!ps || !ps ->link || (ps->link->queue - ps->queue) >1) pinsert = ps; else{ while (ps->link && ps ->link->queue != (pfend ->queue +2)) }

ps = ps->link; pinsert = ps;

}

void insert()//插入进程 {

if(!ready ){

ready = p;

pfend = p; pinsert = p;

}else if(ready ->queue == 1){//第一队列存在

p->link = pfend->link; pfend->link = p; pfend = p; findpos();

}

void input()/*建立进程控制块函数*/ {

int i,num;

printf(

for(i=0; i

p=getpch(PCB);

printf(

printf(

p->queue =1;

p->etime = TIME; p->link=NULL;

insert();/*调用insert函数*/ } else{ p->link = ready; ready = p; }

findpos();

}

void disp(PCB *pr)/*建立进程现实函数，用于显示当前进程*/ {

printf(

}

void check()/*建立进程查看函数*/

{

}

void sort()//调整进程队列

{

} if(!ready->link ||ready->queue link->queue) return; p = ready ->link; ready ->link = pinsert ->link; pinsert ->link = ready; pinsert = ready; ready = p; if (ready && ready ->queue == pinsert ->queue){ findpos(); } PCB *pr; printf(

void addnew()//添加新的进程

{

if(ready ->queue != 1){ (ready ->queue)++; ready->etime *= 2; ready ->state='w'; sort();/*调用sort函数*/ input(); } else{ input();

}

}

void destroy()/*建立进程撤销函数(进程运行结束，撤销进程)*/

{

}

void running()/*建立进程就绪函数(进程运行时间到，置就绪状态)*/

{

}

void main()

{

char ch; input(); while(ready != NULL) { printf(

}

ready ->state = 'R'; check(); running(); printf(

计算机 学院 网络工程 专业班_____ 姓名 张菲 协作者 无 教师评定_________________ 实验题目 作业调度

一、实验目的

本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。

二、实验内容和要求

1、编写并调度一个多道程序系统的作业调度模拟程序。

作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

三、实验主要仪器设备和材料

硬件环境：IBM-PC或兼容机

软件环境：C语言编程环境

四、实验原理及设计方案

采用多道程序设计方法的操作系统，在系统中要经常保留多个运行的作业，以提高系统效率。作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业，并为这些被选中的作业分配所需的系统资源。对被选中运行的作业必须按照它们各自的作业说明书规定的步骤进行控制。

采用先来先服务算法算法模拟设计作业调度程序。

（1）、作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可占用处理器运行。作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业的要求，那么，作业调度必须按一定的算法在这些作业中作出选择。先来先服务算法是按照作业进入输入井的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业时，那么顺序挑选后面的作业。

(2) 假定某系统可供用户使用的主存空间共100k，并有5台磁带机。

3)流程图:

五、结果过程及截图

读取文件jobs.txt来初始化主存，磁带机的个数，并打印出来。

初始时间是9:00：

按Y运行5分钟：

按Y运行5分钟：

按Y运行5分钟：

多次运行后最后状态：

六、所遇困难的解决以及心得体会

这个实验是花的时间最多的一个实验，第一次做的时候由于理解有些问题，所以做错了。之后重新做了一遍，收获还是很多的，遇到了很多的细节问题，例如像是时间化成浮点数和浮点数化成时间等一些问题，从中也暴露了自己的编程能力欠缺，之后要多多的写程序。

七、思考题

1、写出每种算法的调度策略，最后比较各种算法的优缺点。

答：先来先服务算法是根据作业的进入时间来排序,到达时间短的先运行，优点是实现简单，缺点是运行时间慢。

短作业优先算法是根椐作业的估计运行时间来排序，估计运行时间短的先运行，优点是运行时间快,缺点是实现起来比较复杂。

2、选择调度算法的依据是什么？

答：如果作业要求的速度不高，而且作业比较小型，那就最好用先来先服务算法。

如果作业要求的速度高，作业流程复杂，那就最好用短作业优先算法。

八、源代码

#include

#include

#include

#include

#define getjcb() (JCB*)malloc(sizeof(JCB))

typedef struct {//资源的总量

int memory; int tape;

}RESOURCE;

typedef struct JCB {//作业控制块

char username[20];//用户名

char jobname[10];//作业名

char state;//作业状态 char atime[5];//到达时间 float rtime;//运行时间 RESOURCE resource;//资源数量 struct JCB*link; }JCB;

RESOURCE source = {100,5};

JCB *pjcb =getjcb();//作业链表头

char nowtime[5];//现在时间,初始时间为9：00

FILE* ignore(FILE *fp)//忽略文件中的空白符

{

if(feof(fp)) return fp; char ch = fgetc(fp); while (!feof(fp) && (ch == ' '|| ch == ' ')){ ch = fgetc(fp); } //if(!feof(fp)) return fp; fseek(fp, -1, SEEK_CUR);

return fp;

}

FILE* findchar(FILE *fp,char c)//在文件中找到一个字符的位置(读取文件时用) {

if(feof(fp)) return fp; char ch = fgetc(fp); while (!feof(fp) && (ch != c)){ } ch = fgetc(fp); fseek(fp, -1, SEEK_CUR); return fp;

}

void destory()//释放链表所占的内存

{

JCB *p = pjcb->link; while(pjcb){ free(pjcb); pjcb = p; if(p) p = p->link;

}

}

float stof(char *time)//把时间转化为浮点型数

{

float h = 0, m = 0; int i = 0; while(time[i] != ':'){ h = h*10 + time[i] - '0'; } i++; while(time[i] != '\\0'){ m = m*10 + time[i] - '0'; } i++; i++;

return (h + m/60);

}

char* ftos(double ftime)//把浮点型数值转化为时间

{

}

float timesub(char *time1, char *time2)//两个时间相减，得到时间差

{

}

void print()//打印输出

{

JCB *p = pjcb->link; printf(

p->atime, p->rtime, p->resource.memory,p->resource.tape);

}

void sendsource()//为作业分配资源

{

JCB *p; p = pjcb->link; while(p){//为到达的作业调度 p = p->link; }

if(p->state == 'W' && source.memory - p->resource.memory >=0 && source.tape - p->resource.tape >=0){

} } p = p->link; p->state = 'R'; source.memory -= p->resource.memory; source.tape -= p->resource.tape; printf(

}

void init()//初始化，读取文件中的作业信息

{

FILE *fp; JCB *p= NULL,*q = pjcb ; if((fp = fopen(

} } fp = ignore(fp); p->rtime = 0;//不初始化则会发生错误，？？？？？ fscanf(fp,

int checkend() //检查是否所有的作业都已经运行完了

{

JCB *p = pjcb ->link; while(p){ if(p ->state != 'F'){ return 0; } p = p->link; } return 1;

}

void run()//运行作业

{

if(checkend()){//检查是否所有的作业都已经运行完了 printf(

}

} p = p->link; } p = pjcb ->link; while(p){//计算到达的作业 if( strcmp(nowtime, p->atime) ==0 && p->state == 'N'){ p->state = 'W'; printf(

int main()

{

char ch;

double time =9.00;

}

double step = float(5)/60+0.00001; ftos(9.0); init(); do{ run(); puts(

班_____ 姓名 张菲 协作者 无 教师评定_________________

实验题目 主存空间的分配和回收

一、实验目的

熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。

二、实验内容和要求

主存的分配和回收的实现是与主存储器的管理方式有关的。所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。

可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入，作业等待。随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的`。

实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。

三、实验主要仪器设备和材料

硬件环境：IBM-PC或兼容机

软件环境：VC++ 6.0

四、实验原理及设计方案

1、循环首次适应算法

在该算法中，把主存中所有空闲区按其物理地址递增的次序排列。在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到第一个能满足要求的空闲区，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区表或链中。

2、实验步骤

（1）初始化空闲分区；

（2）反复对现有的空闲分区进行进程创建和撤消，即内存分配和回收；

（3）退出。

3、流程图

五、结果过程及截图

初始化主存大小后的状态

按1后分配一块内存：

按1后分配一块内存：

按2释www.unjs.cOm/news/55B7D663B60055B5.html放内存：

六、所遇困难的解决以及心得体会

本实验我采取用一条链表同时表示空闲分区链和主存空间占用情况，因为主存总大小是固定的，把空闲分区链所表示的区域从总的内存里去除就是被占用的空间的大小，这个实验还是比较简单的，因此很快就完成了，通过它使我学习了主存空间的分配与回收，同时也让我意识到了在回收内存时的一些问题，使我对课本知识有了更进一步的理解。

七、思考题

1、内存的主要分配方式有哪些？回收时可能出现的什么情况？应怎样处理这些情况？ 答：有定分区分配和动态分区分配两种，回收时可能出现内存分区被切成若干在小不等小分

区，过小的分区浪费内存资源,这要求我们要用紧凑技术修整。

2、动态分区管理的常用内存分配算法有哪几种？比较它们各自的使用范围。

答：有首次适应算法、循环首次适应算法、最佳适应算法三种。

首次适应算法适用于小型作业,而且分配速度不怎么要求的作业，循环首次适应算法适用于一些大的作业，避免大作业长期得不到分配，最佳适应算法适应于对分配速度要求高，作业容量比较大的作业。

八、源代码

#include

#include

#include

#define getMEM() (MEM*)(malloc(sizeof(MEM)))

typedef struct Memory{//可用分区链表节点

int base;//基地址

int size;//大小

struct Memory *next;

}MEM;

MEM *pm = getMEM();//可用分区的链表头

MEM *temp;//

int SIZE;//总的内存的大小，由用户输入

int geti()//让用户只能输入正整数

{

char ch; int i = 0; fflush(stdin); ch = getchar(); while(ch == '\\n'){ printf(

}

bool check(MEM* pm, int base, int size){//检查用户输入的合法性

MEM *p = pm;

p = pm; while(p->next){ if(p->base + p->size next->base && p->next->base >= base

return true; + size){

} p= p ->next; } if(!p->next && p->base + p->size base + p->size = base + size)

} } return false;

bool release(MEM *pm, int base, int size){//释放内存空间

MEM *p = pm;

}

int allocMem(MEM *pm, int size){//分配内存空间

MEM *p = pm; int base; if(!check(pm, base ,size)){ } return false; while(p->next){ if(base + size next->base) break; p = p->next; } if(base == p->base + p->size){//低地址相邻 if(p ->next && p->next->base == base + size){//释放区上下都相邻 p->size += size + p->next->size; temp = p->next; p->next = p->next->next; free(temp); }else{//仅与地地址相邻 p->size += size; } }else if (p->next && p->next->base == base +size){//仅高地址相邻 p->next->base = base; p->next->size += size; }else{//释放区上下与空闲区都不相邻 } return true; temp = getMEM(); temp->size = size; temp->base = base; temp->next = p->next; p->next = temp;

} if(p->next->size >= size) break; p = p->next; if(!p->next) return -1;

if(p->next->size == size){//空闲分区大小刚好等于所需分区

base = p->next->base;

p->next = p->next->next;

}else{

p->next->size -= size;

base = p->next->base;

p->next->base += size;

}

return base;

}

void print(MEM *pm){//打印空闲分区表和空闲分区链

MEM *p = pm->next;

puts(

puts(

while(p){

printf(

p = p->next;

}

puts(

puts(

p = pm;

while(p->next){

printf(

}

if(p->base + p->size

printf(

}

void init(){//初始化总内存大小和空闲分区链的头结点

pm->base = 0;

pm->size = 0;

pm->next = getMEM();

puts(

}

SIZE = geti(); pm->next->size = SIZE; pm->next->base = 0; pm->next->next =NULL;

int main()

{

}

int size = 0,base = 0; int ch; init(); print(pm); while(1){ puts(

班_____ 姓名 张菲 协作者 无 教师评定_________________ 实验题目 文件系统

一、实验目的

模拟文件系统实现的基本功能,了解文件系统的基本结构和文件的各种管理方法,加深理解文件系统的内部功能及内部实现。通过用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。

二、实验内容和要求

编程模拟一个简单的文件系统，实现文件系统的管理和控制功能。要求本文件系统采用两级目录，即设置主文件目录[MFD]和用户文件目录[UED]。另外，为打开文件设置运行文件目录[AFD]。设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件，并对文件必须设置保护措施。在用户程序中通过使用文件系统提供的Create、open、read、write、close、delete等文件命令，对文件进行操作

三、实验主要仪器设备和材料

硬件环境：IBM-PC或兼容机

软件环境：C语言编程环境

四、实验原理及设计方案

1、实验原理

运用二级目录思想来模拟文件系统。

为每个用户建立一个单独的用户文件目录UFD。这些文件目录具有相似的结构，它由用户文件的文件块组成。此外，在系统再建立一个主文件目录MFD；在主文件目录中，每个用户目录都占有一个目录项，其目录项中包含文件名和指向该文件目录文件的指针。

3、程序流程图

五、结果过程及截图

系统的使用简要说明：

登陆：

create命令新建文件

file5

Create失败

delete命令删除文件

Delete失败：

open打开命令，及write命令来追加文件

Read命令和close命令关闭

对没打开的文件读写：

六、所遇困难的解决以及心得体会

本实验的代码长度的最常的，但是原理很简单，并且实验要求的是模拟，所以大大降低了实验的难度，在操作系统课中我们还有一个课程设计，也是文件管理系统，但是要比这个难很多，通过这个实验，我对文件管理系统的运行机制有了深入的了解，因为要做好这个实验必须要懂得文件管理系统的架构，这也迫使我认认真真的研究了操作系统中关于文件管理这一章的内容。同时这个程序也为以后的课程设计奠定了基础，并且很多的代码也是可以重用的。

七、思考题

1、文件系统要解决哪些问题？

答：要解决文件和用户是否同名，文件创建数是否超额，所要求文件是否存在等问题。

2、什么是文件目录？什么是文件目录中包含哪些信息？目前广泛采用的目录结构形式是哪种？

答：文件目录就是用来展示一个用户的所有文件的一个表格，文件目录应包含文件名，保密码,文件大小，目前广泛采用的目录结构形式是多级目录形式。

八、源代码

#include

#include

#include

#include

#define NULL 0

typedef struct mdf{//MDF结构体

char username[20];//用户名 char filename[20];//文件名

struct mdf *next;

}MDF;

typedef struct ufd{//UFD结构体

char filename[20];//文件名

int protect;//文件保护码 unsigned int length;//文件长度

struct ufd *next;

}UFD;

typedef struct afd{//AFD结构体

char filename[20];//文件名 int protect;//文件保护码 unsigned int point;//文件读写指针

struct afd *next;

}AFD;

MDF *pmdf;//全局链表头指针

UFD *pufd;

AFD *pafd;

char UserUFD[20];//已经登陆成功的用户名

void initMDF()//初始化MDF表

{

FILE *fp; pmdf= (MDF*)malloc(sizeof(MDF)); MDF *p = pmdf; if((fp = fopen(

} exit(1); } while (!feof(fp)){//把MDF文件中的内容装入链表 } p->next = (MDF*)malloc(sizeof(MDF)); p = p->next; fscanf(fp,

void printUFD()//打印MDF表 {

UFD *p = pufd->next; puts(

}

void initUFD(char *name)//初始化UFD表 {

FILE *fp; pufd= (UFD*)malloc(sizeof(UFD)); UFD *p = pufd; if((fp = fopen(name,

} p->next = NULL; fclose(fp);

int checkuser()//检测登陆的用户名 {

} char username[20]; while(1){ puts(

void initAFD()//初始化AFD {

pafd = (AFD*)malloc(sizeof(AFD)); pafd->next = NULL; }

bool create()//创建文件命令 {

char filename[20]; UFD *p = pufd->next; AFD *pa = pafd; puts(

} } if(!p->next) break; p= p->next; p->next = (UFD*)malloc(sizeof(UFD)); p=p->next; strcpy(p->filename, filename); p->protect = 2; p->length = 0; p->next = NULL; while(pa->next){//创建文件后加入到AFD } pa=pa->next; pa->next = (AFD*)malloc(sizeof(AFD)); pa = pa->next; strcpy(pa->filename ,filename); pa->protect = 2; pa->point = 0; pa->next = NULL; return 1;

}

bool _delete()//删除文件命令 {

char filename[20]; puts(

puts(

return 0;

}

bool open()//打开文件命令

{

char filename[20]; unsigned int protect; puts(

} } puts(

void close()//关闭文件命令

{

char filename[20]; UFD *pu = pufd->next; puts(

int read()//读文件命令

{

char filename[20]; unsigned int length; AFD *p = pafd->next;

} puts(

int write()//写文件命令

{

}

char filename[20]; unsigned int length; AFD *p = pafd->next; puts(

void destroy()//释放内存

{

}

void saveUFD()//保存UFD文件

{

}

void bye()//推出系统

{ FILE *fp; UFD *p = pufd->next; if((fp = fopen(UserUFD,

UFD *pu = pufd->next; while(pa){ if(pa->protect == 2){ while(pu){ } saveUFD(); printUFD(); destroy(); } } if(strcmp(pa->filename, pu->filename) == 0){ } pu->length = pa->point; break; pu = pu->next; pa =pa->next;

}

void operate()//命令识别

{

while(1){ char command[20]; char name[][8] = {

}

} return; }else puts(

void print()

{

puts(

int main()

{

}

print(); initMDF(); checkuser(); initAFD(); operate();)//命令识别 return 0;

篇11：linux中利用shell脚本查看占用swap的进程linux操作系统

下面我们一起来看看关于linux中利用shell脚本查看占用swap的进程，希望此文章对各位同学会带来帮助，

查看进程在占用swap分区的脚本

命令脚本如下：

代码如下复制代码

for i in `cd /proc;ls |grep ”^[0-9]“|awk ' $0 >100'` ;do awk '/Swap:/{a=a+$2}END{print '”$i“',a/1024”M“}' /proc/$i/smaps ;done |sort -k2nr

查看占用swap的进程

代码如下复制代码

#!/bin/bash

echo -e `date +%y%m%d%H%M`

echo -e ”PIDttSwapttProc_Name“

# 拿出/proc目录下所有以数字为名的目录（进程名是数字才是进程，其他如sys,net等存放的是其他信息）

for pid in `ls -l /proc | grep ^d | awk '{ print $9 }'| grep -v [^0-9]`

do

# 让进程释放swap的方法只有一个：就是重启该进程。或者等其自动释放。放

# 如果进程会自动释放，那么我们就不会写脚本来找他了，找他都是因为他没有自动释放。

# 所以我们要列出占用swap并需要重启的进程，但是init这个进程是系统里所有进程的祖先进程

# 重启init进程意味着重启系统，这是万万不可以的，所以就不必检测他了，以免对系统造成影响。

if [ $pid -eq 1 ];then continue;fi

grep -q ”Swap“ /proc/$pid/smaps 2>/dev/null

if [ $? -eq 0 ];then

swap=$(grep Swap /proc/$pid/smaps

| gawk '{ sum+=$2;} END{ print sum }')

proc_name=$(ps aux | grep -w ”$pid“ | grep -v grep

| awk '{ for(i=11;i<=NF;i++){ printf(”%s “,$i); }}')

if [ $swap -gt 0 ];then

echo -e ”${pid}t${swap}t${proc_name}“

fi

fi

done | sort -k2 -n | awk -F't' '{

pid[NR]=$1;

size[NR]=$2;

name[NR]=$3;

}

END{

for(id=1;id<=length(pid);id++)

{

if(size[id]<1024)

printf(”%-10st%15sKBt%sn“,pid[id],size[id],name[id]);

else if(size[id]<1048576)

printf(”%-10st%15.2fMBt%sn“,pid[id],size[id]/1024,name[id]);

else

printf(”%-10st%15.2fGBt%sn“,pid[id],size[id]/1048576,name[id]);

}

}'

建议做定时任务监控swap空间使用情况

代码如下复制代码corntab -e

1 * * * * sh /root/swap.sh >>/root/swap/swap.log

曾经有一段时间机器的swap不停上涨,监控后发现是一些java进程占用swap空间后,完全不释放,杀死这些java进程后,释放swap

篇12：linux如何查看端口被哪个进程占用？

我们在使用linux系统的服务器时我们又时会突然发现发现服务器上某个端口起不来，老提示端口已经被占用。而对于这种情况我们该怎么解决呢？

使用命令：

ps -aux | grep tomcat

发现并没有8080端口的Tomcat进程。

使用命令：netstat Capn

查看所有的进程和端口使用情况。发现下面的进程列表，其中最后一栏是PID/Program name

发现8080端口被PID为9658的Java进程占用。

进一步使用命令：ps -aux | grep java，或者直接：ps -aux | grep pid 查看

就可以明确知道8080端口是被哪个程序占用了!然后判断是否使用KILL命令干掉!

方法二：直接使用

netstat -anp | grep portno

即：netstat Capn | grep 8080

方法三：

Linux:

cba001:~ # lsof -i:5300

COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME

named 26751 root 20u IPv4 64750499 TCP localhost:hacl-hb (LISTEN)

named 26751 root 21u IPv4 64750501 TCP cba001.eapac:hacl-hb (LISTEN)

named 26751 root 22u IPv4 64750503 TCP 192.168.0.10:hacl-hb (LISTEN)

named 26751 root 512u IPv4 64750498 UDP localhost:hacl-hb

named 26751 root 513u IPv4 64750500 UDP cba001.eapac:hacl-hb

named 26751 root 514u IPv4 64750502 UDP 192.168.0.10:hacl-hb

[注]:执行lsof -i:5300以后就可以看到26751进程在TCP和UDP上都打开了5300端口.

cba001:~ # ps -ef|grep 26751

root 10118 26915 0 12:59 pts/8 00:00:00 grep 26751

root 26751 1 0 Jul06 ? 00:02:06 /opt/ipworks/IPWdns/usr/bin/named

[注]:执行ps -ef|grep 26751以后就可以看到是named进程打开了5300端口

查看进程ID：

lsof -w -n -i tcp:8080

fuser -n tcp 8080netstat -anp|grep :8080[[:blank:]]

杀掉占用端口的进程PID：

kill -9 pidnumber

[linux如何查看端口被哪个进程占用？]

篇13：Shell 多进程扫描局域网IPlinux操作系统

这个脚本是利用shell多进程扫描局域网IP，扫描254个IP只要10秒，代码如下，希望例子对各位会带来帮助中。

#!/bin/bash

for i in $(seq 1 254)

do

IP=”192.168.12.$i“

ping $IP -c1 -s1 2>&1 1>/dev/null &&

echo -e $IP is ”33[32;49;1malive33[39;49;0m“ || echo -e $IP is ”33[31;49;1mdown33[39;49;0m\" &

done

wait

高分子材料科学的发展进程

加快农业机械化进程的探讨

aqadcup aqadcup.exe 进程信息

城市化进程与地球物理学研究

加快粮改市场化进程的思考

linux查看进程端口号，进程idlinux操作系统.doc

将本文的Word文档下载到电脑，方便收藏和打印

推荐度：

点击下载文档