判断程序实例是否已经运行的N种方法

转自：http://socol.iteye.com/blog/687728

1.  在创建的文件中写入进程的ID，如果机器非正常退出，重启后先读取这个文件，得到进程ID，再根据ID判定进程是否正在运行，如果不是，则把文件删除掉。这样就不会发生不删除文件，程序运行不起来的问题了。

2.  打开一个文件，然后锁定，新运行的程序会试图再次锁定该文件，但是因为已经被锁定，所以会返回错误信息。据此就可以判断是否有程序已经运行。设置FD_CLOEXEC后，只要程序终止，都可以再次锁定。

通常精灵进程都使用这种方法，比如apache等等，而且默认都会在/var/run目录

Qt代码  

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. #include <fcntl.h>  
4. #include <signal.h>  
5. #include <unistd.h>  
6. #include <sys/stat.h>  
7. #include <errno.h>  
8. #include <QtCore/QCoreApplication>  
9. #include <QDebug>  
10. #define PIDFILE "/var/run/my.pid"  
11. #define write_lock(fd,offset,whence,len) lock_reg(fd,F_SETLK,F_WRLCK,offset,whence,len)  
12. #define FILE_MODE (S_IRWXU|S_IRWXG|S_IRWXO)  
13. int lock_reg (int fd, int cmd, int type, off_t offset, int whence, off_t len)  
14. {  
15.     struct flock lock;  
16.     lock.l_type = type;  
17.     lock.l_start = offset;  
18.     lock.l_whence = whence;  
19.     lock.l_len = len;  
20.     int ret = fcntl(fd, cmd, &lock);  
21.     return ret;  
22. }  
23. bool isSingleton()  
24. {  
25.     int fd,val;  
26.     char buf[10];  
27.     if ((fd = open(PIDFILE, O_WRONLY|O_CREAT, FILE_MODE)) < 0) {  
28.         qDebug() << "daemon need run by root. open" << PIDFILE << "error.";  
29.         return false;  
30.     }  
31.     if(write_lock(fd, 0, SEEK_SET, 0) < 0)  
32.     {  
33.         if (errno == EACCES || errno == EAGAIN)  
34.             qDebug() << "daemon has been in running!";  
35.         else  
36.             qDebug() << "daemon other error.";  
37.         return false;  
38.     }  
39.     if (ftruncate(fd, 0) < 0) {  
40.         qDebug() << "ftruncate error.";  
41.         return false;  
42.     }  
43.     sprintf(buf,"%d\n",getpid());  
44.     if (write(fd, buf, strlen(buf)) != strlen(buf)) {  
45.         qDebug() << "pid write error.";  
46.         return false;  
47.     }  
48.     // close file descriptor  
49.     if ((val = fcntl(fd, F_GETFD, 0)) < 0) {  
50.         qDebug() << "fcntl F_GETFD error.";  
51.         return false;  
52.     }  
53.     val |= FD_CLOEXEC;  
54.     if (fcntl(fd, F_SETFD, val) < 0) {  
55.         qDebug() << "fcntl F_SETFD error.";  
56.         return false;  
57.     }  
58.     return true;  
59. }  
60. void initDaemon(void)  
61. {  
62.     pid_t pid, sid;  
63.     if((pid = fork()) < 0)  
64.         return;  
65.     else if(pid != 0)  
66.         exit(0);   
67.     sid = setsid();   
68.     if (sid < 0) {  
69.         exit(-1);  
70.     }  
71.     if ((chdir("/")) < 0) {  
72.         exit(-1);  
73.     }  
74.     umask(0);   
75. #if 0  
76.     close(0);   
77.     close(1);   
78.     close(2);   
79. #endif  
80. }  
81. int main(int argc, char *argv[])  
82. {  
83.     initDaemon();  
84.     if (!isSingleton())  
85.         return 0;  
86.     QCoreApplication a(argc, argv);  
87.     return a.exec();  
88. }  

3. 遍历/proc目录下的进程信息，如果应用程序对应的进程存在，则让认为应用程序已经在运行。然后强制关闭该应用程序，用新的命令行参数重新运行 它。这样做的优点是实现简单，到达了我们预期的目标。缺点是强制kill第一个运行实例太野蛮，可能会造成数据丢失，另外创建新进程的开销会让用户感觉反 应迟钝。

C代码  

