JAVA进程和属性了解

最新推荐文章于 2022-03-23 20:14:10 发布
转载 最新推荐文章于 2022-03-23 20:14:10 发布 · 1.2k 阅读 · 0

Java 进程间通信机制汇总

1.Socket

使用套接字除了可以实现网络间不同主机间的通信外，还可以实现同一主机的不同进程间的通信，且建立的通信是双向的通信。

例如：

客户端：


[java] view plain copy print ?
  1. import java.io.DataInputStream;  
  2. import java.io.DataOutputStream;  
  3. import java.io.IOException;  
  4. import java.net.Socket;  
  5.   
  6.   
  7. public class Socket_Client {  
  8.   
  9.     public static void main(String[] args) throws InterruptedException {  
  10.         // TODO Auto-generated method stub  
  11.         Socket socket = null;  
  12.         String str = null;  
  13.         DataOutputStream out = null;  
  14.         DataInputStream in = null;  
  15.           
  16.         try{  
  17.             socket = new Socket("127.0.0.1", 4331);  
  18.             in = new DataInputStream(socket.getInputStream());  
  19.             out = new DataOutputStream(socket.getOutputStream());  
  20.             for(int i = 0; i < 10; i=i+1)  
  21.             {  
  22.                 out.writeUTF("" + i);  
  23.                 str = in.readUTF();  
  24.                 System.out.println("收到：" + str);  
  25.                 Thread.sleep(500);  
  26.             }  
  27.               
  28.         }  
  29.         catch(IOException e){  
  30.             System.out.println(e.toString());  
  31.         }  
  32.           
  33.     }  
  34.   
  35. }  
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;


public class Socket_Client {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Socket socket = null;
		String str = null;
		DataOutputStream out = null;
		DataInputStream in = null;
		
		try{
			socket = new Socket("127.0.0.1", 4331);
			in = new DataInputStream(socket.getInputStream());
			out = new DataOutputStream(socket.getOutputStream());
			for(int i = 0; i < 10; i=i+1)
			{
				out.writeUTF("" + i);
				str = in.readUTF();
				System.out.println("收到：" + str);
				Thread.sleep(500);
			}
			
		}
		catch(IOException e){
			System.out.println(e.toString());
		}
		
	}

}

服务器端：

[java] view plain copy print ?
  1. import java.io.DataInputStream;  
  2. import java.io.DataOutputStream;  
  3. import java.net.ServerSocket;  
  4. import java.net.Socket;  
  5.   
  6.   
  7. public class Socket_Server {  
  8.   
  9.     public static void main(String[] args) {  
  10.         // TODO Auto-generated method stub  
  11.         ServerSocket server = null;  
  12.         Socket socket = null;  
  13.         String str = null;  
  14.         DataOutputStream out = null;  
  15.         DataInputStream in = null;  
  16.           
  17.         try{  
  18.             server = new ServerSocket(4331);  
  19.             System.out.println("等待用户呼叫");  
  20.             socket = server.accept();  
  21.             out = new DataOutputStream(socket.getOutputStream());  
  22.             in = new DataInputStream(socket.getInputStream());  
  23.               
  24.             while(true){  
  25.                 str = in.readUTF();  
  26.                 out.writeUTF("服务器呼叫");  
  27.                 System.out.println("收到："+str);  
  28.                 Thread.sleep(500);  
  29.             }  
  30.         }  
  31.         catch(Exception e)  
  32.         {  
  33.             System.out.println(e.toString());  
  34.         }  
  35.   
  36.     }  
  37.   
  38. }  
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;


public class Socket_Server {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ServerSocket server = null;
		Socket socket = null;
		String str = null;
		DataOutputStream out = null;
		DataInputStream in = null;
		
		try{
			server = new ServerSocket(4331);
			System.out.println("等待用户呼叫");
			socket = server.accept();
			out = new DataOutputStream(socket.getOutputStream());
			in = new DataInputStream(socket.getInputStream());
			
			while(true){
				str = in.readUTF();
				out.writeUTF("服务器呼叫");
				System.out.println("收到："+str);
				Thread.sleep(500);
			}
		}
		catch(Exception e)
		{
			System.out.println(e.toString());
		}

	}

}


2.RMI

RMI（Remote Method Invocation）远程方法调用是java的核心技术之一。是Enterprise JavaBeans的基础技术，是java建立分布式应用程序的强大支柱。RMI允许一个应用程序访问另外一个服务器或虚拟机上的对象，方法和服务，它使远程方法调用就像在本地调用一样简单。它为用户屏蔽了底层的网络传输细节，使用的时候只需适当处理异常即可。所以RMI是非常容易使用的，但同时是非常强大的。


例如：

接口：

[java] view plain copy print ?
  1. import java.rmi.Remote;  
  2. import java.rmi.RemoteException;  
  3.   
  4. public interface HelloImp extends Remote{  
  5.       
  6.     public String helloWorld() throws RemoteException;   
  7.   
  8.     public String sayHelloToSomeBody(String someBodyName) throws RemoteException;   
  9.   
  10. }  
