2014-05-08 11:42:03 specialsun 阅读数 289
  • Linux系统编程、网络编程》第5章 进程控制

    课程内容: 进程与程序、进程PID与三个特殊进程、fork函数的作用、父子进程对文件的共享、execve加载函数、system函数、进程的资源回收、wait函数、进程状态、java进程、进程关系、守护进程,return/exit/_exit、环境变量表、环境变量API、C程序的内存空间布局、C库。

    319 人正在学习 去看看 张先凤

      Linux查询pid有多种方式,可通过遍历/proc目录下进程运行信息及shell ps命令

 

1. 遍历/proc目录

    Linux下每个运行的进程都会在/proc目录下建立该进程pid目录,/proc/pid 目录下有 status, cmdline等描述进程运行参数,状态等信息. 运行可能没有命令行参数,cmdline文件可能为空. 我们选择 status 文件,比较 status 中 Name 字段即可

    

// 根据进程名称查找pid
pid_t GetPidByName(const char *pName)
{
 DIR *pdir = NULL;
 struct dirent *pde = NULL;
 
 FILE *pf = NULL;
 char buff[128];
 pid_t pid;
 char szName[128];
 
 // 遍历/proc目录下所有pid目录
 pdir = opendir("/proc");
 if (!pdir)
 {
  perror("open /proc fail.\n");
  return -1;
 }
 
 while ((pde = readdir(pdir)))
 {
  if ((pde->d_name[0] < '0')|| (pde->d_name[0] > '9'))
  {
   continue;
  }
  
  // 读取 /proc/$pid/status文件
  sprintf(buff, "/proc/%s/status", pde->d_name);
  pf = fopen(buff, "r");
  if (pf)
  {
   fgets(buff,sizeof(buff),pf);
   fclose(pf);
   
   sscanf(buff,"%*s %s",szName); // 跳过Name:字段,获取进程名称
   pid=atoi(pde->d_name);
   
   if(strcmp(szName,pName)==0)
   {
    closedir(pdir);
    return pid;
   }
  }
 }
 
 closedir(pdir);
 return 0;
}

 

二. ps 命令

     进程名截断

 

    ps

    通过上述截图发现,如果进程名称过长,会被截断,这种情况下无法通过status匹配进程名称,而ps命令却完美解决上述问题,可以通过管道接收shell执行结果

    

int FindPidByName(const char *pName)
{
	int szPid=-1;

	char szProQuery[256];
	sprintf(szProQuery,"ps -ef|grep '%s'|grep -v 'grep'|awk '{print $2}'",pName);  // 打开管道,执行shell命令

	FILE *fp=popen(szProQuery,"r");
	char szBuff[10];

	while(fgets(szBuff,10,fp)!=NULL) // 逐行读取执行结果
	{
		szPid=atoi(szBuff);
		break;
	}

	pclose(fp); // 关闭管道指针,不是fclose()很容易混淆
	return szPid;
}

 

2020-02-05 19:46:05 kingfox 阅读数 54
  • Linux系统编程、网络编程》第5章 进程控制

    课程内容: 进程与程序、进程PID与三个特殊进程、fork函数的作用、父子进程对文件的共享、execve加载函数、system函数、进程的资源回收、wait函数、进程状态、java进程、进程关系、守护进程,return/exit/_exit、环境变量表、环境变量API、C程序的内存空间布局、C库。

    319 人正在学习 去看看 张先凤

Linux下的当前正在运行的进程信息均存放在/proc目录下,有一系列以数字为名的子目录,每一个子目录对应一个进程,子目录名就是进程的pid。子目录下的status文件内容就是进程的基本信息,包括进程名、pid、ppid等。因此,若要扫描系统当前正在运行的所有进程,只需要遍历/proc目录下所有以数字为名的子目录下的status即可。据此,可得到获取当前系统所有进程快照、根据pid获得进程名和根据进程名获得pid的程序,如下所示:

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

#define BUF_SIZE 1024
#define MAX_PROCESS_PATH 1024
#define PROC_NAME_FIELD ("name:")
#define PARENT_PID_FIELD ("ppid:")

#ifndef __cplusplus
typedef enum {false, true} bool;
#endif // __cplusplus

