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

最新推荐文章于 2024-06-30 22:06:28 发布

Hansel

最新推荐文章于 2024-06-30 22:06:28 发布

阅读量4k

点赞数

分类专栏： Linux开发文章标签： null function descriptor cmd thread file

Linux开发专栏收录该内容

69 篇文章 2 订阅

订阅专栏

From: http://socol.iteye.com/blog/687728

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

2. 打开一个文件，然后锁定，新运行的程序会试图再次锁定该文件，但是因为已经被锁定，所以会返回错误信息。据此就可以判断是否有程序已经运行。设置FD_CLOEXEC后，只要程序终止，都可以再次锁定。
通常精灵进程都使用这种方法，比如apache等等，而且默认都会在/var/run目录

Qt代码

    #include <stdlib.h>  
    #include <stdio.h>  
    #include <fcntl.h>  
    #include <signal.h>  
    #include <unistd.h>  
    #include <sys/stat.h>  
    #include <errno.h>  
      
    #include <QtCore/QCoreApplication>  
    #include <QDebug>  
      
    #define PIDFILE "/var/run/my.pid"  
    #define write_lock(fd,offset,whence,len) lock_reg(fd,F_SETLK,F_WRLCK,offset,whence,len)  
    #define FILE_MODE (S_IRWXU|S_IRWXG|S_IRWXO)  
      
    int lock_reg (int fd, int cmd, int type, off_t offset, int whence, off_t len)  
    {  
        struct flock lock;  
      
        lock.l_type = type;  
        lock.l_start = offset;  
        lock.l_whence = whence;  
        lock.l_len = len;  
      
        int ret = fcntl(fd, cmd, &lock);  
        return ret;  
    }  
      
    bool isSingleton()  
    {  
        int fd,val;  
        char buf[10];  
      
        if ((fd = open(PIDFILE, O_WRONLY|O_CREAT, FILE_MODE)) < 0) {  
            qDebug() << "daemon need run by root. open" << PIDFILE << "error.";  
            return false;  
        }  
      
        if(write_lock(fd, 0, SEEK_SET, 0) < 0)  
        {  
            if (errno == EACCES || errno == EAGAIN)  
                qDebug() << "daemon has been in running!";  
            else  
                qDebug() << "daemon other error.";  
            return false;  
        }  
      
        if (ftruncate(fd, 0) < 0) {  
            qDebug() << "ftruncate error.";  
            return false;  
        }  
      
        sprintf(buf,"%d\n",getpid());  
        if (write(fd, buf, strlen(buf)) != strlen(buf)) {  
            qDebug() << "pid write error.";  
            return false;  
        }  
      
        // close file descriptor  
        if ((val = fcntl(fd, F_GETFD, 0)) < 0) {  
            qDebug() << "fcntl F_GETFD error.";  
            return false;  
        }  
        val |= FD_CLOEXEC;  
        if (fcntl(fd, F_SETFD, val) < 0) {  
            qDebug() << "fcntl F_SETFD error.";  
            return false;  
        }  
      
        return true;  
    }  
      
    void initDaemon(void)  
    {  
        pid_t pid, sid;  
        if((pid = fork()) < 0)  
            return;  
        else if(pid != 0)  
            exit(0); /* parent exit */  
        /* child continues */  
        sid = setsid(); /* become session leader */  
        if (sid < 0) {  
            exit(-1);  
        }  
        /* change working directory */  
        if ((chdir("/")) < 0) {  
            exit(-1);  
        }  
        umask(0); /* clear file mode creation mask */  
    #if 0  
        close(0); /* close stdin */  
        close(1); /* close stdout */  
        close(2); /* close stderr */  
    #endif  
    }  
      
    int main(int argc, char *argv[])  
    {  
        initDaemon();  
      
        if (!isSingleton())  
            return 0;  
        QCoreApplication a(argc, argv);  
        return a.exec();  
    }

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

C代码

/* 
     * getpid shell: pidof XXX 
     * Returns the executable name for given pid. 
     */  
    static gchar *  
    pid_to_binary_name (gint pid)  
    {  
      gchar * cmd_f;  
      FILE  * fcmd;  
      
      if (pid <= 0)  
        return NULL;  
      
      cmd_f = g_strdup_printf ("/proc/%d/cmdline", pid);  
      fcmd  = fopen (cmd_f, "r");  
      
      g_free (cmd_f);  
      
      if (fcmd)  
        {  
          gchar buf[256];  
          if (fgets (buf, sizeof (buf), fcmd))  
            {  
              /* 
               * 0-terminate at first whitespace. 
               */  
              gchar *n = &buf[0];  
              while ((n < &buf[0] + sizeof(buf) - 1) && *n && !g_ascii_isspace (*n))  
                ++n;  
      
              *n = 0;  
      
              return g_path_get_basename (buf);  
            }  
      
          fclose (fcmd);  
        }  
      
      return NULL;  
    }

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代码

#include<stdio.h>  
#include<pthread.h>  
#include<unistd.h>  
#include<fcntl.h>  
#include<sys/stat.h>  
#include<sys/types.h>  
#include<semaphore.h>  
#include<stdlib.h>  
#define N 3  
pthread_mutex_t mutex_w,mutex_r; // 定义读写互斥锁   
sem_t sem_w,sem_r; //定义读写信号量   
  
 int data[N];  
int pos=0;  
void *function_w(void *arg)  
{   
 int w = *(int *)arg;  
 pos = w;  
 while(1)  
 {  
  usleep(100000);  
  sem_wait(&sem_w);//等待可写的资源   
  pthread_mutex_lock(&mutex_w);//禁止别的线程写此资源   
  data[pos] = w;  
  w++;  
  w++;  
  w++;  
  pos++;  
  pos=pos%N;  
  pthread_mutex_unlock(&mutex_w);//别的线程可写此资源   
  sem_post(&sem_r);// 释放一个读资源  
 }  
 return (void *)0;  
}  
void *function_r(void *arg)  
{  
 while(1)  
 {  
  sem_wait(&sem_r);//等待可读的资源   
  pthread_mutex_lock(&mutex_r);//禁止别的线程读此资源   
  printf("%d\n",data[(pos+N-1)%N]);  
  pthread_mutex_unlock(&mutex_r);//别的线程可读此资源   
  sem_post(&sem_w);// 释放一个写资源  
 }  
 return (void *)0;  
}  
int main(int argc, char **argv)  
{  
 pthread_t thread[2*N];  
  
 int i;  
   
  
 pthread_mutex_init(&mutex_w,NULL);  
 pthread_mutex_init(&mutex_r,NULL);  
 sem_init(&sem_w,0,N);  
 sem_init(&sem_r,0,0);  
   
 for(i=0;i<N;i++)  
 {  
  if ( pthread_create(&thread[i],NULL,function_w,(void *)&i) < 0)//创建写线程   
  {  
   perror("pthread_create");  
   exit(-1);  
  }  
 }  
  
 for(i=N;i<2*N;i++)  
 {  
  if ( pthread_create(&thread[i],NULL,function_r,NULL) < 0)//创建读线程   
  {  
   perror("pthread_create");  
   exit(-1);  
  }  
 }  
    
 sleep(1);  
  
 return(0);  
}

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