import java.rmi.Remote;
import java.rmi.RemoteException;

public interface HelloImp extends Remote{
	
	public String helloWorld() throws RemoteException; 

    public String sayHelloToSomeBody(String someBodyName) throws RemoteException; 

}


 

类：

[java] view plain copy print ?
  1. import java.rmi.RemoteException;  
  2. import java.rmi.server.UnicastRemoteObject;  
  3.   
  4. public class Hello extends UnicastRemoteObject implements HelloImp{  
  5.       
  6.   
  7.     public Hello() throws RemoteException {   
  8.     }   
  9.   
  10.        
  11.     public String helloWorld() throws RemoteException {   
  12.         return "Hello World!";   
  13.     }   
  14.   
  15.        
  16.     public String sayHelloToSomeBody(String someBodyName) throws RemoteException {   
  17.         return "你好，" + someBodyName + "!";   
  18.     }   
  19. }  
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class Hello extends UnicastRemoteObject implements HelloImp{
	

	public Hello() throws RemoteException { 
    } 

     
    public String helloWorld() throws RemoteException { 
        return "Hello World!"; 
    } 

     
    public String sayHelloToSomeBody(String someBodyName) throws RemoteException { 
        return "你好，" + someBodyName + "!"; 
    } 
}


 

客户端：

[java] view plain copy print ?
  1. import java.net.MalformedURLException;  
  2. import java.rmi.Naming;  
  3. import java.rmi.NotBoundException;  
  4. import java.rmi.RemoteException;  
  5.   
  6. public class RMI_Client {  
  7.     public static void main(String[] args) {  
  8.         try {   
  9.             //在RMI服务注册表中查找名称为RHello的对象，并调用其上的方法   
  10.             HelloImp rhello =(HelloImp) Naming.lookup("rmi://localhost:8888/RHello");   
  11.             System.out.println(rhello.helloWorld());   
  12.             System.out.println(rhello.sayHelloToSomeBody("Hello!SomeBody"));   
  13.         } catch (NotBoundException e) {   
  14.             e.printStackTrace();   
  15.         } catch (MalformedURLException e) {   
  16.             e.printStackTrace();   
  17.         } catch (RemoteException e) {   
  18.             e.printStackTrace();     
  19.         }   
  20.     }  
  21. }  
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

public class RMI_Client {
	public static void main(String[] args) {
		try { 
	        //在RMI服务注册表中查找名称为RHello的对象，并调用其上的方法 
	        HelloImp rhello =(HelloImp) Naming.lookup("rmi://localhost:8888/RHello"); 
	        System.out.println(rhello.helloWorld()); 
	        System.out.println(rhello.sayHelloToSomeBody("Hello!SomeBody")); 
	    } catch (NotBoundException e) { 
	        e.printStackTrace(); 
	    } catch (MalformedURLException e) { 
	        e.printStackTrace(); 
	    } catch (RemoteException e) { 
	        e.printStackTrace();   
	    } 
	}
}


 

服务器端：


 

