linux根据进程名获取pid_linux 已知进程pid获取父进程pid - CSDN
精华内容
参与话题
  • Linux下的当前正在运行的进程信息均存放在/proc目录下,有一系列以数字为的子目录,每一个子目录对应一个进程,子目录就是进程pid。...据此,可得到获取当前系统所有进程快照、根据pid获得进程名根据...

    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;
    }

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

    展开全文
  • 交互式 Bash Shell 获取进程 pid在已知进程名(name)的前提下,交互式 Shell 获取进程 pid 有很多种方法,典型的通过 grep 获取 pid 的方法为(这里添加 -v grep是为了避免匹配到 grep 进程):ps -...

    导读

    Linux 的交互式 Shell 与 Shell 脚本存在一定的差异,主要是由于后者存在一个独立的运行进程,因此在获取进程 pid 上二者也有所区别。

    交互式 Bash Shell 获取进程 pid

    在已知进程名(name)的前提下,交互式 Shell 获取进程 pid 有很多种方法,典型的通过 grep 获取 pid 的方法为(这里添加 -v grep是为了避免匹配到 grep 进程):

    ps -ef | grep "name" | grep -v grep | awk '{print $2}'
    • 1

    或者不使用 grep(这里名称首字母加[]的目的是为了避免匹配到 awk 自身的进程):

    ps -ef | awk '/[n]ame/{print $2}'
    • 1

    如果只使用 x 参数的话则 pid 应该位于第一位:

    ps x | awk '/[n]ame/{print $1}'
    • 1

    最简单的方法是使用 pgrep:

    pgrep -f name
    • 1

    如果需要查找到 pid 之后 kill 掉该进程,还可以使用 pkill:

    pkill -f name
    • 1

    如果是可执行程序的话,可以直接使用 pidof

    pidof name
    • 1

    Bash Shell 脚本获取进程 pid

    根据进程名获取进程 pid 
    在使用 Shell 脚本获取进程 pid 时,如果直接使用上述命令,会出现多个 pid 结果,例如

    #! /bin/bash
    # process-monitor.sh
    process=$1
    pid=$(ps x | grep $process | grep -v grep | awk '{print $1}')
    echo $pid
    • 1
    • 2
    • 3
    • 4
    • 5

    执行 process-monitor.sh 会出现多个结果:

    $> sh process-monitor.sh
    3036  3098  3099
    • 1
    • 2

    进一步排查可以发现,多出来的几个进程实际上是子 Shell 的(临时)进程:

    root      3036  2905  0 09:03 pts/1    00:00:45 /usr/java/jdk1.7.0_71/bin/java ...name
    root      4522  2905  0 16:12 pts/1    00:00:00 sh process-monitor.sh name
    root      4523  4522  0 16:12 pts/1    00:00:00 sh process-monitor.sh name
    • 1
    • 2
    • 3

    其中 3036 是需要查找的进程pid,而 4522、4523 就是子 Shell 的 pid。 为了避免这种情况,需要进一步明确查找条件,考虑到所要查找的是 Java 程序,就可以通过 Java 的关键字进行匹配:

    #! /bin/bash
    # process-monitor.sh
    process=$1
    pid=$(ps -ef | grep $process | grep '/bin/java' | grep -v grep | awk '{print $2}')
    echo $pid
    • 1
    • 2
    • 3
    • 4
    • 5

    获取 Shell 脚本自身进程 pid

    这里涉及两个指令: 
    1. $$ :当前 Shell 进程的 pid 
    2. 2. $! :上一个后台进程的 pid 可以使用这两个指令来获取相应的进程 pid。例如,如果需要获取某个正在执行的进程的 pid(并写入指定的文件):

    myCommand && pid=$!
    myCommand & echo $! >/path/to/pid.file
    • 1
    • 2

    注意,在脚本中执行 $! 只会显示子 Shell 的后台进程 pid,如果子 Shell 先前没有启动后台进程,则没有输出。

    查看指定进程是否存在

    在获取到 pid 之后,还可以根据 pid 查看对应的进程是否存在(运行),这个方法也可以用于 kill 指定的进程。

    if ps -p $PID > /dev/null
    then
       echo "$PID is running"
       # Do something knowing the pid exists, i.e. the process with $PID is running
    fi
    
    原文
    
    展开全文
  • linux有一个命令行工具叫做pidof,可以根据用户输入的进程名字查找到进程号,但有时候我们需要在程序里实现,不想调用system,在查阅了很多版本的pidof源代码后,没有发现一个自己感觉比较好的,所以就参照linux上的...

    linux有一个命令行工具叫做pidof,可以根据用户输入的进程名字查找到进程号,但有时候我们需要在程序里实现,不想调用system,在查阅了很多版本的pidof源代码后,没有发现一个自己感觉比较好的,所以就参照linux上的pidof的源代码,改写出了一版,供大家参考使用。

    /***************************************************************************
    * File name    :        findpidbyname.c
    * Function     :        like pidof
    * Author       :        zhangzhao@tass.com.cn
    * Date         :        2012/12/
    * Version      :             v1.0
    * Description  :           Find process's pid by name in linux.
    * ModifyRecord :
    ****************************************************************************/
    
    #include <stdio.h>
    #include <sys/types.h>
    #include <dirent.h>
    #include <stdlib.h>
    #include <string.h>
    
    int find_pid_by_name( char* ProcName, int* foundpid)
    {
            DIR             *dir;
            struct dirent   *d;
            int             pid, i;
            char            *s;
            int pnlen;
    
            i = 0;
            foundpid[0] = 0;
            pnlen = strlen(ProcName);
    
            /* Open the /proc directory. */
            dir = opendir("/proc");
            if (!dir)
            {
                    printf("cannot open /proc");
                    return -1;
            }
    
            /* Walk through the directory. */
            while ((d = readdir(dir)) != NULL) {
    
                    char exe [PATH_MAX+1];
                    char path[PATH_MAX+1];
                    int len;
                    int namelen;
    
                    /* See if this is a process */
                    if ((pid = atoi(d->d_name)) == 0)       continue;
    
                    snprintf(exe, sizeof(exe), "/proc/%s/exe", d->d_name);
                    if ((len = readlink(exe, path, PATH_MAX)) < 0)
                            continue;
                    path[len] = '\0';
    
                    /* Find ProcName */
                    s = strrchr(path, '/');
                    if(s == NULL) continue;
                    s++;
    
                    /* we don't need small name len */
                    namelen = strlen(s);
                    if(namelen < pnlen)     continue;
    
                    if(!strncmp(ProcName, s, pnlen)) {
                            /* to avoid subname like search proc tao but proc taolinke matched */
                            if(s[pnlen] == ' ' || s[pnlen] == '\0') {
                                    foundpid[i] = pid;
                                    i++;
                            }
                    }
            }
    
            foundpid[i] = 0;
            closedir(dir);
    
            return  0;
    
    }
    
    
    int main(int argc, char *argv[])
    {
            int i, rv, pid_t[128];
            if ( argc != 2 )
            {
                    fprintf(stdout,"Usage %s procname\n",argv[0]);
                    return 0;
            }
    
            rv = find_pid_by_name( argv[1], pid_t);
            if(!rv) {
                    for(i=0; pid_t[i] != 0; i++)
                            printf("%d\n", pid_t[i]);
            }
    
            return 0;
    }
    



    展开全文
  • #!/bin/bash #arr_name=(1 3 4 5 7) #echo ${arr_name[@]} #PROCESS="java" ...PID=$(ps -A |grep "java"| awk '{print $1}') cat /proc/$PID/status | grep RSS > /home/men47.txt MEN=$(awk '/
    #!/bin/bash

    PID=$(ps -A |grep "java"| awk '{print $1}')

    if (( PID < 1 ))

    then

    /etc/init.d/elasticsearch restart

    fi


    cat /proc/$PID/status | grep RSS > /home/me.txt
    MEN=$(awk '/[0-9]/{print $2}' /home/me.txt)


    if (( $MEN > 13631588 ))
    then

    #echo $MEN

    /etc/init.d/elasticsearch restart

    fi
    展开全文
  • Linux根据进程名称获取pid的方法

    千次阅读 2019-11-21 20:07:44
    以下通过两种方法来根据进程名称获取pid 方法一 最简单的方法是使用 pidof命令 用法:pidof process_name 示例 官网的详细用法如下: NAME pidof -- find the process ID of a running program. ...
  • 在我的另外一个篇博客【Linux下C语言开发(信号signal处理机制)】中需要测试系统调用kill来向指定进行号发送指定的信号,在同一个测试文件很容易获取当前进程pid,只需调用getpid()函数就可获取当前进程pid。...
  • linux有一个命令行工具叫做pidof,可以根据用户输入的进程名字查找到进程号,但有时候我们需要在程序里实现,不想调用system,在查阅了很多版本的pidof源代码后,没有发现一个自己感觉比较好的,所以就参照linux上的...
  • 一、获取进程pid 相关函数:fork, kill, getpid 头文件:#include 定义函数:pid_t getpid(void); 函数说明:getpid ()用来取得目前进程进程识别码,许多程序利用取到的此值来建立临时文件, 以...
  • 根据PID获取进程名&根据进程名获取PID Liunx中 通过进程名查找进程PID可以通过 pidof [进程名] 来查找。反过来 ,相同通过PID查找进程名则没有相关命令。 在linux根目录中,有一个/proc的VFS(虚拟文件系统),...
  • #include &lt;stdio.h&gt;#include &lt;sys/types.h&gt;#include &lt;dirent.h&gt;#include &... int find_pid_by_name( char* ProcName, int* foundpid){ DIR ...
  • linux根据进程名字获取进程进程PID,类似pidof,C函数 linux有一个命令行工具叫做pidof,可以根据用户输入的进程名字查找到进程号,但有时候我们需要在程序里实现,不想调用system,在查阅了很多版本的pidof...
  • 最近需要实现一个功能,即在一个Linux C程序中,已知其他进程的名字,需要获得该进程PID,经过一番上网搜索,找到两种可行的方法: 1.通过popen创建一个管道,执行shell命令并得到返回结果 2.通过搜索/proc...
  • linux根据进程名字获取进程ID

    千次阅读 2014-11-07 16:59:41
    一、前言:要在程序中启动某一程序,如果程序已经存在了,就不再启动。查找了N篇文档,有所收获,总结一下。 二、实现 大体分两种: 1、exec或popen执行ps的命令行,然后运用某几个字符串匹配函数。...
  • ps aux | grep "common" |grep -v grep| cut -c 9-15
  • linux 根据进程ID获取对应进程的信息

    千次阅读 2015-12-15 15:55:57
    linux 根据进程ID获取对应进程的信息  ps -u --pid 8012(pid)
  • linux中通过proc获取进程名以及PID

    千次阅读 2020-01-12 08:05:32
    给定某个线程的线程号tid,获取对应的进程名,或通过进程获取进程名。源码(通过进程获取进程名): void getNameByPid(pid_t pid, char *task_name) { char proc_pid_path[BUF_SIZE]; char buf[BUF_SIZE]...
  • Linux 根据进程名查找进程ID

    千次阅读 2017-08-10 22:16:24
    pgrep str命令进行模糊匹配,查找匹配该特征串的进程ID
  • linux根据端口 获取 所占进程pid 及程序,类似netstat -p 代码,或者给我 netstat 源码也行
  • Linux获取进程pid

    千次阅读 2016-03-16 19:26:02
    -/proc是系统中当前运行的所有进程的对应目录,以进程PID号为目录,可用来获取进程信息。 -/proc/pid/comm是对应pid号的进程名
  • Linux驱动获取进程PID进程名字

    千次阅读 2017-10-31 11:23:17
    Linux驱动打印进程PID进程名字在内核中, 进程用task_struct结构表示, 其中有char comm[TASK_COMM_LEN]成员, 其含义是 executable name excluding path 按照标准做法, 应该使用get_task_comm()/set_task_comm()...
1 2 3 4 5 ... 20
收藏数 84,423
精华内容 33,769
关键字:

linux根据进程名获取pid