typedef struct __tagProcessEntry
{
   pid_t pid;
   pid_t ppid;
   char processName[MAX_PROCESS_PATH];
} ProcessEntry;

void string2lower(const char src[], char dest[])
{
   int length = strlen(src);
   int index;
   for(index = 0; index < length; index ++)
   {
      dest[index] = ((src[index] >= 'A') && (src[index] <= 'Z')) ? src[index] + 0x20 : src[index];
   }
   dest[length] = '\0';
}

int createProcessSnapshot(ProcessEntry pes[], int maxCount)
{
   int processCount = 0;
   DIR *dir;
   struct dirent *dirEntry;
   FILE *fp;
   char filePath[MAX_PROCESS_PATH];
   char fieldName[32];
   char fieldValue[MAX_PROCESS_PATH];
   char buf[BUF_SIZE];

   dir = opendir("/proc");
   if (NULL != dir)
   {
      while((dirEntry = readdir(dir)) != NULL) //循环读取路径下的每一个文件/文件夹
      {
         //如果读取到的是"."或者".."则跳过,读取到的不是文件夹名字也跳过
         if ((strcmp(dirEntry->d_name, ".") == 0) || (strcmp(dirEntry->d_name, "..") == 0) || (DT_DIR != dirEntry->d_type))
         {
            continue;
         }

         sprintf(filePath, "/proc/%s/status", dirEntry->d_name); //生成要读取的文件的路径
         fp = fopen(filePath, "r");
         if (NULL != fp)
         {
            do {
               if (fgets(buf, BUF_SIZE - 1, fp) == NULL)
               {
                  break;
               }
               sscanf(buf, "%s %s", fieldName, fieldValue);
               string2lower(fieldName, fieldName);
               if (strcmp(fieldName, PROC_NAME_FIELD) == 0)
               {
                  strcpy(pes[processCount].processName, fieldValue);
               }
               else if (strcmp(fieldName, PARENT_PID_FIELD) == 0)
               {
                  pes[processCount].ppid = atoi(fieldValue);
               }
            } while(!feof(fp));
            fclose(fp);

            pes[processCount].pid = atoi(dirEntry->d_name);
            processCount ++;
            if (processCount >= maxCount)
            {
               break;
            }
         }
      }
      closedir(dir);
   }
   return processCount;
}

int getPidByName(const char *procName, pid_t pids[], int maxCount)
{
   DIR *dir;
   struct dirent *dirEntry;
   FILE *fp;
   char filePath[MAX_PROCESS_PATH];
   char currProcName[MAX_PROCESS_PATH];
   char buf[BUF_SIZE];
   int pidCount = 0;

   dir = opendir("/proc");
   if (NULL != dir)
   {
      while((dirEntry = readdir(dir)) != NULL) //循环读取路径下的每一个文件/文件夹
      {
         //如果读取到的是"."或者".."则跳过,读取到的不是文件夹名字也跳过
         if ((strcmp(dirEntry->d_name, ".") == 0) || (strcmp(dirEntry->d_name, "..") == 0) || (DT_DIR != dirEntry->d_type))
         {
            continue;
         }

         sprintf(filePath, "/proc/%s/status", dirEntry->d_name); //生成要读取的文件的路径
         fp = fopen(filePath, "r"); //打开进程描述文件
         if (NULL != fp)
         {
            if (fgets(buf, BUF_SIZE - 1, fp) == NULL)
            {
               fclose(fp);
               continue;
            }
            sscanf(buf, "%*s %s", currProcName);

            if (strcmp(procName, currProcName) == 0)
            {
               pids[pidCount] = atoi(dirEntry->d_name);
               pidCount ++;
               if (pidCount >= maxCount)
               {
                  break;
               }
            }
            fclose(fp);
         }
      }
      closedir(dir);
   }
   return pidCount;
}

bool getNameByPid(pid_t pid, char procName[])
{
   char pidPath[BUF_SIZE];
   char buf[BUF_SIZE];
   bool success = false;

   sprintf(pidPath, "/proc/%d/status", pid);
   FILE *fp = fopen(pidPath, "r");
   if (NULL != fp)
   {
      if (fgets(buf, BUF_SIZE - 1, fp) != NULL)
      {
         sscanf(buf, "%*s %s", procName);
         success = true;
      }
      else
      {
         success = false;
      }
      fclose(fp);
   }

   return success;
}

