C++利用inotify+epoll实现异步文件监控的方法

#include <sys/epoll.h>
int epoll_create(int size);
##参数
- size：监听的事件数目；

#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
## 参数
- epfd：epoll_create()返回值；
- op：执行的操作。包括EPOLL_CTL_ADD、EPOLL_CTL_MOD、EPOLL_CTL_DEL；
- fd：文件描述符；
- event：结构体epoll_event的指针。
#### 结构体epoll_event
typedef union epoll_data
{
 	void *ptr; /* Pointer to user-defind data */
 	int fd; /* File descriptor */
 	uint32_t u32; /* 32-bit integer */
 	uint64_t u64; /* 64-bit integer */
} epoll_data_t;
struct epoll_event
{
 	uint32_t events; /* epoll events(bit mask) */
 	epoll_data_t data; /* User data */
};

#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout);
## 参数：
- epfd：epoll_create()返回值；
- events：evlist所指向的结构体数组中返回的是有关就绪态文件描述符的信息，数组evlist的空间由调用者负责申请；
- maxevents：指定所evlist数组里包含的元素个数；
- timeout：确定epoll_wait()的阻塞行为。<0：一直阻塞，0：执行一次非阻塞式地检查，>0：调用将阻塞至多timeout毫秒；

#include <sys/inotify.h>
int inotify_init(void);
## 返回值
- 返回文件描述符

#include <sys/inotify.h>
int inotify_add_watch(int fd, const char *pathname, uint32_t mask);
## 参数
- fd: inotify_init的返回值;
- pathname: 目录或文件路径;
- mask: 监控的事件类型;
## 返回值
- 针对pathname的watch描述符

#include <sys/inotify.h>
int inotify_rm_watch(int fd, int wd);
## 参数值
- fd: inotify_init的返回值;
- wd: inotify_add_watch的返回值;

#include <iostream>
#include <thread>
#include <sys/inotify.h>
#include <sys/epoll.h>
#include <unistd.h>
using namespace std;
#define   INOTIFY_FDS           200
#define   INOTIFY_EVENT_SIZE    (sizeof(struct inotify_event))
#define   INOTIFY_BUF_LEN       (1024*(INOTIFY_EVENT_SIZE + 16))
int main()
{
	// inotify初始化
	int inotifyId = inotify_init();
	if (-1 == inotifyId)
	{
		cout << "inotify_init failed" << endl;
		return -1;
	}
	// 创建epoll句柄
	int epfd = epoll_create(INOTIFY_FDS);
	if (-1 == epfd)
	{
		cout << "epoll_create failed" << endl;
		return -1;
	}
	// 注册epoll事件
	struct epoll_event ev;
	ev.data.fd = inotifyId;                
	ev.events = EPOLLIN | EPOLLET;      
	int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, inotifyId, &ev);
	if (-1 == ret)
	{
		cout << "epoll_ctl failed" << endl;
		return -1;
	}
	// 添加监听对象
	const char* pathMame = "/home/inotify/dir/";
	int watchFd = inotify_add_watch(inotifyId, pathMame, IN_MODIFY | IN_CREATE | IN_DELETE);
	if (watchFd < 0)
	{
		cout << "inotify_add_watch failed" << endl;
		return -1;
	}
	// 启动线程
	std::thread func = std::thread([&]() {
		// 循环监听事件
		char buf[INOTIFY_BUF_LEN] = { 0, };
		struct epoll_event events[20];
		while (1)
		{
			int nfds = epoll_wait(epfd, events, 20, 1000);
			for (int i = 0; i < nfds; ++i)
			{
				if (events[i].data.fd != inotifyId)
				{
					continue;
				}
				int length = read(inotifyId, buf, INOTIFY_BUF_LEN);
				if (length < 0)
				{
					// error
					continue;
				}
				int pos = 0;
				while (pos < length)
				{
					struct inotify_event* event = (struct inotify_event*)&buf[pos];
					if (event->len)
					{
                        // 此处(event->wd == watchFd)
						if (event->mask & IN_CREATE)
						{
							if (event->mask & IN_ISDIR)
							{
								// dir create
								cout << "dir create" << endl;
							}
							else
							{
								// file create
								cout << "file create" << endl;
							}
						}
						else if (event->mask & IN_DELETE)
						{
							if (event->mask & IN_ISDIR)
							{
								// dir delete
								cout << "dir delete" << endl;
							}
							else
							{
								// file delete
								cout << "file delete" << endl;
							}
						}
						else if (event->mask & IN_MODIFY)
						{
							if (event->mask & IN_ISDIR)
							{
								// dir modify
								cout << "dir modify" << endl;
							}
							else
							{
								// file modify
								cout << "file modify" << endl;
							}
						}
					}
					pos += INOTIFY_EVENT_SIZE + event->len;
				}
			}
			// 1s更新一次
			sleep(1);
		}
	});
	func.join();
	while (1)
	{
		// 仅作事件循环
		sleep(2);
	}
	inotify_rm_watch(inotifyId, watchFd);
	close(epfd);
	close(inotifyId);
	return 0;
}