[java] view plain copy print ?
  1. import java.net.MalformedURLException;  
  2. import java.rmi.AlreadyBoundException;  
  3. import java.rmi.Naming;  
  4. import java.rmi.RemoteException;  
  5. import java.rmi.registry.LocateRegistry;  
  6.   
  7. public class RMI_Server {  
  8.   
  9.     public static void main(String[] args) {  
  10.         // TODO Auto-generated method stub  
  11.         try {   
  12.             //创建一个远程对象   
  13.             HelloImp rhello = new Hello();   
  14.               
  15.             //本地主机上的远程对象注册表Registry的实例，并指定端口为8888，这一步必不可少（Java默认端口是1099），必不可缺的一步，缺少注册表创建，则无法绑定对象到远程注册表上   
  16.             LocateRegistry.createRegistry(8888);   
  17.   
  18.             //把远程对象注册到RMI注册服务器上，并命名为RHello   
  19.             //绑定的URL标准格式为：rmi://host:port/name(其中协议名可以省略，下面两种写法都是正确的）   
  20.             Naming.bind("rmi://localhost:8888/RHello",rhello);   
  21.   
  22.             System.out.println(">>>>>INFO:远程Hello对象绑定成功！");   
  23.         } catch (RemoteException e) {   
  24.             System.out.println("创建远程对象发生异常！");   
  25.             e.printStackTrace();   
  26.         } catch (AlreadyBoundException e) {   
  27.             System.out.println("发生重复绑定对象异常！");   
  28.             e.printStackTrace();   
  29.         } catch (MalformedURLException e) {   
  30.             System.out.println("发生URL畸形异常！");   
  31.             e.printStackTrace();   
  32.         }   
  33.   
  34.     }  
import java.net.MalformedURLException;
import java.rmi.AlreadyBoundException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class RMI_Server {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try { 
            //创建一个远程对象 
            HelloImp rhello = new Hello(); 
            
            //本地主机上的远程对象注册表Registry的实例，并指定端口为8888，这一步必不可少（Java默认端口是1099），必不可缺的一步，缺少注册表创建，则无法绑定对象到远程注册表上 
            LocateRegistry.createRegistry(8888); 

            //把远程对象注册到RMI注册服务器上，并命名为RHello 
            //绑定的URL标准格式为：rmi://host:port/name(其中协议名可以省略，下面两种写法都是正确的） 
            Naming.bind("rmi://localhost:8888/RHello",rhello); 

            System.out.println(">>>>>INFO:远程Hello对象绑定成功！"); 
        } catch (RemoteException e) { 
            System.out.println("创建远程对象发生异常！"); 
            e.printStackTrace(); 
        } catch (AlreadyBoundException e) { 
            System.out.println("发生重复绑定对象异常！"); 
            e.printStackTrace(); 
        } catch (MalformedURLException e) { 
            System.out.println("发生URL畸形异常！"); 
            e.printStackTrace(); 
        } 

	}

总结：
从上面的过程来看，RMI对服务器的IP地址和端口依赖很紧密，但是在开发的时候不知道将来的服务器IP和端口如何，但是客户端程序依赖这个IP和端口。
这也是RMI的局限性之一。这个问题有两种解决途径：一是通过DNS来解决，二是通过封装将IP暴露到程序代码之外。
RMI的局限性之二是RMI是Java语言的远程调用，两端的程序语言必须是Java实现，对于不同语言间的通讯可以考虑用Web Service或者公用对象请求代理体系（CORBA）来实现。


3.内存映射

Java 利用NIO(New I/O)来实现共享内存，就是将不同进程的内存映射文件关联到同一个物理文件，NIO的内存映射文件（MappedByteBuffer）总是与某个物理文件相关，不管是从FileInputStream、FileOutputStream之类还是RandomAccessFile得来的FileChannel，都由map()得到的内存映射文件MappedByteBuffer。严格来说，其实就是两个Java进程通过中间文件来交换数据，用中间文件使得两个进程的两块内存区域的内容得到及时的同步。

代码 WriteShareMemory.java 往映射文件中依次写入 A、B、C ... Z，ReadShareMemory.java 逐个读出来，打印到屏幕上。代码对交换文件 swap.txt 的第一个字节作了读写标志，分别是 0-可读，1-正在写，2-可读。RandomAccessFile 得到的 Channel 能够灵活的进行读或写，并且不会破坏原有文件内容，而 FileInputStream 或 FileOutputStream 取得的 Channel 则很难达到这一功效，所以使用了 RandomAccessFile 来获得 FileChannel。

WriteShareMemory.java:

[java] view plain copy print ?
  1. import java.io.RandomAccessFile;  
  2. import java.nio.MappedByteBuffer;  
  3. import java.nio.channels.FileChannel;  
  4. import java.nio.channels.FileChannel.MapMode;  
  5.    
  6. /** 
  7.  * 往 "共享内存" 写入数据 
  8.  * @author Unmi 
  9.  */  
  10. public class WriteShareMemory {  
  11.    
  12.     /** 
  13.      * @param args 
  14.      * @throws Exception 
  15.      */  
  16.     public static void main(String[] args) throws Exception {  
  17.         RandomAccessFile raf = new RandomAccessFile("f:/swap.txt", "rw");  
  18.         FileChannel fc = raf.getChannel();  
  19.         MappedByteBuffer mbb = fc.map(MapMode.READ_WRITE, 0, 1024);  
  20.    
  21.         //清除文件内容  
  22.         for(int i=0;i<1024;i++){  
  23.             mbb.put(i,(byte)0);  
  24.         }  
  25.    
  26.         //从文件的第二个字节开始，依次写入 A-Z 字母，第一个字节指明了当前操作的位置  
  27.         for(int i=65;i<91;i++){  
  28.             int index = i-63;  
  29.             int flag = mbb.get(0); //可读标置第一个字节为 0  
  30.             if(flag != 0){ //不是可写标示 0，则重复循环，等待  
  31.                 i --;  
  32.                 continue;  
  33.             }  
  34.             mbb.put(0,(byte)1); //正在写数据，标志第一个字节为 1  
  35.             mbb.put(1,(byte)(index)); //写数据的位置  
  36.    
  37.             System.out.println("程序 WriteShareMemory："+System.currentTimeMillis() +  
  38.                     "：位置：" + index +" 写入数据：" + (char)i);  
  39.    
  40.             mbb.put(index,(byte)i);//index 位置写入数据  
  41.             mbb.put(0,(byte)2); //置可读数据标志第一个字节为 2  
  42.             Thread.sleep(513);  
  43.         }  
  44.         raf.close();  
  45.     }  
  46. }  
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
 
/**
 * 往 "共享内存" 写入数据
 * @author Unmi
 */
public class WriteShareMemory {
 
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        RandomAccessFile raf = new RandomAccessFile("f:/swap.txt", "rw");
        FileChannel fc = raf.getChannel();
        MappedByteBuffer mbb = fc.map(MapMode.READ_WRITE, 0, 1024);
 
        //清除文件内容
        for(int i=0;i<1024;i++){
            mbb.put(i,(byte)0);
        }
 
        //从文件的第二个字节开始，依次写入 A-Z 字母，第一个字节指明了当前操作的位置
        for(int i=65;i<91;i++){
            int index = i-63;
            int flag = mbb.get(0); //可读标置第一个字节为 0
            if(flag != 0){ //不是可写标示 0，则重复循环，等待
                i --;
                continue;
            }
            mbb.put(0,(byte)1); //正在写数据，标志第一个字节为 1
            mbb.put(1,(byte)(index)); //写数据的位置
 
            System.out.println("程序 WriteShareMemory："+System.currentTimeMillis() +
                    "：位置：" + index +" 写入数据：" + (char)i);
 
            mbb.put(index,(byte)i);//index 位置写入数据
            mbb.put(0,(byte)2); //置可读数据标志第一个字节为 2
            Thread.sleep(513);
        }
        raf.close();
    }
}