int main(int argc, char **argv)
{
   char procName[MAX_PROCESS_PATH];
   pid_t pids[32];
   ProcessEntry pes[1024];

   pid_t currPid = getpid();
   printf("pid of this process:%d\n", currPid);
   getNameByPid(currPid, procName);
   printf("task name is %s\n", procName);
   strcpy(procName, "eclipse");
   int pidCount= getPidByName(procName, pids, sizeof pids / sizeof pids[0]);
   for(int index = 0; index < pidCount; index ++)
   {
      printf("pid of process %s: %d\n", procName, pids[index]);
   }

   int procCnt = createProcessSnapshot(pes, sizeof pes / sizeof pes[0]);
   printf("%d processes found.\n", procCnt);
   for(int index = 0; index < procCnt; index ++)
   {
      printf("proc: %-16s, pid: %6d, ppid: %6d.\n", pes[index].processName, pes[index].pid, pes[index].ppid);
   }

   return 0;
}

上述代码大部分源于网上材料,我在这里只是整理了一下,做为笔记。

2019-02-18 16:57:55 qq_38204718 阅读数 1135
  • Linux系统编程、网络编程》第5章 进程控制

    课程内容: 进程与程序、进程PID与三个特殊进程、fork函数的作用、父子进程对文件的共享、execve加载函数、system函数、进程的资源回收、wait函数、进程状态、java进程、进程关系、守护进程,return/exit/_exit、环境变量表、环境变量API、C程序的内存空间布局、C库。

    319 人正在学习 去看看 张先凤

方法一

#ps -ef |grep xxx  |awk '{print $1}'

e.g:

      ps -ef |grep java |awk '{print $1}'

注释:

      1、xxx为执行的命令名称

      2、举个例子,获取当前用户下的java进程 【pid】

           [admin@vm168a ~]$ ps -ef |grep java |awk '{print $1}'

           16920

      3、用到三个命令,ps、grep、awk。

 

方法二(推荐)

$pgrep xxx 

e.g:

pgrep java

原文:http://lionbule.iteye.com/blog/713585

统计java进程的数目:

proNo=`pgrep java | wc -l`

2019-09-04 16:31:34 weixin_39722409 阅读数 26
  • Linux系统编程、网络编程》第5章 进程控制

    课程内容: 进程与程序、进程PID与三个特殊进程、fork函数的作用、父子进程对文件的共享、execve加载函数、system函数、进程的资源回收、wait函数、进程状态、java进程、进程关系、守护进程,return/exit/_exit、环境变量表、环境变量API、C程序的内存空间布局、C库。

    319 人正在学习 去看看 张先凤

在 Linux 底下执行一个指令时,系统会给予这个动作一个 ID, 我们称为 PID,而根据启用这个指令的使用者与相关的指令功能,而给予这个特定 PID 一组权限, 该指令可以进行的行为则与这个 PID 的权限有关。