1. static gchar *  
2. pid_to_binary_name (gint pid)  
3. {  
4.   gchar * cmd_f;  
5.   FILE  * fcmd;  
6.   if (pid <= 0)  
7.     return NULL;  
8.   cmd_f = g_strdup_printf ("/proc/%d/cmdline", pid);  
9.   fcmd  = fopen (cmd_f, "r");  
10.   g_free (cmd_f);  
11.   if (fcmd)  
12.     {  
13.       gchar buf[256];  
14.       if (fgets (buf, sizeof (buf), fcmd))  
15.         {  
16.           gchar *n = &buf[0];  
17.           while ((n < &buf[0] + sizeof(buf) - 1) && *n && !g_ascii_isspace (*n))  
18.             ++n;  
19.           *n = 0;  
20.           return g_path_get_basename (buf);  
21.         }  
22.       fclose (fcmd);  
23.     }  
24.   return NULL;  
25. }  

4. 通过窗口管理器实现，根据应用程序的窗口判断应用程序是否在运行。如果发现对应的应用程序已经在运行，把对应的窗口提到 前面来。这要修改应用程序才行，只有应用程序自己才知道其拥有的窗口的关系，若不加考虑把应用程序的主窗口提到前面来，这也并不见得合适。这种方法只能解 决前两个小问题，命令行参数还是无法传递给第一个运行实例。

5. 应用程序提供一个DBUS服务对象，第一个运行实例作为服务器运行， 第二个运行实例作为客户端运行，第二个运行实例把命令行参数传递给第一个运行实例,然后就退出。第一个运行实例接受到新的命令行参数，作相应的处理，比 如，把相应的窗口提到前面来，根据命令行参数进行处理。这是第二种方法的改进，可以实现全部的功能，缺点是要修改应用程序，不过DBUS服务对象可以通过 一个公共库来实现，应用程序的改动并不大。

6. 使用信号量

信号量知识：

http://www.cublog.cn/u/19185/showart_2034149.html

http://www.ibm.com/developerworks/cn/linux/l-osmig1.html

信号量实例：

C代码  

1. #include<stdio.h>  
2. #include<pthread.h>  
3. #include<unistd.h>  
4. #include<fcntl.h>  
5. #include<sys/stat.h>  
6. #include<sys/types.h>  
7. #include<semaphore.h>  
8. #include<stdlib.h>  
9. #define N 3  
10. pthread_mutex_t mutex_w,mutex_r; // 定义读写互斥锁   
11. sem_t sem_w,sem_r; //定义读写信号量   
12.  int data[N];  
13. int pos=0;  
14. void *function_w(void *arg)  
15. {   
16.  int w = *(int *)arg;  
17.  pos = w;  
18.  while(1)  
19.  {  
20.   usleep(100000);  
21.   sem_wait(&sem_w);//等待可写的资源   
22.   pthread_mutex_lock(&mutex_w);//禁止别的线程写此资源   
23.   data[pos] = w;  
24.   w++;  
25.   w++;  
26.   w++;  
27.   pos++;  
28.   pos=pos%N;  
29.   pthread_mutex_unlock(&mutex_w);//别的线程可写此资源   
30.   sem_post(&sem_r);// 释放一个读资源  
31.  }  
32.  return (void *)0;  
33. }  
34. void *function_r(void *arg)  
35. {  
36.  while(1)  
37.  {  
38.   sem_wait(&sem_r);//等待可读的资源   
39.   pthread_mutex_lock(&mutex_r);//禁止别的线程读此资源   
40.   printf("%d\n",data[(pos+N-1)%N]);  
41.   pthread_mutex_unlock(&mutex_r);//别的线程可读此资源   
42.   sem_post(&sem_w);// 释放一个写资源  
43.  }  
44.  return (void *)0;  
45. }  
46. int main(int argc, char **argv)  
47. {  
48.  pthread_t thread[2*N];  
49.  int i;  
50.  pthread_mutex_init(&mutex_w,NULL);  
51.  pthread_mutex_init(&mutex_r,NULL);  
52.  sem_init(&sem_w,0,N);  
53.  sem_init(&sem_r,0,0);  
54.  for(i=0;i<N;i++)  
55.  {  
56.   if ( pthread_create(&thread[i],NULL,function_w,(void *)&i) < 0)//创建写线程   
57.   {  
58.    perror("pthread_create");  
59.    exit(-1);  
60.   }  
61.  }  
62.  for(i=N;i<2*N;i++)  
63.  {  
64.   if ( pthread_create(&thread[i],NULL,function_r,NULL) < 0)//创建读线程   
65.   {  
66.    perror("pthread_create");  
67.    exit(-1);  
68.   }  
69.  }  
70.  sleep(1);  
71.  return(0);  
72. }   

7. 绑定某一个socket端口, 下次运行就无法再次绑定而退出.