精华内容
下载资源
问答
  • /*进入子进程创建子进程*/ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <signal.h> #include <sys/wait.h> int...

    /*进入子进程创建子进程*/
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    #include <sys/wait.h>

    int ossion();    //函数的申明
    int flag = 0;    //全局变量

    int main(int argc, char **argv)
    {
        ossion();
     return 0;
     }

     int ossion()
     {
         flag += 1;

         if(flag < 6)    //退出条件,总共递归五次
         {
             pid_t pid;
            pid = fork();

             if(pid == 0)
             {             
                 printf("son pid :%d\n",getpid());
                 ossion();    //子进程创建成功,再次进入递归
                     
                 return 0;
             }
             waitpid(pid,NULL,WUNTRACED);
         }
         return 0;        
     }

    展开全文
  • 获取子进程输入流 杀死 Process 子进程 不加 cmd 直接打开的子进程 加 cmd 打开的子进程 Process 进程概述 1、ProcessBuilder.start 和 Runtime.exec 方法都可以开启一个本机进程,并返回 Process 子类的一个...

    目录

    Process 进程概述

    获取子进程输入流

    杀死 Process 子进程

    不加 cmd 直接打开的子进程

    加 cmd 打开的子进程


    Process 进程概述

    1、ProcessBuilder.start 和 Runtime.exec  方法都可以开启一个本机进程,并返回 Process 子类的一个实例,Process 实例可控制进程并获得相关信息。

    2、Process 类提供了执行从进程输入、执行输出到进程、等待进程完成、检查进程的退出状态以及销毁(杀掉)进程的方法。 

    3、从 JDK 1.5开始, ProcessBuilder.start() 是创建 Process 的首选方式。 《Runtime 运行时类 执行 dos 、cmd 命令、VBS 脚本

    获取子进程输入流

    1、public abstract InputStream getInputStream() :获取子进程的输入流

    2、输入流获得由该 Process 对象表示的进程的标准输出流。 

    3、实现注意事项:对输入流进行缓冲是一个好主意。 返回连接到子进程正常输出的输入流。

    public static void main(String[] args) {
        try {
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec("cmd /c dir %JAVA_HOME%",null);
            InputStream inputStream = process.getInputStream();
            InputStreamReader streamReader = new InputStreamReader(inputStream,"gbk");
            BufferedReader bufferedReader = new BufferedReader(streamReader);
            String readLine ;
            while ((readLine = bufferedReader.readLine())!=null){
                System.out.println(readLine);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    

     

    杀死 Process 子进程

    1、public abstract void destroy() :杀掉子进程,强制终止此 Process 对象表示的子进程。 

    2、public Process destroyForcibly():杀死子进程,此Process对象表示的子进程被强制终止。 此方法的默认实现调用destroy() ,因此可能不会强制终止进程。 强烈建议使用此类的具体实现来使用兼容实现覆盖此方法。这是1.8新增的方法,也是推荐方式

    3、public boolean isAlive():测试这个Process代表的子 进程是否存活。 为true则表示此 Process对象表示的子进程尚未终止。 

    不加 cmd 直接打开的子进程

    1、如下所示,Runtime 调用本地的 PotPlayer 程序播放了一个视频,返回 Process 对象,Process 就代表着打开的 PotPlayer 子进程。休眠 5 秒之后判断 PotPlayer 子进程是否活着,如果活着则杀死它,即 关闭PotPlayer 程序

    2、对于如下 cmdStr 这种没有加前缀"cmd /c"的写法,在杀死子进程时,是没有问题的,因为打开的时候,Process 就直接记录的是 PotPlayer.exe 程序

    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Created by Administrator on 2018/6/27 0027.
     * 杀进程测试类
     */
    public class ProcessTest {
        public static void main(String[] args) {
            try {
                String cmdStr = "D:\\PotPlayer\\PotPlayerMini.exe E:/wmx/zl2.mp4";
                Runtime runtime = Runtime.getRuntime();
                Process process = runtime.exec(cmdStr);
                Thread.sleep(5000);
                if (process.isAlive()){
                    process.destroy();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    加 cmd 打开的子进程

    1、cmdStr1、cmdStr2 :对于 exe 程序是不用加"cmd  /c"前缀就可以直接打开的,这种方式打开时,Process的destory()与destroyForcibly()方法能正常杀死子进程。而加了"cmd /c"前缀的cmdStr3、cmdStr4打开的文件或程序都是“杀不死”的

    2、然而对于其它的大部分的 DOS 指令是必须借助 cmd.exe 程序的,cmdStr3、cmdStr4中 的 cmd 字符表示的就是 windows 系统目录中的程序 “C:\\Windows\\System32\\cmd.exe”

    3、如下所示的 cmdStr3、cmdStr4 中要想打开普通的 word 文件,如 txt、ppt、excel、pdf、png、mp4 等等都是要借用 cmd.exe 程序才能打开的,否则会报错说找不到路径

    4、cmdStr3、cmdStr4 这种直接指明参数文件,而没有指定打开此文件的程序时,默认会使用文件的关联程序进行打开,如下面的“E:/wmx/演讲稿.pptx”,如果关联的是Office则用Office打开,如果关联的是WPS,则用WPS打开。

    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Created by Administrator on 2018/6/27 0027.
     * 杀进程测试类
     */
    public class ProcessTest {
        public static void main(String[] args) {
            try {
                String cmdStr1 = "D:\\PotPlayer\\PotPlayerMini.exe E:/wmx/zl2.mp4";
                String cmdStr2 = "D:\\PotPlayer\\GPaoPao.exe";
                String cmdStr3 = "cmd /c E:/wmx/演讲稿.pptx";
                String cmdStr4 = "cmd /c E:/wmx/zl2.mp4";
    
                Runtime runtime = Runtime.getRuntime();
                Process process = runtime.exec(cmdStr4);
                Thread.sleep(5000);
                if (process.isAlive()) {
                    process.destroy();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    5、加了"cmd  /c”前缀就表示会打开cmd.exe程序来执行后面的命令,所以cmdStr3、cmdStr4在执行之后任务管理器就会有cmd进程,于是当Process调用destory()或者destroyForcibly()杀子进程的时候,杀死的只是cmd.exe,而真正需要结束的是打开mp4文件的 PotPlayer,或者是打开 pptx 文件的 WPS 程序

    解决方式 1

    1、如果能准确知道打开文件的程序路径,则建议直接写上程序路径。如下所示直接指定打开 .docx 文件的 Office 程序,这样结束子进程的时候就不会有问题了。

    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Created by Administrator on 2018/6/27 0027.
     * 杀进程测试类
     */
    public class ProcessTest {
        public static void main(String[] args) {
            try {
                /** 当路径中有空格时,则应该程序和参数分开写*/
                String[] paramArr = new String[2];
                paramArr[0] = "C:\\Program Files (x86)\\Microsoft Office\\root\\Office16\\WINWORD.EXE";
                paramArr[1] = "E:\\wmx\\Map_in-depth.docx";
                Runtime runtime = Runtime.getRuntime();
                Process process = runtime.exec(paramArr);
                Thread.sleep(15000);
                if (process.isAlive()) {
                    process.destroy();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    解决方式 2

    1、因为很多时候可能并不知道某个文件到底将来会用什么程序打开,如.docx文件可能是Office打开,也可能是WPS打开

    2、而且形如Office与WPS安装的路径也不一定知道或者路径不固定,此时采用杀进程树的方式来解决

    3、因为加"cmd /c"前缀使用cmd.exe程序来执行命令时,是先打开了cmd程序,然后打开的文件关联程序打开文件,后者属于cmd.exe程序的子进程,它们属于同一个进程树,而cmd提供了杀死整个进程树的命令,taskkill

    4、taskkill /PID xxx /F /T:taskkill表示杀死任务,/PID表示按进程的pid进行关闭,xxx表示进程pid值,/F表示强制终止进程,/T表示终止指定的进程和由它启用的子进程。

    5、这种方式时借助 JNA 的 API 会更加方便,需要的 Jar 包以及相关知识可以参考《JNA 理论详解 1》《JNA 实战 1

    6、使用 JNA 则先要导入它的两个开发包

    package com.lct.utils;
    
    import com.sun.jna.Pointer;
    import com.sun.jna.platform.win32.Kernel32;
    import com.sun.jna.platform.win32.WinNT;
    
    import java.lang.reflect.Field;
    import java.net.InetAddress;
    import java.net.NetworkInterface;
    import java.net.SocketException;
    import java.net.UnknownHostException;
    
    /**
     * Created by Administrator on 2018/6/26 0026.
     * 系统工具类
     */
    public class SystemUtils {
    
        /**
         * 杀死指定进程数,即包括process进程的所有子进程
         *
         * @param process
         */
        public static void killProcessTree(Process process) {
            try {
                if (process != null && process.isAlive()) {
                    Field f = process.getClass().getDeclaredField("handle");
                    f.setAccessible(true);
                    long handl = f.getLong(process);
                    Kernel32 kernel = Kernel32.INSTANCE;
                    WinNT.HANDLE handle = new WinNT.HANDLE();
                    handle.setPointer(Pointer.createConstant(handl));
                    int ret = kernel.GetProcessId(handle);
                    Long PID = Long.valueOf(ret);
                    String cmd = "cmd /c taskkill /PID " + PID + " /F /T ";
                    Runtime rt = Runtime.getRuntime();
                    Process killPrcess = rt.exec(cmd);
                    killPrcess.waitFor();
                    killPrcess.destroyForcibly();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    import com.lct.utils.SystemUtils;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Created by Administrator on 2018/6/27 0027.
     * 杀进程测试类
     */
    public class ProcessTest {
        public static void main(String[] args) {
            try {
                String cmdStr4 = "cmd /c E:\\wmx\\Map_in-depth.docx";
                Runtime runtime = Runtime.getRuntime();
                Process process = runtime.exec(cmdStr4);
                /** 休眠5秒后关闭子进程树*/
                Thread.sleep(5000);
                SystemUtils.killProcessTree(process);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    这样就能杀死打开.docx文件的程序了,亲测有效!

    展开全文
  • /*父进程下有子进程又有子子进程*/ #include #include int main(void) { pid_t pid; int i; pid=fork();/*复制出一个子进程*/ for(i=0;i;i++){/*i控制可以建5个进程,pid=0是子进程。此代码实现在...
    /*父进程下有子进程又有子子进程*/
    #include <stdio.h>
    #include <unistd.h>
    
    int main(void)
    {
    	pid_t pid;
    	int i;
    
    	pid=fork();/*复制出一个子进程*/
    	for(i=0;i<5&&pid==0;i++){/*i<5控制可以建5个进程,pid=0是子进程。此代码实现在子进程下再复制出子进程,依次复制*/
    		pid=fork();
    	}
    
    	while(1);/*保证进程处于存在状态*/
    	return 0;
    }
    编译程序用
    pstree可以看到
    展开全文
  • 父进程等待子进程退出并收集子进程退出状态 1.父进程为什么要等待子进程退出? 创建子进程目的:------干活 我们要知道干活结束没。 子进程退出状态不被收集,变成僵尸进程 等待:wait,waitpid函数: #include &...

    父进程等待(wait,waitpid)子进程退出并收集子进程退出状态

    1.父进程为什么要等待子进程退出?

    创建子进程目的:------干活
    我们要知道干活结束没。
    子进程退出状态不被收集,变成僵尸进程

    等待:wait,waitpid函数:

    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t wait(int *status);
    pid_t waitpid(pid_t pid, int *status, int options);
    

    Status参数:
    是一个整型数指针
    非空:子进程退出状态放在它所指向的地址中
    :不关心退出状态
    如果其所有子进程都还在运行,则wait阻塞
    如果一个子进程已终止,正等待父进程获取其终止状态,则wait取得该子进程的终止状态立即返回
    如果它没有任何子进程,则立即出错返回

    wait,waitpid的区别:

    区别:wait使调用者阻塞,waitpid有一个选项,可以使调用者不阻塞:options

    参数pid
    从参数的名字pid和类型pid_t中就可以看出,这里需要的是一个进程ID,但当pid取不同值的时候,在这里有不同的意义。
    1,pid>0时:只等待进程ID等于pid的子进程,不管其它有多少子进程运行结束退出了,只要指定的子进程还没有结束,waitpid就会一直等下去。
    2,pid=-1时:等待任何一个子进程退出,没有任何限制,此时waitpid和wait的作用一模一样。
    3.pid=0时:等待同一个进程组中的任何子进程,如果子进程已经进入了别的进程组,waitpid不会对它做出任何理睬。
    4,pid<-1时:等待一个指定进程中的任何子进程,这个进程组的ID等于pid的绝对值

    参数:options:
    在这里插入图片描述

    wait演示代码:

    #include <sys/types.h>
    #include <sys/wait.h> 
    #include <unistd.h> 
    #include <stdlib.h>
     #include <stdlib.h> 
    #include <stdio.h> 
    int main() 
    { 
    pid_t pid,pc; 
    int status; 
    printf("wait实例:\n"); 
    pid=fork(); 
    if(pid<0)//创建出错, 
    printf("error ocurred!\n"); 
    else if(pid == 0) //如果是子进程 
    { 
    printf("我是子进程的ID=%d\n",getpid());
     sleep(10); //睡眠10秒 
    exit(7); 
    } 
    else //父进程 
    { 
    pc=wait(&status); //等待子进程结束; 得到子进程的ID
    if(WIFEXITED(status)) //子程序正常结束返回非0值,异常返回0
    { 
    printf("我是父进程,我等待的子进程的id号=%d\n",pc); 
    printf("退出码是%d\n",WEXITSTATUS(status)); 
    } 
    else 
    { 
    printf("子进程退出异常!\n"); 
    } 
    } 
    exit(0);
    }
    

    代码实现:父进程等待子进程退出。
    在第3行结果打印出来前有10 秒钟的等待时间,这就是我们设定的让子进程睡眠的时间,只有子进程从睡眠中苏醒过来,它才能正常退出,也就才能被父进程捕捉到.

    运行结果:
    在这里插入图片描述
    waitpid代码演示:

    #include <sys/types.h>
    #include <sys/wait.h> 
    #include <unistd.h> 
    #include <stdlib.h>
     #include <stdlib.h> 
    #include <stdio.h> 
    int main() 
    { 
    pid_t pid,pc;
     pid=fork(); 
    int status; 
    if(pid<0) 
    { 
    printf("创建进程失败!\n"); 
    } 
    else if(pid==0) 
    { 
    printf("我是子进程,我的ID=%d\n",getpid());
     sleep(10); 
    exit(0); 
    } 
    else 
    { 
    do
    { 
    pc=waitpid(pid,&status,WNOHANG);//使用了WNOHANG参数,waitpid就不会等待,直接返回0. 
    // pc=waitpid(pid,&status,0); 
    if(pc==0) 
    { 
    printf("没有收集到子进程!\n"); 
    sleep(1); 
    } 
    }while(pc==0);//等不到,继续等, 
    if(pid==pc) 
    printf("等到了子进程\n");
     else printf("出错了\n");
     printf("我是父进程,我要等的进程id是%d\n",pc); 
    } 
    exit(0); 
    }

    运行结果:
    在这里插入图片描述
    从结果看出:

    先执行父进程,输出"没有收集到子进程",然后sleep(1),此时执行了子进程,输出"我是…31842",sleep(10);然后执行父进程,因为父进程不会等待子进程,所以不断的收集子进程,直到子进程sleep(10),结束后,才会收集到.

    展开全文
  • 一、父进程创建子进程,使用fork(), 一次fork() 两次返回,一次返回的是父进程自己,一次返回的是子进程的运行空间。 二、父进程必须监控子进程的运行状态,等待子进程退出后,使用wait()进行关闭,否则,如果父...
  • Unix 父子进程以及创建子进程

    千次阅读 2020-09-22 23:59:36
    Unix 进程 Unix系统中进程存在父子关系,父进程拥有多个子进程,子进程只能有一个父进程。pid为0的进程为调度进程...为了创建子进程能更加的轻量,fork创建子进程时,不会进行复制的动作,子进程和父进程共享内存区,只
  • 我们在fork 创建子进程的时候,有个特点就是 主进程和子进程互不影响, 但是 我们在用Process 类创建的子进程就需要等待 子进程全部结束后然后再结束主进程。 下边我们验证两个问题: 主进程的和子进程之间数据隔离...
  • ``` #!/usr/bin/python ...向子进程传了一个队列,子进程就全部无法运行。如果传一个list,传一个数都没问题。请大神指点指点。 ![图片说明](https://img-ask.csdn.net/upload/201812/28/1545996695_326091.png)
  • 父进程 等待子进程初始化后才使用子进程_waitforinputidle 在进程中创建子进程是很常见的话题。常规的方法是用CreateProcess(),这个函数功能强大,使用起来也很方便。不过CreateProcess()或其他函数,如...
  • python 多进程与子进程

    千次阅读 2018-10-10 15:47:36
    多进程: 1.os.fork() 2.from multiprocessing import Process ...我们创建了子进程后,还需要控制子进程的输入和输出。 使用subprocess包中的函数创建子进程的时候,要注意: 在创建子进程之后,父进程是...
  • 区分父进程和子进程 判断子进程和父进程可以使用**fork()**函数: 所需头文件: #include<sys/types.h> #include<unistd.h> 返回值: 0:子进程 >0: 父进程,返回值为创造出的子进程的PID -1:出错 ...
  • 我要做个多进程的应用,大概意思是 父进程启动子进程1,子进程2,在第一次运行完子进程的时候,我不让子进程关闭,待下次需要调用子进程的时候 子进程接着运行。 问题 1. 如下代码在运行完子进程的时候,通过任务...
  • 父进程与子进程

    千次阅读 2016-04-02 16:21:38
    关于父进程与子进程有许多疑问,这篇仅仅是个开头,这个系列仅为自己思考,并不是成熟体系,希望大家多批评指正。 在网上搜了很多,但是都没有一个普适的解释,仅仅是what和how,而我想知道的是why,所以我自己决定...
  • 假定父进程malloc的指针指向0x12345678, fork 后,子进程中的指针也是指向0x12345678,但是这两个地址都是虚拟内存地址 (virtual memory),经过内存地址转换后所对应的 物理地址是不一样的。所以两个进城中的这两个...
  • 1)子进程是从父进程中使用Process生成的,对子进程使用os.getppid()可以得到父进程的pid 2)全局变量在多个进程中不能共享,在子进程中修改全局变量,对父进程没有影响  ...
  • 子进程继承父进程

    千次阅读 2018-03-01 16:13:31
    子进程继承父进程用户号UIDs和用户组号GIDs环境Environment堆栈共享内存打开文件的描述符执行时关闭(Close-on-exec)标志信号(Signal)控制设定进程组号当前工作目录根目录文件方式创建屏蔽字资源限制控制终端子...
  • linux进程和子进程获取进程号

    千次阅读 2017-03-23 10:29:09
    #include int main(){  printf("当前进程id:%d\n",getpid());  int t;  if(t = fork()){ ... printf("我是父进程,我的子进程id为:%d\n",t);... printf("我是子进程... printf("我是子进程,我的父进程id是:%d\n
  • 主进程等待子进程结束

    千次阅读 2017-12-02 17:12:00
    子进程先于父进程退出时,如果父进程没有调用wait和waitpid函数,子进程就会进入僵死状态。如果父进程调用了wait或waitpid函数,就不会使子进程变为僵尸进程。这两个函数的声明如下: #include #include pid_t ...
  • 多进程编程---创建进程 头文件:#include<unistd.h> 创建一个新进程 :pid_t fork(void) 如果出错返回-1 fork 调用一次,两次返回... 新进程中返回0(子进程) (一)、举例,创建一个子进程,代码...
  • 4.父进程和子进程

    千次阅读 多人点赞 2018-05-19 17:36:10
    父进程和子进程 子进程是父进程的复制品Unix/linux系统中的进程创建是这样的,理解起来有点绕。父进程先执行fork()系统调用,这个调用的结果是系统中多出了一个跟父进程内容完全一样的进程,这个新进程被称为子进程...
  • fork出的子进程和父进程

    千次阅读 2019-06-01 21:44:15
    子进程id返回给父进程的理由是:因为一个进程的子进程可以多于一个,没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说,之所以fork返回0给它,是因为它随时可以调用getp...
  • 进程 第二天 (fork函数&子进程与父进程&守护进程)

    万次阅读 多人点赞 2018-08-13 20:37:20
    子进程与父进程&amp;守护进程) 一、fork()函数 在Linux系统内,创建子进程的方法是使用系统调用fork()函数。fork()函数是Linux系统内一个非常重要的函数,它与我们之前学过的函数有一个显著的区别:fork()函数...
  • 子进程与子线程的区别

    千次阅读 2019-03-19 17:23:12
    1、相同点: (a)二者都具有ID,一组...线程和子进程的创建者可以在线程和子进程上实行某些控制,比如,创建者可以取消、挂起、继续和修改线程和子进程的优先级;线程和子进程可以改变其属性并创建新的资源。 ...
  • Node父进程与子进程

    2018-04-27 15:24:10
    子进程 共享内存空间 子进程之间互相通信实现信息交换 子进程之间共享端口,分配请求 基本操作 /**************stdin*************/ process.stdin.resume(); process.stdin.on("data", function...
  • 线程与线程之间共享全局变量,进程之间不能共享全局变量...子进程会拷贝复制主进程中的所有资源(变量、函数定义等),所以子进程比子线程耗费资源。   demo.py(多进程): import threading # 线程 import tim...
  • LINUX父进程与子进程的理解

    千次阅读 2020-02-10 17:06:44
    1、父进程 指已创建一个或多个子进程的进程。在UNIX里,除了进程0以外的所有进程都是...2、子进程 指的是由另一进程(对应称之为父进程)所创建的进程。子进程继承了对应的父进程的大部分属性,如文件描述符。在Uni...
  • 在apache中,worker模式下,控制进程和子进程分别对应哪个进程?有哪位大神知道,谢谢
  • 父进程wait回收子进程

    千次阅读 2016-09-24 10:46:51
    子进程结束后,系统向其父进程发送SIGCHILD信号, 父进程调用wait函数后阻塞, 父进程被sigchild信号唤醒然后去回收僵尸子进程, 若父进程没有子进程则wait函数返回错误,  #include  #include
  • 进程概念的加深二、父进程与子进程1. 通过系统调用获取进程标示符2. 进程的创建 - fork3. fork的深层探讨(关键)(1)如何理解进程创建?(2)如何深刻理解fork为什么会有两个返回值?(3)fork父子进程执行顺序、...
  • python的多线程不是真正的多线程,所以使用多进程来实现高并发,比如训练模型读取数据时,但是kill只会杀死相应的进程ID,由于真实环境下子进程太多,一个一个去kill太麻烦,下面实现了只需要杀死主进程id即可同时使...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,090
精华内容 16,836
关键字:

子进程