linux进程简介
Linux是一个多任务的操作系统,也就是说,在同一个时间内,可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话,会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令,那么Linux是如何实现多进程同时执行的呢?原来Linux使用了一种称为"进程调度(process scheduling)"的手段,首先,为每个进程指派一定的运行时间,这个时间通常很短,短到以毫秒为单位,然后依照某种规则,从众多进程中挑选一个投入运行,其他的进程暂时等待,当正在运行的那个进程时间耗尽,或执行完毕退出,或因某种原因暂停,Linux就会重新进行调度,挑选下一个进程投入运行。因为每个进程占用的时间片都很短,在我们使用者的角度来看,就好像多个进程同时运行一样了。
在Linux中,每个进程在创建时都会被分配一个数据结构,称为进程控制块(Process Control Block,简称PCB)。PCB中包含了很多重要的信息,供系统调度和进程本身执行使用,其中最重要的莫过于进程ID(process ID)了,进程ID也被称作进程标识符,是一个非负的整数,在Linux操作系统中唯一地标志一个进程,在我们最常使用的I386架构(即PC使用的架构)上,一个非负的整数的变化范围是0-32767,这也是我们所有可能取到的进程ID。其实从进程ID的名字就可以看出,它就是进程的身份证号码,每个人的身份证号码都不会相同,每个进程的进程ID也不会相同。
一个或多个进程可以合起来构成一个
进程组(process group)
一个或多个进程组可以合起来构成一个会话(session)。这样我们就有了对进程进行批量操作的能力,比如通过向某个进程组发送信号来实现向该组中的每个进程发送信号。
最后,让我们通过ps命令亲眼看一看自己的系统中目前有多少进程在运行:
$ps -aux(以下是在我的计算机上的运行结果,你的结果很可能与这不同。)
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.1 0.4 1412 520 ? S May15 0:04 init [3]
root 2 0.0 0.0 0 0 ? SW May15 0:00 [keventd]
root 3 0.0 0.0 0 0 ? SW May15 0:00 [kapm-idled]
root 4 0.0 0.0 0 0 ? SWN May15 0:00 [ksoftirqd_CPU0]
root 5 0.0 0.0 0 0 ? SW May15 0:00 [kswapd]
root 6 0.0 0.0 0 0 ? SW May15 0:00 [kreclaimd]
root 7 0.0 0.0 0 0 ? SW May15 0:00 [bdflush]
以上除标题外,每一行都代表一个进程。在各列中,PID一列代表了各进程的进程ID,COMMAND一列代表了进程的名称或在Shell中调用的命令行,对其他列的具体含义,我就不再作解释,有兴趣的读者可以去参考相关书籍。
getpid
在2.4.4版内核中,getpid是第20号系统调用,其在Linux函数库中的原型是:
#include<sys/types.h> /* 提供类型pid_t的定义 /
#include<unistd.h> /
提供函数的定义 /
pid_t getpid(void);
getpid的作用很简单,就是返回当前进程的进程ID,请大家看以下的例子:
/
getpid_test.c /
#include<unistd.h>
main()
{
printf("The current process ID is %d
“,getpid());
}
细心的读者可能注意到了,这个程序的定义里并没有包含头文件sys/types.h,这是因为我们在程序中没有用到pid_t类型,pid_t类型即为进程ID的类型。事实上,在i386架构上(就是我们一般PC计算机的架构),pid_t类型是和int类型完全兼容的,我们可以用处理整形数的方法去处理pid_t类型的数据,比如,用”%d"把它打印出来。
编译并运行程序getpid_test.c:
$gcc getpid_test.c -o getpid_test
$./getpid_test
The current process ID is 1980
(你自己的运行结果很可能与这个数字不一样,这是很正常的。)
再运行一遍:
$./getpid_test
The current process ID is 1981
正如我们所见,尽管是同一个应用程序,每一次运行的时候,所分配的进程标识符都不相同。
fork
在2.4.4版内核中,fork是第2号系统调用,其在Linux函数库中的原型是:
#include<sys/types.h> /
提供类型pid_t的定义 /
#include<unistd.h> /
提供函数的定义 /
pid_t fork(void);
只看fork的名字,可能难得有几个人可以猜到它是做什么用的。fork系统调用的作用是复制一个进程。当一个进程调用它,完成后就出现两个几乎一模一样的进程,我们也由此得到了一个新进程。据说fork的名字就是来源于这个与叉子的形状颇有几分相似的工作流程。
在Linux中,创造新进程的方法只有一个,就是我们正在介绍的fork。其他一些库函数,如system(),看起来似乎它们也能创建新的进程,如果能看一下它们的源码就会明白,它们实际上也在内部调用了fork。包括我们在命令行下运行应用程序,新的进程也是由shell调用fork制造出来的。fork有一些很有意思的特征,下面就让我们通过一个小程序来对它有更多的了解。
/
fork_test.c /
#include<sys/types.h>
#inlcude<unistd.h>
main()
{
pid_t pid;
/此时仅有一个进程/
pid=fork();
/此时已经有两个进程在同时运行/
if(pid<0)
printf(“error in fork!”);
else if(pid0)
printf("I am the child process, my process ID is %d
",getpid());
else
printf("I am the parent process, my process ID is %d
",getpid());
}
编译并运行:
$gcc fork_test.c -o fork_test
$./fork_test
I am the parent process, my process ID is 1991
I am the child process, my process ID is 1992
看这个程序的时候,头脑中必须首先了解一个概念:在语句pid=fork()之前,只有一个进程在执行这段代码,但在这条语句之后,就变成两个进程在执行了,这两个进程的代码部分完全相同,将要执行的下一条语句都是if(pid
0)…。
两个进程中,原先就存在的那个被称作"父进程",新出现的那个被称作"子进程"。父子进程的区别除了进程标志符(process ID)不同外,变量pid的值也不相同,pid存放的是fork的返回值。fork调用的一个奇妙之处就是它仅仅被调用一次,却能够返回两次,它可能有三种不同的返回值:
在父进程中,fork返回新创建子进程的进程ID;
在子进程中,fork返回0;
如果出现错误,fork返回一个负值;

fork出错可能有两种原因:
(1)当前的进程数已经达到了系统规定的上限,这时errno的值被设置为EAGAIN。(2)系统内存不足,这时errno的值被设置为ENOMEM。(关于errno的意义,请参考本系列的第一篇文章。)
fork系统调用出错的可能性很小,而且如果出错,一般都为第一种错误。如果出现第二种错误,说明系统已经没有可分配的内存,正处于崩溃的边缘,这种情况对Linux来说是很罕见的。
说到这里,聪明的读者可能已经完全看懂剩下的代码了,如果pid小于0,说明出现了错误;pid==0,就说明fork返回了0,也就说明当前进程是子进程,就去执行printf(“I am the child!”),否则(else),当前进程就是父进程,执行printf(“I am the parent!”)。完美主义者会觉得这很冗余,因为两个进程里都各有一条它们永远执行不到的语句。不必过于为此耿耿于怀,毕竟很多年以前,UNIX的鼻祖们在当时内存小得无法想象的计算机上就是这样写程序的,以我们如今的"海量"内存,完全可以把这几个字节的顾虑抛到九霄云外。
说到这里,可能有些读者还有疑问:如果fork后子进程和父进程几乎完全一样,而系统中产生新进程唯一的方法就是fork,那岂不是系统中所有的进程都要一模一样吗?那我们要执行新的应用程序时候怎么办呢?从对Linux系统的经验中,我们知道这种问题并不存在。至于采用了什么方法,我们把这个问题留到后面具体讨论。
exit
在2.4.4版内核中,exit是第1号调用,其在Linux函数库中的原型是:
#include<stdlib.h>
void exit(int status);
不像fork那么难理解,从exit的名字就能看出,这个系统调用是用来终止一个进程的。无论在程序中的什么位置,只要执行到exit系统调用,进程就会停止剩下的所有操作,清除包括PCB在内的各种数据结构,并终止本进程的运行。请看下面的程序:
/
exit_test1.c /
#include<stdlib.h>
main()
{
printf("this process will exit!
");
exit(0);
printf("never be displayed!
");
}
编译后运行:
$gcc exit_test1.c -o exit_test1
$./exit_test1
this process will exit!
我们可以看到,程序并没有打印后面的"never be displayed! ",因为在此之前,在执行到exit(0)时,进程就已经终止了。
exit系统调用带有一个整数类型的参数status,我们可以利用这个参数传递进程结束时的状态,比如说,该进程是正常结束的,还是出现某种意外而结束的,一般来说,0表示没有意外的正常结束;其他的数值表示出现了错误,进程非正常结束。我们在实际编程时,可以用wait系统调用接收子进程的返回值,从而针对不同的情况进行不同的处理。关于wait的详细情况,我们将在以后的篇幅中进行介绍。
exit和_exit
作为系统调用而言,_exit和exit是一对孪生兄弟,它们究竟相似到什么程度,我们可以从Linux的源码中找到答案:
#define __NR__exit __NR_exit /
摘自文件include/asm-i386/unistd.h第334行 /
“_NR"是在Linux的源码中为每个系统调用加上的前缀,请注意第一个exit前有2条下划线,第二个exit前只有1条下划线。
这时随便一个懂得C语言并且头脑清醒的人都会说,_exit和exit没有任何区别,但我们还要讲一下这两者之间的区别,这种区别主要体现在它们在函数库中的定义。_exit在Linux函数库中的原型是:
#include<unistd.h>
void _exit(int status);
和exit比较一下,exit()函数定义在stdlib.h中,而_exit()定义在unistd.h中,从名字上看,stdlib.h似乎比unistd.h高级一点,那么,它们之间到底有什么区别呢?让我们先来看流程图,通过下图,我们会对这两个系统调用的执行过程产生一个较为直观的认识。
从图中可以看出,_exit()函数的作用最为简单:直接使进程停止运行,清除其使用的内存空间,并销毁其在内核中的各种数据结构;exit()函数则在这些基础上作了一些包装,在执行退出之前加了若干道工序,也是因为这个原因,有些人认为exit已经不能算是纯粹的系统调用。
exit()函数与_exit()函数最大的区别就在于exit()函数在调用exit系统调用之前要检查文件的打开情况,把文件缓冲区中的内容写回文件,就是图中的"清理I/O缓冲"一项。
在Linux的标准函数库中,有一套称作"高级I/O"的函数,我们熟知的printf()、fopen()、fread()、fwrite()都在此列,它们也被称作"缓冲I/O(buffered I/O)”,其特征是对应每一个打开的文件,在内存中都有一片缓冲区,每次读文件时,会多读出若干条记录,这样下次读文件时就可以直接从内存的缓冲区中读取,每次写文件的时候,也仅仅是写入内存中的缓冲区,等满足了一定的条件(达到一定数量,或遇到特定字符,如换行符和文件结束符EOF),再将缓冲区中的内容一次性写入文件,这样就大大增加了文件读写的速度,但也为我们编程带来了一点点麻烦。如果有一些数据,我们认为已经写入了文件,实际上因为没有满足特定的条件,它们还只是保存在缓冲区内,这时我们用_exit()函数直接将进程关闭,缓冲区中的数据就会丢失,反之,如果想保证数据的完整性,就一定要使用exit()函数。
请看以下例程:
/
exit2.c /
#include<stdlib.h>
main()
{
printf("output begin
");
printf(“content in buffer”);
exit(0);
}
编译并运行:
$gcc exit2.c -o exit2
$./exit2
output begin
content in buffer
/
_exit1.c /
#include<unistd.h>
main()
{
printf("output begin
");
printf(“content in buffer”);
_exit(0);
}
编译并运行:
$gcc _exit1.c -o _exit1
$./_exit1
output begin
在Linux中,标准输入和标准输出都是作为文件处理的,虽然是一类特殊的文件,但从程序员的角度来看,它们和硬盘上存储数据的普通文件并没有任何区别。与所有其他文件一样,它们在打开后也有自己的缓冲区。
请读者结合前面的叙述,思考一下为什么这两个程序会得出不同的结果。相信如果您理解了我前面所讲的内容,会很容易的得出结论。
在这篇文章中,我们对Linux的进程管理作了初步的了解,并在此基础上学习了getpid、fork、exit和_exit四个系统调用。在下一篇文章中,我们将学习与Linux进程管理相关的其他系统调用,并将作一些更深入的探讨。
前面的文章中,我们已经了解了父进程和子进程的概念,并已经掌握了系统调用exit的用法,但可能很少有人意识到,在一个进程调用了exit之后,该进程并非马上就消失掉,而是留下一个称为僵尸进程(Zombie)的数据结构。在Linux进程的5种状态中,僵尸进程是非常特殊的一种,它已经放弃了几乎所有内存空间,没有任何可执行代码,也不能被调度,仅仅在进程列表中保留一个位置,记载该进程的退出状态等信息供其他进程收集,除此之外,僵尸进程不再占有任何内存空间。从这点来看,僵尸进程虽然有一个很酷的名字,但它的影响力远远抵不上那些真正的僵尸兄弟,真正的僵尸总能令人感到恐怖,而僵尸进程却除了留下一些供人凭吊的信息,对系统毫无作用。
也许读者们还对这个新概念比较好奇,那就让我们来看一眼Linux里的僵尸进程究竟长什么样子。
当一个进程已退出,但其父进程还没有调用系统调用wait(稍后介绍)对其进行收集之前的这段时间里,它会一直保持僵尸状态,利用这个特点,我们来写一个简单的小程序:
/
zombie.c /
#include
#include
main()
{
pid_t pid;
pid=fork();
if(pid<0) /
如果出错 /
printf(“error occurred!n”);
else if(pid==0) /
如果是子进程 /
exit(0);
else /
如果是父进程 /
sleep(60); /
休眠60秒,这段时间里,父进程什么也干不了 /
wait(NULL); /
收集僵尸进程 /
}
sleep的作用是让进程休眠指定的秒数,在这60秒内,子进程已经退出,而父进程正忙着睡觉,不可能对它进行收集,这样,我们就能保持子进程60秒的僵尸状态。
编译这个程序:
$ cc zombie.c -o zombie
后台运行程序,以使我们能够执行下一条命令:
$ ./zombie &
[1] 1577
列一下系统内的进程:
$ ps -ax
… …
1177 pts/0 S 0:00 -bash
1577 pts/0 S 0:00 ./zombie
1578 pts/0 Z 0:00 [zombie ]
1579 pts/0 R 0:00 ps -ax
看到中间的
*"Z"了吗?那就是僵尸进程的标志,它表示1578号进程现在就是一个僵尸进程。**
我们已经学习了系统调用exit,它的作用是使进程退出,但也仅仅限于将一个正常的进程变成一个僵尸进程,并不能将其完全销毁。僵尸进程虽然对其他进程几乎没有什么影响,不占用CPU时间,消耗的内存也几乎可以忽略不计,但有它在那里呆着,还是让人觉得心里很不舒服。而且Linux系统中进程数目是有限制的,在一些特殊的情况下,如果存在太多的僵尸进程,也会影响到新进程的产生。那么,我们该如何来消灭这些僵尸进程呢?
先来了解一下僵尸进程的来由,我们知道,Linux和UNIX总有着剪不断理还乱的亲缘关系,僵尸进程的概念也是从UNIX上继承来的,而UNIX的先驱们设计这个东西并非是因为闲来无聊想烦烦其他的程序员。僵尸进程中保存着很多对程序员和系统管理员非常重要的信息,首先,这个进程是怎么死亡的?是正常退出呢,还是出现了错误,还是被其它进程强迫退出的?其次,这个进程占用的总系统CPU时间和总用户CPU时间分别是多少?发生页错误的数目和收到信号的数目。这些信息都被存储在僵尸进程中,试想如果没有僵尸进程,进程一退出,所有与之相关的信息都立刻归于无形,而此时程序员或系统管理员需要用到,就只好干瞪眼了。
那么,我们如何收集这些信息,并终结这些僵尸进程呢?就要靠我们下面要讲到的waitpid调用和wait调用。这两者的作用都是收集僵尸进程留下的信息,同时使这个进程彻底消失。下面就对这两个调用分别作详细介绍。

2010-07-15 15:59:33 iteye_11019 阅读数 181
  • Linux系统编程、网络编程》第5章 进程控制

    课程内容: 进程与程序、进程PID与三个特殊进程、fork函数的作用、父子进程对文件的共享、execve加载函数、system函数、进程的资源回收、wait函数、进程状态、java进程、进程关系、守护进程,return/exit/_exit、环境变量表、环境变量API、C程序的内存空间布局、C库。

    319 人正在学习 去看看 张先凤

如果想在脚本里只获取PID,那么可以用如下脚本。目前收集两种方法:

 

方法一

$ps x|grep xxx  |awk '{print $1}'

 

e.g.

      ps x|grep java |awk '{print $1}'

注释:

      1、xxx为执行的命令名称

      2、举个例子,获取当前用户下的java进程 【pid】

           [admin@vm168a ~]$ ps x|grep java |awk '{print $1}'
           16920

      3、用到三个命令,ps、grep、awk。

 

方法二(推荐)

 

$pgrep xxx 

 

e.g.

     pgrep java

 

 

 

没有更多推荐了,返回首页