如何用 C 或 C++ 创建单实例应用程序

问题描述：

为了创建单实例应用程序，您有什么建议，以便每次只允许运行一个进程？文件锁、互斥锁还是其他？

解决方案 1：

一个好方法是：

#include <sys/file.h>
#include <errno.h>

int pid_file = open("/var/run/whatever.pid", O_CREAT | O_RDWR, 0666);
int rc = flock(pid_file, LOCK_EX | LOCK_NB);
if(rc) {
    if(EWOULDBLOCK == errno)
        ; // another instance is running
}
else {
    // this is the first instance
}

请注意，锁定允许您忽略陈旧的 pid 文件（即您不必删除它们）。当应用程序因任何原因终止时，操作系统会为您释放文件锁定。

Pid 文件不是很有用，因为它们可能过时（文件存在但进程不存在）。因此，可以锁定应用程序可执行文件本身，而不是创建并锁定 pid 文件。

更高级的方法是使用预定义的套接字名称创建并绑定 unix 域套接字。对于应用程序的第一个实例，绑定成功。同样，当应用程序因任何原因终止时，操作系统会解除套接字的绑定。当bind()失败时，应用程序的另一个实例可以connect()使用此套接字将其命令行参数传递给第一个实例。

解决方案 2：

这是用 C++ 编写的解决方案。它使用了 Maxim 的套接字建议。我更喜欢这个解决方案，而不是基于文件的锁定解决方案，因为如果进程崩溃并且不删除锁定文件，基于文件的解决方案就会失败。另一个用户将无法删除该文件并锁定它。进程退出时，套接字会自动删除。

用法：

int main()
{
   SingletonProcess singleton(5555); // pick a port number to use that is specific to this app
   if (!singleton())
   {
     cerr << "process running already. See " << singleton.GetLockFileName() << endl;
     return 1;
   }
   ... rest of the app
}

代码：

#include <netinet/in.h>

class SingletonProcess
{
public:
    SingletonProcess(uint16_t port0)
            : socket_fd(-1)
              , rc(1)
              , port(port0)
    {
    }

    ~SingletonProcess()
    {
        if (socket_fd != -1)
        {
            close(socket_fd);
        }
    }

