让Java程序只运行一个实例

  让Java程序只运行一个实例  
   
  作者：梁邦勇     不是我
    
      一个程序可以在内存里面存在多个运行实例，比如，你可以打开多个微软的Word程序。但是，有些时候我们需要控制程序运行的实例只有一个，也就是说，该程序同一时刻在内存里面运行的只有一个实例。这样当这个程序在内存中已经存在一个运行实例而用户又再次运行了该程序的时候，有两种结果，第一种结果是结束目前的运行实例，打开新运行的实例；第二种就是让新运行的实例退出，原有的运行实例继续运行。     
         
  原理   
  因为任何时候只有一个实例，所以在实现这种功能的时候必须借助只能被独享的资源。如果我们的程序是基于某个平台的，那么就可以借助操作系统的内核对象来完成，比如Windows操作系统就提供了CreateMutex这个API来创建一个独享的内核对象。但是因为要考虑平台无关，Java程序的实例控制不应该使用系统的内核对象来完成，那么我们就必须找到其它的、可以独享的资源。实际上，一台机器无论是在什么操作系统上，网络端口都是独享的，也就是说基于网络端口这个独享的原理，我们可以很方便地让我们的Java程序实现在内存里面只有一个运行实例这个功能，而且这个功能的实现是与平台无关的。     
 
  实现   
  我们先来看看第一种情况是如何实现的，也就是说如果系统中已经存在运行实例的话，那么结束原有的运行实例，让新实例运行。这个实现实例控制的Java类也是一个线程，具体的实现如下：

1.   import    java.net.*;   
2.     
3.    public     class    InstanceControl    extends    Thread   {   
4.     
5.    public     void    run()   {   
6.     
7.    try {   
8.     
9.   Socket   sock   =    new    Socket( "127.0.0.1" , 22222 );     
10.     
11.    //创建socket，连接22222端口　　　　　　　　　　　　　　　　　　　   
12.     
13.   }   
14.     
15.    catch    (Exception   e)   
16.     
17.   {}   
18.     
19.    try {   
20.     
21.   ServerSocket   server   =    new    ServerSocket( 22222 ); //创建socket,在22222端口监听   
22.     
23.   server.accept();    //等待连接   
24.     
25.   server.close();    //有连接到来，也就是说有新的实例   
26.     
27.   System.exit( 0 );    //这个实例退出   
28.     
29.   } catch    (Exception   e)   
30.     
31.   {   
32.     
33.   e.printStackTrace();   
34.     
35.   }   
36.     
37.   }   
38.     
39.   }   

  下面这个Java程序的程序入口是没有实例控制功能的：     

1.    public     class    ProgramMain   {   
2.     
3.    public     static     void    main(String   argv[])   
4.     
5.   {   
6.     
7.   mainFrame   frame   =    new    mainFrame();   
8.     
9.   }   
10.     
11.   }   

       
  现在想加入实例控制，只需要添加两行代码，添加后代码如下所示：     

1.   public     class    ProgramMain   {   
2.     
3.    public     static     void    main(String   argv[])   
4.     
5.   {   
6.     
7.   InstanceControl   ic   =    new    InstanceControl();   
8.     
9.   ic.start();   
10.     
11.   mainFrame   frame   =    new    mainFrame();   
12.     
13.   }   
14.     
15.   }   

  在这个基础上，要实现第二种情况，也就是已经有实例运行的情况下，新的实例退出，保持原有的运行实例，就只需要一点小的改动了。具体的实现如下：     

1. import    java.net.*;   
2.     
3.    public     class    InstanceControl2    extends    Thread   {   
4.     
5.    public     void    run()   {   
6.     
7.    try {   
8.     
9.   Socket   sock   =    new    Socket( "127.0.0.1" ,    22222 ); //创建socket,连接22222端口   
10.     
11.   System.exit( 0 );    //连接成功，说明有实例存在，则退出   
12.     
13.   } catch    (Exception   e)   
14.     
15.   {}   
16.     
17.    try {   
18.     
19.   ServerSocket   server   =    new    ServerSocket( 22222 ); //创建socket，连接22222端口   
20.     
21.    while    ( true )   
22.     
23.   {   
24.     
25.   server.accept();    //接受连接请求   
26.     
27.   }   
28.     
29.   } catch    (Exception   e)   
30.     
31.   {   
32.     
33.   e.printStackTrace();   
34.     
35.   }   
36.     
37.   }   
38.     
39.   }   
40.     

  这个类的使用方法和第一种情况的那个类是一样的，只需要在原有的代码上加入两行代码即可：  

1.   InstanceControl2   ic   =    new    InstanceControl();   
2.     
3.   ic.start();   

  扩展   

  上面的程序也许有一个小bug，就是如果程序在开始运行时ServerSocket监听的端口已经被其它程序占用，那么程序的运行就会受到影响。所以程序的端口应该尽量取得大一些，在这种情况下其它程序占用这个程序使用的端口的概率是可以忽略不计的。同时，还可以做两种扩展，第一种是把端口写在配置文件中，可通过读配置文件得到端口，这样就能够在其它程序占用目前端口的情况下改变这个程序使用的端口。还有一种是在运行的时候用两个InstanceControl类分别在两个端口监听，只要有一个InstanceControl类得到连接就做出响应，这样两个端口都被其它程序占用的概率就更加的微乎其微了。