ReadSharedMemory.java:

[java] view plain copy print ?
  1. import java.io.RandomAccessFile;  
  2. import java.nio.MappedByteBuffer;  
  3. import java.nio.channels.FileChannel;  
  4. import java.nio.channels.FileChannel.MapMode;  
  5.    
  6. /** 
  7.  * 从 "共享内存" 读出数据 
  8.  * @author Unmi 
  9.  */  
  10. public class ReadShareMemory {  
  11.    
  12.     /** 
  13.      * @param args 
  14.      * @throws Exception 
  15.      */  
  16.     public static void main(String[] args) throws Exception {  
  17.         RandomAccessFile raf = new RandomAccessFile("f:/swap.txt", "rw");  
  18.         FileChannel fc = raf.getChannel();  
  19.         MappedByteBuffer mbb = fc.map(MapMode.READ_WRITE, 0, 1024);  
  20.         int lastIndex = 0;  
  21.    
  22.         for(int i=1;i<27;i++){  
  23.             int flag = mbb.get(0); //取读写数据的标志  
  24.             int index = mbb.get(1); //读取数据的位置,2 为可读  
  25.    
  26.             if(flag != 2 || index == lastIndex){ //假如不可读，或未写入新数据时重复循环  
  27.                 i--;  
  28.                 continue;  
  29.             }  
  30.    
  31.             lastIndex = index;  
  32.             System.out.println("程序 ReadShareMemory：" + System.currentTimeMillis() +  
  33.                     "：位置：" + index +" 读出数据：" + (char)mbb.get(index));  
  34.    
  35.             mbb.put(0,(byte)0); //置第一个字节为可读标志为 0  
  36.    
  37.             if(index == 27){ //读完数据后退出  
  38.                 break;  
  39.             }  
  40.         }  
  41.         raf.close();  
  42.     }  
  43. }  
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
 
/**
 * 从 "共享内存" 读出数据
 * @author Unmi
 */
public class ReadShareMemory {
 
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        RandomAccessFile raf = new RandomAccessFile("f:/swap.txt", "rw");
        FileChannel fc = raf.getChannel();
        MappedByteBuffer mbb = fc.map(MapMode.READ_WRITE, 0, 1024);
        int lastIndex = 0;
 
        for(int i=1;i<27;i++){
            int flag = mbb.get(0); //取读写数据的标志
            int index = mbb.get(1); //读取数据的位置,2 为可读
 
            if(flag != 2 || index == lastIndex){ //假如不可读，或未写入新数据时重复循环
                i--;
                continue;
            }
 
            lastIndex = index;
            System.out.println("程序 ReadShareMemory：" + System.currentTimeMillis() +
                    "：位置：" + index +" 读出数据：" + (char)mbb.get(index));
 
            mbb.put(0,(byte)0); //置第一个字节为可读标志为 0
 
            if(index == 27){ //读完数据后退出
                break;
            }
        }
        raf.close();
    }
}

 

Java的多进程运行模式分析

一般我们在java中运行其它类中的方法时，无论是静态调用，还是动态调用，都是在当前的进程中执行的，也就是说，只有一个java虚拟机实例在运行。而有的时候，我们需要通过java代码启动多个java子进程。这样做虽然占用了一些系统资源，但会使程序更加稳定，因为新启动的程序是在不同的虚拟机进程中运行的，如果有一个进程发生异常，并不影响其它的子进程。

　　在Java中我们可以使用两种方法来实现这种要求。最简单的方法就是通过Runtime中的exec方法执行java classname.如果执行成功，这个方法返回一个Process对象，如果执行失败，将抛出一个IOException错误。下面让我们来看一个简单的例子。

　　// Test1.java文件

　　import java.io.*；

　　public class Test

　　{

　　public static void main（String[] args）

　　{

　　FileOutputStream fOut = new FileOutputStream（"c：//Test1.txt"）；

　　fOut.close（）；

　　System.out.println（"被调用成功！"）；

　　}

　　}

