swing判断程序是否已经运行

Question

我用swing写了个程序
当这个程序运行并托盘时，再点击一次桌面开始启动这个程序
第一次已经运行表示创建了一个进程
但第二次点击运行表示又要创建一个新的进程，程序再次运行，两个程序不相干
我现在希望这样
假如第一次运行程序为托盘状态
第二次再点击时，去判断第一次的进程，得到程序运行的状态，让第一次运行的程序显示出来
如果不为托盘状态就保持原样
不再创建新的进程说了这么多
大家看看迅雷和快拨就明白了啊
来个高人指点哈啊
万分感激

Answer 1

现在只会做使得应用程序只能启动一个进程，点击图标显示已经本程序已经启动的进程，不知道是不是需要调用系统的api，这个你自己查一下吧。同一个程序同时只能启动一个实例的代码
import java.io.File;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;public class SingleApplication {
    // 在应用程序的main方法里调用此函数保证程序只有一个实例在运行.
    public static void makeSingle(String singleId) {
        RandomAccessFile raf = null;
        FileChannel channel = null;
        FileLock lock = null;        try {
            // 在临时文件夹创建一个临时文件，锁住这个文件用来保证应用程序只有一个实例被创建.
            File sf = new File(System.getProperty("java.io.tmpdir") + singleId + ".single");
            sf.deleteOnExit();
            sf.createNewFile();            raf = new RandomAccessFile(sf, "rw");
            channel = raf.getChannel();
            lock = channel.tryLock();            if (lock == null) {
                // 如果没有得到锁，则程序退出.
                // 没有必要手动释放锁和关闭流，当程序退出时，他们会被关闭的.
                throw new Error("An instance of the application is running.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }    public static void main(String[] args) throws Exception {
        SingleApplication.makeSingle("single.test"); // 保证程序只有一个实例在运行.        // 测试: 模拟一个程序正在运行5秒
        System.out.println("Start");
        System.out.println("Waiting 5 seconds.");        for (int i = 0; i < 5; ++i) {
            Thread.sleep(1000);
            System.out.println((i + 1) + "......");
        }        System.out.println("End");
    }
}

Answer 2

运行程序的时候先通过访问任务管理器来判断程序是否已经启动
window 下 cmd /c Tasklist /v
unix linux ps -ef | grep 用户
如果有的话就让程序最大化..（这步我还没有想好）

Answer 3

import java.io.File;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;
import java.util.RandomAccess;
import javax.swing.JOptionPane;public class A1 {private FileChannel channel;private FileLock lock;private File file;public A1(String lockFileName) {
   file = new File(lockFileName);
}public boolean isAppActive() {
   try {
    channel = new RandomAccessFile(file, "rw").getChannel();
    try {
     lock = channel.tryLock();    } catch (OverlappingFileLockException e) {
     closeLock();
     return true;
    }
    if (lock == null) {
     closeLock();
     return true;
    }
    Runtime.getRuntime().addShutdownHook(new Thread() {
     public void run() {
      closeLock();
      deleteFile();
     }
    });
    return false;
   } catch (Exception e) {
    closeLock();
    return true;
   }
}protected void deleteFile() {
   try {
    file.delete();
   } catch (Exception e) {   }}private void closeLock() {
   try {
    lock.release();
   } catch (Exception e) {   }   try {
    channel.close();
   } catch (Exception e) {   }}public static void main(String[] args) {
   A1 a = new A1(".lock");
   if (a.isAppActive() == true)
    JOptionPane.showMessageDialog(null, "已有一个程序在运行,程序退出");   try {
    Thread.sleep(10000);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }}}

Answer 4

very easy 可以用序列化通信或者socket也行。
第一次已经打开的进程要实时监视该端口或者文件，如果发生变化，读取出来 执行命令
Thread serverSocketThread = new Thread() {
public void run() {
// 开始监听一个端口，保证只有一个实例.
try {
ServerSocket serverSocket = new ServerSocket(INFORMATION_PORT);
while (started) {
Socket socket = serverSocket.accept(); // 接收客户连接 BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter writer = new PrintWriter(socket.getOutputStream());
String line = null;
while ((line = reader.readLine()) != null) {
if(line =="某某命令"){
执行最大化操作
} if (STOP.equals(line)) {
started = false;
break;
}
} writer.close();
reader.close();
socket.close();
} serverSocket.close();
} catch (IOException e) { }
}
}; serverSocketThread.start();

Answer 5

/**
 * 向服务器发送命令行，给服务器端处理
 */
public static void clientSend(String[] lines) {
if (lines != null && lines.length <= 0) {
return;
}
try {
Socket socket = new Socket("localhost", SingleServerSork.INFORMATION_PORT); PrintWriter writer = new PrintWriter(socket.getOutputStream());
for (int i = 0; i < lines.length; i++) {
writer.println(lines[i]);
} writer.flush();
writer.close();
socket.close();
} catch (Exception e) {
FRContext.getLogger().error(e.getMessage(), e);
}
}