    bool operator()()
    {
        if (socket_fd == -1 || rc)
        {
            socket_fd = -1;
            rc = 1;

            if ((socket_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
            {
                throw std::runtime_error(std::string("Could not create socket: ") +  strerror(errno));
            }
            else
            {
                struct sockaddr_in name;
                name.sin_family = AF_INET;
                name.sin_port = htons (port);
                name.sin_addr.s_addr = htonl (INADDR_ANY);
                rc = bind (socket_fd, (struct sockaddr *) &name, sizeof (name));
            }
        }
        return (socket_fd != -1 && rc == 0);
    }

    std::string GetLockFileName()
    {
        return "port " + std::to_string(port);
    }

private:
    int socket_fd = -1;
    int rc;
    uint16_t port;
};

解决方案 3：

对于 Windows，是一个命名的内核对象（例如 CreateEvent、CreateMutex）。对于 UNIX，是一个 pid 文件 - 创建一个文件并将您的进程 ID 写入其中。

解决方案 4：

您可以创建一个“匿名命名空间”AF_UNIX 套接字。这完全是 Linux 特有的，但其优点是实际上不需要存在任何文件系统。

阅读 unix(7) 的手册页以了解更多信息。

解决方案 5：

避免基于文件的锁定

避免使用基于文件的锁定机制来实现应用程序的单例实例总是好的。用户可以随时将锁定文件重命名为其他名称，然后再次运行应用程序，如下所示：

mv lockfile.pid lockfile1.pid

lockfile.pid在运行应用程序之前检查其是否存在的锁定文件在哪里。

因此，最好对仅对内核可见的对象使用锁定方案。因此，与文件系统有关的任何事情都不可靠。

因此，最好的选择是绑定到 inet 套接字。请注意，unix 域套接字驻留在文件系统中，并且不可靠。

或者，您也可以使用 DBUS 来完成。

解决方案 6：

似乎没有提到——可以在共享内存中创建互斥锁，但需要通过属性标记为共享（未经测试）：

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
pthread_mutex_t *mutex = shmat(SHARED_MEMORY_ID, NULL, 0);
pthread_mutex_init(mutex, &attr);

还有共享内存信号量（但我不知道如何锁定它）：

int sem_id = semget(SHARED_MEMORY_KEY, 1, 0);

解决方案 7：

没有人提到过，但sem_open()在现代 POSIX 兼容操作系统下会创建一个真正的命名信号量。如果给信号量赋予初始值 1，它就会变成互斥量（只要它严格地仅在成功获得锁时才被释放）。

使用多个sem_open()基于 的对象，您可以创建所有常见的等效 Windows 命名对象 - 命名互斥、命名信号量和命名事件。将“manual”设置为 true 的命名事件更难模拟（需要四个信号量对象才能正确模拟CreateEvent()、SetEvent()和ResetEvent()）。无论如何，我离题了。

或者，有命名共享内存。您可以在命名共享内存中使用“共享进程”属性初始化 pthread 互斥锁，然后所有进程都可以在使用shm_open()/打开共享内存的句柄后安全地访问该互斥锁对象mmap()。 sem_open()如果它适用于您的平台，则更容易（如果不是，则应该出于理智的考虑）。

无论使用哪种方法，要测试应用程序的单个实例，请使用trylock()wait 函数的变体（例如sem_trywait()）。如果该进程是唯一正在运行的进程，它将成功锁定互斥锁。如果不是，它将立即失败。

不要忘记在应用程序退出时解锁并关闭互斥锁。

解决方案 8：

这将取决于您想通过强制应用程序只有一个实例来避免哪个问题以及您考虑实例的范围。

对于守护进程来说 — — 通常的方法是拥有一个/var/run/app.pid文件。

对于用户应用程序，我遇到的问题多于无法运行两次应用程序，而无法运行两次不应该运行的应用程序。因此，回答“为什么以及在哪个范围内”非常重要，并且可能会带来关于为什么和预期范围的具体答案。

解决方案 9：

这是一个基于 sem_open 的解决方案

/*
*compile with :
*gcc single.c -o single -pthread
*/

/*
 * run multiple instance on 'single', and check the behavior
 */
#include <stdio.h>
#include <fcntl.h>    
#include <sys/stat.h>        
#include <semaphore.h>
#include <unistd.h>
#include <errno.h>

#define SEM_NAME "/mysem_911"

int main()
{
  sem_t *sem;
  int rc; 

  sem = sem_open(SEM_NAME, O_CREAT, S_IRWXU, 1); 
  if(sem==SEM_FAILED){
    printf("sem_open: failed errno:%d
", errno);
  }

  rc=sem_trywait(sem);

  if(rc == 0){ 
    printf("Obtained lock !!!
");
    sleep(10);
    //sem_post(sem);
    sem_unlink(SEM_NAME);
  }else{
    printf("Lock not obtained
");
  }
}

另一个答案的评论之一是“我发现 sem_open() 相当缺乏”。我不确定缺乏的具体内容

解决方案 10：

根据maxim 的回答中的提示，这是我的双重角色守护进程的 POSIX 解决方案（即，可以充当守护进程和与该守护进程通信的客户端的单个应用程序）。此方案的优点是提供了一个优雅的问题解决方案，当首先启动的实例应该是守护进程时，所有后续执行都应该只在该守护进程上加载工作。这是一个完整的示例，但缺少很多真正的守护进程应该做的事情（例如，用于syslog日志记录并fork正确地将自己置于后台，放弃权限等），但它已经很长并且完全可以正常工作。到目前为止，我只在 Linux 上测试过它，但 IIRC 它应该完全兼容 POSIX。

在示例中，客户端可以将整数作为第一个命令行参数传递给它们，并通过atoi套接字将其解析到守护进程，然后守护进程将其打印到stdout。使用这种套接字，还可以传输数组、结构甚至文件描述符（请参阅man 7 unix）。

#include <stdio.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_NAME "/tmp/exampled"

static int socket_fd = -1;
static bool isdaemon = false;
static bool run = true;

/* returns
 *   -1 on errors
 *    0 on successful server bindings
 *   1 on successful client connects
 */
int singleton_connect(const char *name) {
    int len, tmpd;
    struct sockaddr_un addr = {0};

    if ((tmpd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
        printf("Could not create socket: '%s'.
", strerror(errno));
        return -1;
    }

    /* fill in socket address structure */
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path, name);
    len = offsetof(struct sockaddr_un, sun_path) + strlen(name);

    int ret;
    unsigned int retries = 1;
    do {
        /* bind the name to the descriptor */
        ret = bind(tmpd, (struct sockaddr *)&addr, len);
        /* if this succeeds there was no daemon before */
        if (ret == 0) {
            socket_fd = tmpd;
            isdaemon = true;
            return 0;
        } else {
            if (errno == EADDRINUSE) {
                ret = connect(tmpd, (struct sockaddr *) &addr, sizeof(struct sockaddr_un));
                if (ret != 0) {
                    if (errno == ECONNREFUSED) {
                        printf("Could not connect to socket - assuming daemon died.
");
                        unlink(name);
                        continue;
                    }
                    printf("Could not connect to socket: '%s'.
", strerror(errno));
                    continue;
                }
                printf("Daemon is already running.
");
                socket_fd = tmpd;
                return 1;
            }
            printf("Could not bind to socket: '%s'.
", strerror(errno));
            continue;
        }
    } while (retries-- > 0);

    printf("Could neither connect to an existing daemon nor become one.
");
    close(tmpd);
    return -1;
}

static void cleanup(void) {
    if (socket_fd >= 0) {
        if (isdaemon) {
            if (unlink(SOCKET_NAME) < 0)
                printf("Could not remove FIFO.
");
        } else
            close(socket_fd);
    }
}

static void handler(int sig) {
    run = false;
}

int main(int argc, char **argv) {
    switch (singleton_connect(SOCKET_NAME)) {
        case 0: { /* Daemon */

            struct sigaction sa;
            sa.sa_handler = &handler;
            sigemptyset(&sa.sa_mask);
            if (sigaction(SIGINT, &sa, NULL) != 0 || sigaction(SIGQUIT, &sa, NULL) != 0 || sigaction(SIGTERM, &sa, NULL) != 0) {
                printf("Could not set up signal handlers!
");
                cleanup();
                return EXIT_FAILURE;
            }

            struct msghdr msg = {0};
            struct iovec iovec;
            int client_arg;
            iovec.iov_base = &client_arg;
            iovec.iov_len = sizeof(client_arg);
            msg.msg_iov = &iovec;
            msg.msg_iovlen = 1;

            while (run) {
                int ret = recvmsg(socket_fd, &msg, MSG_DONTWAIT);
                if (ret != sizeof(client_arg)) {
                    if (errno != EAGAIN && errno != EWOULDBLOCK) {
                        printf("Error while accessing socket: %s
", strerror(errno));
                        exit(1);
                    }
                    printf("No further client_args in socket.
");
                } else {
                    printf("received client_arg=%d
", client_arg);
                }

                /* do daemon stuff */
                sleep(1);
            }
            printf("Dropped out of daemon loop. Shutting down.
");
            cleanup();
            return EXIT_FAILURE;
        }
        case 1: { /* Client */
            if (argc < 2) {
                printf("Usage: %s <int>
", argv[0]);
                return EXIT_FAILURE;
            }
            struct iovec iovec;
            struct msghdr msg = {0};
            int client_arg = atoi(argv[1]);
            iovec.iov_base = &client_arg;
            iovec.iov_len = sizeof(client_arg);
            msg.msg_iov = &iovec;
            msg.msg_iovlen = 1;
            int ret = sendmsg(socket_fd, &msg, 0);
            if (ret != sizeof(client_arg)) {
                if (ret < 0)
                    printf("Could not send device address to daemon: '%s'!
", strerror(errno));
                else
                    printf("Could not send device address to daemon completely!
");
                cleanup();
                return EXIT_FAILURE;
            }
            printf("Sent client_arg (%d) to daemon.
", client_arg);
            break;
        }
        default:
            cleanup();
            return EXIT_FAILURE;
    }

    cleanup();
    return EXIT_SUCCESS;
}

解决方案 11：

所有功劳都归功于 Mark Lakata。我只是做了一些非常小的修饰。

主程序

#include "singleton.hpp"
#include <iostream>
using namespace std;
int main()
{
   SingletonProcess singleton(5555); // pick a port number to use that is specific to this app
   if (!singleton())
   {
     cerr << "process running already. See " << singleton.GetLockFileName() << endl;
     return 1;
   }
   // ... rest of the app
}

单例.hpp

#include <netinet/in.h>
#include <unistd.h>
#include <cerrno>
#include <string>
#include <cstring>
#include <stdexcept>

using namespace std;
class SingletonProcess
{
public:
    SingletonProcess(uint16_t port0)
            : socket_fd(-1)
              , rc(1)
              , port(port0)
    {
    }

    ~SingletonProcess()
    {
        if (socket_fd != -1)
        {
            close(socket_fd);
        }
    }

    bool operator()()
    {
        if (socket_fd == -1 || rc)
        {
            socket_fd = -1;
            rc = 1;

            if ((socket_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
            {
                throw std::runtime_error(std::string("Could not create socket: ") +  strerror(errno));
            }
            else
            {
                struct sockaddr_in name;
                name.sin_family = AF_INET;
                name.sin_port = htons (port);
                name.sin_addr.s_addr = htonl (INADDR_ANY);
                rc = bind (socket_fd, (struct sockaddr *) &name, sizeof (name));
            }
        }
        return (socket_fd != -1 && rc == 0);
    }

    std::string GetLockFileName()
    {
        return "port " + std::to_string(port);
    }

private:
    int socket_fd = -1;
    int rc;
    uint16_t port;
};

解决方案 12：

#include <windows.h>

int main(int argc, char *argv[])
{
    // ensure only one running instance
    HANDLE hMutexH`enter code here`andle = CreateMutex(NULL, TRUE, L"my.mutex.name");
    if (GetLastError() == ERROR_ALREADY_EXISTS)
    {
        return 0;
    }
    
    // rest of the program

    ReleaseMutex(hMutexHandle);
    CloseHandle(hMutexHandle);
    
    return 0;
}

来源：这里

解决方案 13：

在 Windows 上，您还可以创建共享数据段并使用互锁函数来测试第一次出现的情况，例如

#include <Windows.h>
#include <stdio.h>
#include <conio.h>

#pragma data_seg("Shared")
volatile LONG lock = 0;
#pragma data_seg()
#pragma comment(linker, "/SECTION:Shared,RWS")

void main()
{
  if (InterlockedExchange(&lock, 1) == 0)
    printf("first
");
  else
    printf("other
");

  getch();
}

解决方案 14：

我刚刚写了一个，并进行了测试。

#define PID_FILE "/tmp/pidfile"
static void create_pidfile(void) {
    int fd = open(PID_FILE, O_RDWR | O_CREAT | O_EXCL, 0);

    close(fd);
}

int main(void) {
    int fd = open(PID_FILE, O_RDONLY);
    if (fd > 0) {
        close(fd);
        return 0;
    }

    // make sure only one instance is running
    create_pidfile();
}

解决方案 15：

只需在单独的线程上运行此代码：

void lock() {
  while(1) {
    ofstream closer("myapplock.locker", ios::trunc);
    closer << "locked";
    closer.close();
  }
}

将其作为主代码运行：

int main() {
  ifstream reader("myapplock.locker");
  string s;
  reader >> s;
  if (s != "locked") {
  //your code
  }
  return 0;
}