　　// Test_Exec.java

　　public class Test_Exec

　　{

　　public static void main（String[] args）

　　{

　　Runtime run = Runtime.getRuntime（）；

　　Process p = run.exec（"java test1"）；

　　}

　　}

　　通过java Test_Exec运行程序后，发现在C盘多了个Test1.txt文件，但在控制台中并未出现"被调用成功！"的输出信息。因此可以断定，Test已经被执行成功，但因为某种原因，Test的输出信息未在Test_Exec的控制台中输出。这个原因也很简单，因为使用exec建立的是Test_Exec的子进程，这个子进程并没有自己的控制台，因此，它并不会输出任何信息。

　　如果要输出子进程的输出信息，可以通过Process中的getInputStream得到子进程的输出流（在子进程中输出，在父进程中就是输入），然后将子进程中的输出流从父进程的控制台输出。具体的实现代码如下如示：

　　// Test_Exec_Out.java

　　import java.io.*；

　　public class Test_Exec_Out

　　{

　　public static void main（String[] args）

　　{

　　Runtime run = Runtime.getRuntime（）；

　　Process p = run.exec（"java test1"）；

　　BufferedInputStream in = new BufferedInputStream（p.getInputStream（））；

　　BufferedReader br = new BufferedReader（new InputStreamReader（in））；

　　String s；

　　while （（s = br.readLine（）） ！= null）

　　System.out.println（s）；

　　}

　　}

　　从上面的代码可以看出，在Test_Exec_Out.java中通过按行读取子进程的输出信息，然后在Test_Exec_Out中按每行进行输出。 上面讨论的是如何得到子进程的输出信息。那么，除了输出信息，还有输入信息。既然子进程没有自己的控制台，那么输入信息也得由父进程提供。我们可以通过Process的getOutputStream方法来为子进程提供输入信息（即由父进程向子进程输入信息，而不是由控制台输入信息）。我们可以看看如下的代码：

　　// Test2.java文件

　　import java.io.*；

　　public class Test

　　{

　　public static void main（String[] args）

　　{

　　BufferedReader br = new BufferedReader（new InputStreamReader（System.in））；

　　System.out.println（"由父进程输入的信息：" + br.readLine（））；

　　}

　　}

　　// Test_Exec_In.java

　　import java.io.*；

　　public class Test_Exec_In

　　{

　　public static void main（String[] args）

　　{

　　Runtime run = Runtime.getRuntime（）；

　　Process p = run.exec（"java test2"）；

　　BufferedWriter bw = new BufferedWriter（new OutputStreamWriter（p.getOutputStream（）））；

　　bw.write（"向子进程输出信息"）；

　　bw.flush（）；

　　bw.close（）； // 必须得关闭流，否则无法向子进程中输入信息

　　// System.in.read（）；

　　}

　　}

　　从以上代码可以看出，Test1得到由Test_Exec_In发过来的信息，并将其输出。当你不加bw.flash（）和bw.close（）时，信息将无法到达子进程，也就是说子进程进入阻塞状态，但由于父进程已经退出了，因此，子进程也跟着退出了。如果要证明这一点，可以在最后加上System.in.read（），然后通过任务管理器（在windows下）查看java进程，你会发现如果加上bw.flush（）和bw.close（），只有一个java进程存在，如果去掉它们，就有两个java进程存在。这是因为，如果将信息传给Test2，在得到信息后，Test2就退出了。在这里有一点需要说明一下，exec的执行是异步的，并不会因为执行的某个程序阻塞而停止执行下面的代码。因此，可以在运行test2后，仍可以执行下面的代码。

　　exec方法经过了多次的重载。上面使用的只是它的一种重载。它还可以将命令和参数分开，如exec（"java.test2"）可以写成exec（"java"， "test2"）。exec还可以通过指定的环境变量运行不同配置的java虚拟机。

　　除了使用Runtime的exec方法建立子进程外，还可以通过ProcessBuilder建立子进程。ProcessBuilder的使用方法如下：

　　// Test_Exec_Out.java

　　import java.io.*；

　　public class Test_Exec_Out

　　{

　　public static void main（String[] args）

　　{

　　ProcessBuilder pb = new ProcessBuilder（"java"， "test1"）；

　　Process p = pb.start（）；

　　… …

　　}

　　}

　　在建立子进程上，ProcessBuilder和Runtime类似，不同的ProcessBuilder使用start（）方法启动子进程，而Runtime使用exec方法启动子进程。得到Process后，它们的操作就完全一样的。

　　ProcessBuilder和Runtime一样，也可设置可执行文件的环境信息、工作目录等。下面的例子描述了如何使用ProcessBuilder设置这些信息。

