在Linux下如何保证只创建一个进程

在Linux下，如果不加限制，同一个程序，可以有多个运行实例，也称之为进程．它们都有一样的名字，执行着一样的代码段．不同的是，它们拥有不同的pid以及进程空间．有时候，希望同一时间只能创建一个进程．下面这段示例代码就加了这样一个限制．

核心点：

1. 进程在启动时，判断/tmp/my_pid_file是否存在；如果不存在，则将当前进程的pid写入，程序继续运行；

2. 如果/tmp/my_pid_file已经存在但无内容，则将当前进程的pid写入，程序继续运行；

3. 如果/tmp/my_pid_file已经存在且有内容，读取并判断该值指向的pid是否正在运行。如果没有，则将当前进程的pid写入，程序继续运行；否则，当前进程退出。使用了 kill(pid, 0) 进行检测．

4. 在收到SIGINT和SIGTERM时，先删除/tmp/my_pid_file，再退出．

single_app.c:

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>

#define MY_PID_FILE     "/tmp/my_pid_file"
#define BUF_LEN_FOR_PID 64


static int write_pid_into_fd(int fd, pid_t pid)
{
	int ret = -1;
	char buf[BUF_LEN_FOR_PID] = {0};

	/* Move cursor to the start of file. */
	lseek(fd, 0, SEEK_SET);

	sprintf(buf, "%d", pid);
	ret = write(fd, buf, strlen(buf));
	if(ret <= 0) { /* Write fail or write 0 byte */
		if(ret == -1) 
			perror("Write "MY_PID_FILE" fail\n");

		ret = -1;
	} else {
		printf("Create "MY_PID_FILE" ok, pid=%d\n", pid);
		ret = 0;
	}

	return ret;
}

/*
 * Create MY_PID_FILE, write pid into it.
 *
 * @return: 0 is ok, -1 is error.
 */
static int create_pid_file(pid_t pid)
{
	int fd, ret;
	char buf[BUF_LEN_FOR_PID] = {0};

	fd = open(MY_PID_FILE, O_WRONLY | O_CREAT | O_EXCL, 0666);  /* rw-rw-rw- */
	if(fd == -1) {
		perror("Create "MY_PID_FILE" fail\n");
		return -1;
	} 

	ret = flock(fd, LOCK_EX);
	if(ret == -1) {
		perror("flock "MY_PID_FILE" fail\n");
		close(fd);
		return -1;
	}

	ret = write_pid_into_fd(fd, pid);

	flock(fd, LOCK_UN);
	close(fd);
	
	return ret;
}

/*
 * If pid file already exists, check the pid value in it.
 * If pid from file is still running, this program need exit();
 * If it is not running, write current pid into file.
 *
 * @return: 0 is ok, -1 is error.
 */
static int check_pid_file(int fd, pid_t pid)
{
	int ret = -1;
	pid_t old_pid;
	char buf[BUF_LEN_FOR_PID] = {0};

	ret = flock(fd, LOCK_EX);
	if(ret == -1) {
		perror("flock "MY_PID_FILE" fail\n");
		return -1;
	}

	ret = read(fd, buf, sizeof(buf)-1);
	if(ret < 0) {  /* read error */
		perror("read from "MY_PID_FILE" fail\n");
		ret = -1;
	} else if(ret > 0) {  /* read ok */
		old_pid = atol(buf);

		/* Check if old_pid is running */
		ret = kill(old_pid, 0);
		if(ret < 0) {
			if(errno == ESRCH) { /* old_pid is not running. */
				ret = write_pid_into_fd(fd, pid);
			} else {
				perror("send signal fail\n");
				ret = -1;
			}
		} else {  /* running */
			printf("Program already exists, pid=%d\n", old_pid);
			ret = -1;
		}
	} else if(ret == 0) { /* read 0 byte from file */
		ret = write_pid_into_fd(fd, pid);
	}

	flock(fd, LOCK_UN);

	return ret;
}

/*
 * It will create the only one pid file for app.
 * 
 * @return: 0 is ok, -1 is error.
 */
static int init_pid_file()
{
	pid_t pid;
	int fd, ret;
	
	pid = getpid();

	fd = open(MY_PID_FILE, O_RDWR);
	if(fd == -1) {  /* open file fail */
		if(errno == ENOENT) {  /* No such file. Create one for this program. */
			ret = create_pid_file(pid);
		} else {
			perror("open "MY_PID_FILE" fail\n");
			ret = -1;
		}
	} else {  /* pid file already exists */
		ret = check_pid_file(fd, pid);
		close(fd);
	}

	return ret;
}

static void sigHandler(int sig)
{
	if(sig == SIGINT || sig == SIGTERM)
		remove(MY_PID_FILE);

	_exit(0);
}


int main()
{
	if(-1 == init_pid_file()) {
		exit(-1);
	}

	/* Ctrl + C */
	if(signal(SIGINT, sigHandler) == SIG_ERR) {
		exit(-1);
	}

	/* kill pid / killall name */
	if(signal(SIGTERM, sigHandler) == SIG_ERR) {
		exit(-1);
	}

	while(1)
		sleep(3);

	return 0;
}