　　ProcessBuilder pb = new ProcessBuilder（"Command"， "arg2"， "arg2"， '''）；

　　// 设置环境变量

　　Map<String， String> env = pb.environment（）；

　　env.put（"key1"， "value1"）；

　　env.remove（"key2"）；

　　env.put（"key2"， env.get（"key1"） + "_test"）；

　　pb.directory（"……/abcd"）； // 设置工作目录

　　Process p = pb.start（）； // 建立子进程

Java中获取进程ID以及杀死进程的方法

taskkill介绍

taskkill是用来终止进程的。具体的命令规则如下：　　TASKKILL [/S system [/U username [/P [password]]]]　　{ [/FI filter] [/PID processid | /IM imagename] } [/F] [/T]　　描述:　　这个命令行工具可用来结束至少一个进程。　　可以根据进程 id 或图像名来结束进程。　　参数列表:　　

/S system 指定要连接到的远程系统。　　

/U [domain\]user 指定应该在哪个用户上下文　　执行这个命令。　　

/P [password] 为提供的用户上下文指定密码。如果忽略，提示输入。　　

/F 指定要强行终止的进程。　　/FI filter 指定筛选进或筛选出查询的的任务。　　

/PID process id 指定要终止的进程的PID。　　

/IM image name 指定要终止的进程的图像名。通配符 '*'可用来指定所有图像名。　　

/T Tree kill: 终止指定的进程和任何由此启动的子进程。　　

/? 显示帮助/用法。　　筛选器:　　筛选器名 有效运算符 有效值

Java实现

private String getPID() {
  String pid = null;
  String cmd = "tasklist /nh /FI \"IMAGENAME eq eclipse.exe\"";
  try {
   Runtime runtime = Runtime.getRuntime();
   Process process = runtime.exec(cmd);
   BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
   String line = null;
   while((line=br.readLine()) != null){
    if(line.indexOf("eclipse.exe") != -1){
     String[] lineArray = line.split(" ");
     pid = lineArray[17].trim();
     if(pid.equals(RFT_ECLIPSE_PID)){
      continue;
     } else {
      return pid;
     }
    }
   }
  } catch (IOException e) {
   e.printStackTrace();
  }
  return pid;
 }

 

      try {
       RBD_ECLIPSE_PID = getPID();
       Runtime.getRuntime().exec("taskkill /F /PID "+RBD_ECLIPSE_PID);
      } catch (IOException e1) {
       e1.printStackTrace();
      }

 

获取当前运行Java的进程标识符(PID)

C:\Users>jps
7152 Jps
4440 后面是应用程序启动类的类名

C:\Users>

可以在新建一个批处理,在文件中输入JPS,然后在JAVA中用ProcessBuilder执行批处量命令后得到进程对象,通过输入对象可以读取到控制台中的内容.如下所示:

ProcessBuilder此类用于创建操作系统进程。

每个 ProcessBuilder 实例管理一个进程属性集。start() 方法利用这些属性创建一个新的Process 实例。start() 方法可以从同一实例重复调用，以利用相同的或相关的属性创建新的子进程。

 

修改进程构建器的属性将影响后续由该对象的 start() 方法启动的进程，但从不会影响以前启动的进程或 Java 自身的进程。

ProcessBuilder pb = new ProcessBuilder("批处理文件名带后缀");//该文件在工程目录下就行了.

pb.directory(System.getProperty("user.dir") );//得到当前工程所在的绝对路径.

Map<String, String> env = pb.environment();

env.put("VAR1", "myValue");

env.remove("OTHERVAR");

env.put("VAR2", env.get("VAR1") + "suffix");

Process p = pb.start();

　　BufferedInputStream in = new BufferedInputStream（p.getInputStream（））；

　　BufferedReader br = new BufferedReader（new InputStreamReader（in））；

　　String s；

　　while （（s = br.readLine（）） ！= null）

　　System.out.println（s）；

　　}

　　}

 

 

 

启动java并得到当前JVM进程的pid

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;

public class ShowOwnPID {
    public static void main(String[] args) throws Exception {
        int pid = getPid();
        System.out.println("pid: " + pid);
        System.in.read(); // block the program so that we can do some probing on it
    }
   
    private static int getPid() {
        RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
        String name = runtime.getName(); // format: "pid@hostname"
        try {
            return Integer.parseInt(name.substring(0, name.indexOf('@')));
        } catch (Exception e) {
            return -1;
        }
    }
}

 

Java的系统环境变量

java.version

Java 运行时环境版本

java.vendor

Java 运行时环境供应商

java.vendor.url

Java 供应商的 URL

java.home

Java 安装目录

java.vm.specification.version

Java 虚拟机规范版本

java.vm.specification.vendor

Java 虚拟机规范供应商

java.vm.specification.name

Java 虚拟机规范名称

java.vm.version

Java 虚拟机实现版本

java.vm.vendor

Java 虚拟机实现供应商

java.vm.name

Java 虚拟机实现名称

java.specification.version

Java 运行时环境规范版本

java.specification.vendor

Java 运行时环境规范供应商

java.specification.name

Java 运行时环境规范名称

java.class.version

Java 类格式版本号

java.class.path

Java 类路径

java.library.path

加载库时搜索的路径列表

java.io.tmpdir

默认的临时文件路径

java.compiler

要使用的 JIT 编译器的名称

java.ext.dirs

一个或多个扩展目录的路径

os.name

操作系统的名称

os.arch

操作系统的架构

os.version

操作系统的版本

file.separator

文件分隔符（在 UNIX 系统中是“/”）

path.separator

路径分隔符（在 UNIX 系统中是“:”）

line.separator

行分隔符（在 UNIX 系统中是“/n”）

user.name

用户的账户名称

user.home

用户的主目录

user.dir

用户的当前工作目录

可以通过System.getenv()获取系统环境变量;

System.getenv("JAVA_HOME"); // 获取JAVA_HOME环境变量

System.getenv("CLASSPATH"); // 获取CLASSPATH环境变量


-----------------------------------------------------------------------------------

Java启动时，如果设置了-classpath或-cp参数的话，直接取这个参数后面的值，设置到java.class.path系统变量中

否则查询CLASSPATH环境变量的值，设置到java.class.path系统变量中

如果没有定义CLASSPATH环境变量或CLASSPATH环境变量为.，则把.设置到java.class.path系统变量中

在Lanuer生成AppClassLoader类加载器的时候，处理如下

  String str = System.getProperty("java.class.path");  // 先拿到类加载路径
  File[] arrayOfFile = str == null ? new File[0] : Launcher.getClassPath(str); // 转换为File

  URL[] arrayOfURL = this.val$s == null ? new URL[0] : Launcher.pathToURLs(arrayOfFile); // 把File转换成URL


  private static URL[] pathToURLs(File[] paramArrayOfFile)
  {
    URL[] arrayOfURL = new URL[paramArrayOfFile.length];
    for (int i = 0; i < paramArrayOfFile.length; i++) {
      arrayOfURL[i] = getFileURL(paramArrayOfFile[i]); // 获取URL
    }


    return arrayOfURL;
  }


  static URL getFileURL(File paramFile)
  {
    try
    {
      paramFile = paramFile.getCanonicalFile();  // 如果File为.，则直接返回的URL为当前目录,如D:\work_taobao\workspace\Main

    } catch (IOException localIOException) {
    }
    try {
      return ParseUtil.fileToEncodedURL(paramFile);
    } catch (MalformedURLException localMalformedURLException) {
    }
    throw new InternalError();
  }

 

Java 进程调度
Naion的博客
07-21 548
简单介绍了自己对于进程的理解。
Java进程调度的基本过程(详细易理解)
qq_62718027的博客
06-21 528
了解这个问题之前,我们需要先打开我们桌面上的的学习资料啪的一下,很快啊,点双击学习资料.exe之后,在后台(ctrl+alt+delete,任务管理器)我们就能看到这个东西我们这里肉眼直观可见的这个XX游戏登录程序,就是我们所谓的进程桌面上的exe文件,只是起了一个发起调用的作用如果我们不点击exe文件,那么这个进程就永远不会被触发换句话来说不调用,不触发很好的一句废话。
java进程
08-16 179
13.1 进程的简单描述 * 进程：分配资源最小的单位 * 线程：“同时”去做几件事情 * 进程与线程： * 一个程序一个进程； * 一个进程最少有一个线程 * 并行与并发：cpu-单核、双核、四核、八核 * 并行：真正的"同时" * 并发：不是真正的"同时" * 控制不了并行，一般只说并发：并发量 * 系统：实时-分时-时间轮 ...
java程序属性_java的属性
weixin_39604045的博客
02-28 148
Person.javapackage com.google.eshop.javase;import java.util.Date;//电商 人 和银行项目的人//类是抽象的数据类型，我们需要的是具体的人变成对象//包含别的数据类型，不只是基本数据类型，还可以是别的引用类型//类具体化成对象//main方法不是类必须的，只是一个程序//类的设计是为了复用public class Person {//...
什么是进程 java_java中进程是什么
weixin_39574140的博客
02-12 534
进程是操作系统结构的基础；是一个正在执行的程序；计算机中正在运行的程序实例；可以分配给处理器并由处理器执行的一个实体；由单一顺序的执行显示，一个当前状态和一组相关的系统资源所描述的活动单元。 (推荐学习：java课程)第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域(text region)、数据区域(data region)和堆栈(stack region)。文...
Java 进程
weixin_59771320的博客
03-23 1888
目录 什么是进程？ 操作系统 进程控制块（PCB） PCB中的一些属性 pid（进程id） 内存指针 文件描述符表 状态 优先级 记账信息 上下文 并行，并发 CPU分配——进程调度 内存分配——内存管理 进程间是如何通信的 什么是进程？ 如图，当我们调出电脑的任务管理器即可看到这些内容，而这些就是进程。 进程还有一个名字 任务 进程就是操作系统对一个正在进行的程序的一种抽象，简的来说，我们可以把进程当做程序的一次运行过程，同时，在操作系统内部，进程又是操
Java--进程
郑斑
04-07 385
1 进程概念 线程：线程在一个进程中负责代码的执行，是进程中一个执行路径 多线程：在一个进程中有多个线程同时在执行不同的任务 一个java应用程序至少有两个线程，一个是主线程负责main方法代码的执行，一个是垃圾回收器线程，负责了回收垃圾。 2 创建进程方式一 2.1 方式一步骤 【方式一】： 1、自定义一个类继承Thread类 2、重写Thread类的run方法 , 把自定义...
精选资源
Java实现模拟单处理器的进程调度.zip
12-15
1. **进程类**（Process）：定义进程的基本属性和行为。 2. **调度器类**（Scheduler）：实现不同的调度算法，如FCFS、SPF、时间片轮转等。 3. **测试类**：用于创建一系列进程，调用调度器进行调度，并输出结果，如...
学习Java多线程之线程定义、状态和属性
09-02
首先，我们需要了解线程和进程的概念。线程是程序执行的基本单位，每个线程都有自己的栈空间，用于存储局部变量和方法调用信息。在Java中，线程有四种状态：运行、就绪、挂起和结束。进程则是指正在执行的程序实体，...
操作系统进程调度（java）
07-01
在Java中，这个类可能包含各种属性和方法来创建、修改和访问这些信息。 在实际的进程调度中，操作系统会考虑多个因素，例如进程的执行时间、等待时间、周转时间以及响应时间，以达到公平、高效的目标。在Java实现中...
Java进程
Lee_my_的专栏
01-15 732
获取键盘上的输入流键盘输入> package com.fs.demo;   import java.io.IOException; import java.io.InputStream; import java.io.PrintStream;   public class Test1 { public static void main(String[] args) throws I
java 什么是进程_Java线程和进程
weixin_28785657的博客
02-12 1041
一.线程1.什么是线程：线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。一个进程至少包含一个线程，也可以多个，线程属于进程。2.Java中线程经历的四个过程：(1)创建：创建一个Java线程常见的有两种方式:继承Thread类和实现Runnable接口这两种方式。(2)执行：线程创建后仅仅占有了内存资源，在JVM管理的线程中还没有该线程，该线程必须调用st...
java 什么是进程_什么是java的进程和线程-乐橙谷
weixin_39613433的博客
02-16 230
原标题：什么是java的进程和线程-乐橙谷首先我们先给大家来说一下进程和线程的基本概念，然后对比一下他们的区别进程是什么呢？进程是指一个运行的程序,它有自己独立的内存空间,一组系统资源,每个进程的内部数据和状态都是独立的,例如在window是同时打开多个记事本,虽然它们所运行的程序代码都是一样的,但是所使用的内存空间是独立的,互不干扰.线程是什么？线程是一段完成某个特定功能的代码,是程序中单个顺序...
什么是Java程序的进程、线程
康雨城
02-02 2122
对Java工程师来说，这里有一个问题：什么是Java程序的进程呢？ Java编写的程序都运行在Java虚拟机（JVM）中，每当使用Java命令启动一个Java应用程序时，就会启动一个JVM进程。在这个JVM进程内部，所有Java程序代码都是以线程来运行的。JVM找到程序的入口点main()方法，然后运行main()方法，这样就产生了一个线程，这个线程被称为主线程。当main()方法结束后，主线程运行完成，JVM进程也随即退出。
Java进程间通信方法
pickpocket的专栏
02-14 241
一般的，进程间通信的方法有：       （1）管道（Pipe）：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。       （2）命名管道（named pipe）：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来...
Java 线程、进程
单枪匹码
08-25 1392
1、什么是进程：process 进程时操作系统中运行的一个任务（一个应用程序运行在一个进程中）。 进程时一块包含了某些资源的内存区域，操作系统利用进程把它的工作划分为一些功能单元。 进程中包含的一个或多个执行单元称为线程，进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。 线程只能归属于一个进程，并且它只能访问该进程所拥有的资源，当操作系统创建一个进程后，该进程会自动申请一个名为主线程或者首要线程的线程。 2、什么是线程：thread 一个线程是进程的一个顺序执行流。 同类的多个线程共享一块
Java进程的基本概念
cxj861216的专栏
01-09 528
今天开始整理资料。欢迎大家关注，首先是Java线程和进程。快速进入话题，查了资料，感觉一下这样描述进，线程比较合适进程：内存环境中基本执行单元，进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。从用户角度来看，进程是应用程序的一个执行过程。线程：CPU执行的最小片段。线程是程序中一个单一的顺序控制流程。多进程和多线程多线程运行：自己基本上不拥有系统资源,只拥有一点在运行中必不可少的
<JAVA学习笔记4>——进程、线程简单介绍
小冯的Blog
06-24 429
1、线程、进程：
java进程间通信_java进程间通信
weixin_29069575的博客
02-12 356
packagechild;importjava.io.*;importjava.nio.CharBuffer;importjava.util.Arrays;public classProcessCommunication{public static voidmain(String[] args) {System.out.println(System.getProperty("user.dir"))...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值