从inotify机制说到FileObserver
2016-07-14 03:01
309 查看
有些情况下,我们难免需要监控一些文件的变化情况,这该如何实现呢?自然而然的我们会想要利用一个线程,每个一段时间便去看看文件的情况,这种方式本质上就是基于时间调度的轮训.虽然能够实现我们的需求,但是这种方式只适合文件经常变化的情况,其他情况下都非常低效,并且可能丢掉某些类型的变化,也就是说,这种方式无法实现实时的文件监控.
这里需要记住一点:name字段并不是什么时候都有的,只有要监控的目标是一个目录,且产生的事件与目录内部的文件或子目录相关,且与目录本身无关时才会提供响应的name字段.
此处的fd即inotify_init()方法返回的文件描述符.每个文件描述符都有一个排序的事件序列.
path则是需要监控的文件或者目录的路径.
mask则是事件掩码,它表示应用程序对哪些事件感兴趣.
文件系统产生的事件用Watch来描述,该方法将返回一个watch对象的句柄,即wd.
event_buf是一个事件数组,用于接受文件变化所产生的事件(inotify_event).len则指定了要读的长度.通常来说,len大于事件数组的大小,很多时候,我们也会直接取事件数组的大小来作为len.
另外需要注意的是read()函数是阻塞式的,如果没有事件产生,该方法将一直阻塞.
此处的fd也是在创建inotify时返回的文件描述符,wd则是上面提到watch对象的句柄.
现在我们简单的介绍了inotity相关方面的知识,并没做过多的深究,感兴趣的童鞋可以自行研究相关linux在这方面的源码.我们的重点还是Android中FileObserver的实现.接下来,我们真正的开始了解FileObserver的实现原理:
接下来,来看一下FileObserver如何借助inotify实现文件监控的.
不难发现发现FileObserver通过静态代码块的方式构造了s_observerThread对象,我们来看一下其构造过程:
我们发现这里,调用natvie方法init(),既然这样,我们就在深入一下,看看init()方法的实现(现在,是不是发现我们自己编译源码的好处了?)该方法的实现在/frameworks/base/core/jni/android_util_FileObserver.cpp
实现非常简单,就是调用inotify中的inotify_init()来创建一个inotify实例。回到FileObserver中来看s_ObserverThread的启动:
这里同样是调用了natvie方法
不难看出,此处的循环主要就是从inotity中取出事件,然后回调ObserverThread中的
FileObserver中的
到现在为止我们已经明白了ObserverThread如何被启动,以及如何获取inotify中的事件,并回调给上层进行处理.
具体的注册操作委托给s_observerThread中的startWatching():
该方法中同样调用了native方法,其具体实现是:
不难看出,这里通过inotify的
具体的实现也是交给了s_observerThread的
接着委托给了natvie方法:
这里的实现非常简单,就是调用inotify_rm_watch方法来解除inotify实例和watch实例的关系.
到现在为止我们已经弄明白了FileObserver的实现原理,为了方便理解,我们用一张简单的图来描述整个过程:
![](http://img.blog.csdn.net/20160714004034396)
1. 谨慎的选择你要处理的事件,否则可能造成死循环.
2. 当不再需要监听时,请记得停止监控
3. 需要注意FileObserver对象被垃圾回收的情况,从上面的原理中我们知道,该对象被回收后将不会再触发事件.
inotify简介
那还有其他的方式么?熟悉linux的童鞋应该记得从linux 2.6.13之后,引入inotify机制,它是内核中用于通知文件变化的:任何一个文件发生某种变化,都会产生一个事件来告诉用户.可监控事件类型
首先我们来看一下inotify能够监控的几种文件变化事件:事件类型 | 说明 |
---|---|
IN_ACCESS | 文件被访问 |
IN_MODIFY | 文件被修改 |
IN_ATTRIB | 文件属性被修改 |
IN_CLOSE_WRITE | 可写文件被关闭 |
IN_CLOSE_NOWRITE | 不可写文件被关闭 |
IN_CLOSE | 文件被关闭,也就以上两者的集合 |
IN_OPEN | 文件被打开 |
IN_MOVED_FROM | 文件被移来 |
IN_MOVED_TO | 文件被移走 |
IN_MOVE | 文件被移动,也就是以上两者的集合 |
IN_CREATE | 文件被创建 |
IN_DELETE | 文件被删除 |
IN_DELETE_SELF | 自删除,也就是一个可执行文件在执行时尝试删除自己 |
IN_MOVE_SELF | 自移动,也就是一个可执行文件在执行时尝试移动自己 |
IN_UNMOUNT | 宿主文件系统被卸载 |
API说明
接下来,我们对innotify的api做个简单的说明:方法 | 说明 |
---|---|
inotify_init | 用于创建一个inotify实例,返回一个指向该实例的的文件描述符 |
inotify_add_watch | 添加对文件或者目录的监控,可以指定需要监控那些文件变化事件 |
inotify_rm_watch | 从监控列表中移除监控文件或者目录 |
read | 读取事件信息 |
close | 关闭文件描述符,并会移除所有在该描述符上监控 |
事件通知
在inotify中,文件事件用结构体inotify_event表示,其结构如下所示:struct inotify_event { int wd; //监控目标的watch描述符 uint32_t mask; //事件掩码 uint32_t cookie; //事件同步cookie uint32_t len; //name字符串的长度 char name __flexarr; //被监视目标的路径名 };
这里需要记住一点:name字段并不是什么时候都有的,只有要监控的目标是一个目录,且产生的事件与目录内部的文件或子目录相关,且与目录本身无关时才会提供响应的name字段.
使用流程
通常要实现对文件或者目录的监控需要以下几个步骤:1. 创建inotify实例
在应用程序中,首先需要创建inotify实例:int fd=inotify_init();
2. 添加监控
int wd=inotify_add_watch(fd,path,mask)
此处的fd即inotify_init()方法返回的文件描述符.每个文件描述符都有一个排序的事件序列.
path则是需要监控的文件或者目录的路径.
mask则是事件掩码,它表示应用程序对哪些事件感兴趣.
文件系统产生的事件用Watch来描述,该方法将返回一个watch对象的句柄,即wd.
3. 等待事件与循环处理
在循环中,当事件发生时,通过read()方法可以一次获得多个事件,简单代码如下://事件数组,一次最多接受128个事件 char event_buf[128]; while(true){ int num_bytes=read(fd,event_buf,len); //....省略.... }
event_buf是一个事件数组,用于接受文件变化所产生的事件(inotify_event).len则指定了要读的长度.通常来说,len大于事件数组的大小,很多时候,我们也会直接取事件数组的大小来作为len.
另外需要注意的是read()函数是阻塞式的,如果没有事件产生,该方法将一直阻塞.
4.停止监控
当需要停止监控的时候,需要为文件描述符删除watch:int r=inotify_rm_watch(fd,wd);
此处的fd也是在创建inotify时返回的文件描述符,wd则是上面提到watch对象的句柄.
现在我们简单的介绍了inotity相关方面的知识,并没做过多的深究,感兴趣的童鞋可以自行研究相关linux在这方面的源码.我们的重点还是Android中FileObserver的实现.接下来,我们真正的开始了解FileObserver的实现原理:
FileObserver实现原理
我们知道Android 1.5时对应的linux内核已经是2.6.26,因此完全可以在Android上利用inotify机制来实现对文件的监控.Google很显然意识到了这一点,并且帮我们在inotify的基础上进行封装—inotify机制封装为FileObserver抽象类,以实现监听文件访问,创建,修改,删除等操作接下来,来看一下FileObserver如何借助inotify实现文件监控的.
监控线程初始化
在FileObserver中存在一个静态内部类ObserverThread,该线程类是实现了文件监控的过程:public abstract class FileObserver { //可监控的事件 public static final int ALL_EVENTS = ACCESS | MODIFY | ATTRIB | CLOSE_WRITE | CLOSE_NOWRITE | OPEN | MOVED_FROM | MOVED_TO | DELETE | CREATE | DELETE_SELF | MOVE_SELF; private static class ObserverThread extends Thread { //....省略多行代码.... } private static ObserverThread s_observerThread; static { s_observerThread = new ObserverThread(); s_observerThread.start(); } //....省略多行代码.... }
不难发现发现FileObserver通过静态代码块的方式构造了s_observerThread对象,我们来看一下其构造过程:
public ObserverThread() { super("FileObserver"); m_fd = init(); }
我们发现这里,调用natvie方法init(),既然这样,我们就在深入一下,看看init()方法的实现(现在,是不是发现我们自己编译源码的好处了?)该方法的实现在/frameworks/base/core/jni/android_util_FileObserver.cpp
static jint android_os_fileobserver_init(JNIEnv* env, jobject object) { #if defined(__linux__) return (jint)inotify_init(); #else return -1; #endif }
实现非常简单,就是调用inotify中的inotify_init()来创建一个inotify实例。回到FileObserver中来看s_ObserverThread的启动:
public void run() { observe(m_fd); }
这里同样是调用了natvie方法
observe(int fd),来看其实现:
static void android_os_fileobserver_observe(JNIEnv* env, jobject object, jint fd) { #if defined(__linux__) //设置事件数组 char event_buf[512]; struct inotify_event* event; //循环处理读到的事件 while (1) { int event_pos = 0; //读取事件 int num_bytes = read(fd, event_buf, sizeof(event_buf)); if (num_bytes < (int)sizeof(*event)) { if (errno == EINTR) continue; ALOGE("***** ERROR! android_os_fileobserver_observe() got a short event!"); return; } while (num_bytes >= (int)sizeof(*event)) { int event_size; event = (struct inotify_event *)(event_buf + event_pos); jstring path = NULL; if (event->len > 0) { path = env->NewStringUTF(event->name); } //调用ObserverThread中的onEvent方法 env->CallVoidMethod(object, method_onEvent, event->wd, event->mask, path); if (env->ExceptionCheck()) { env->ExceptionDescribe(); env->ExceptionClear(); } if (path != NULL) { env->DeleteLocalRef(path); } event_size = sizeof(*event) + event->len; num_bytes -= event_size; event_pos += event_size; } } #endif }
不难看出,此处的循环主要就是从inotity中取出事件,然后回调ObserverThread中的
onEvent()方法.现在,回到ObserverThread中的
onEvent()方法中:
public void onEvent(int wfd, int mask, String path) { // look up our observer, fixing up the map if necessary... FileObserver observer = null; synchronized (m_observers) { //根据wfd找出FileObserver对象 WeakReference weak = m_observers.get(wfd); if (weak != null) { // can happen with lots of events from a dead wfd observer = (FileObserver) weak.get(); if (observer == null) {//observer已经被回收时,从m_observers中删除该对象 m_observers.remove(wfd); } } } // ...then call out to the observer without the sync lock held if (observer != null) { try { //回调给FileObserver中的onEvent方法进行处理 observer.onEvent(mask, path); } catch (Throwable throwable) { Log.wtf(LOG_TAG, "Unhandled exception in FileObserver " + observer, throwable); } } }
FileObserver中的
onEvent()为抽象方法,也就是要求你继承FileObserver,并实现该方法,在其中做相关的操作.
到现在为止我们已经明白了ObserverThread如何被启动,以及如何获取inotify中的事件,并回调给上层进行处理.
启动监控
上面提到m_observers表,该表维护着已经注册的FileObserver对象.接下来,我们就就来看看FileObserver中的startWatching()方法,该方法注册FileObserver对象,也是启动监控的过程:
public void startWatching() { if (m_descriptor < 0) { m_descriptor = s_observerThread.startWatching(m_path, m_mask, this); } }
具体的注册操作委托给s_observerThread中的startWatching():
public int startWatching(String path, int mask, FileObserver observer) { //调用native方法startWatching,并得到一个watch对象的句柄 int wfd = startWatching(m_fd, path, mask); Integer i = new Integer(wfd); if (wfd >= 0) { synchronized (m_observers) { //将watch对象句柄和当前FileObserver关联 m_observers.put(i, new WeakReference(observer)); } } return i; }
该方法中同样调用了native方法,其具体实现是:
static jint android_os_fileobserver_startWatching(JNIEnv* env, jobject object, jint fd, jstring pathString, jint mask) { int res = -1; #if defined(__linux__) if (fd >= 0) { const char* path = env->GetStringUTFChars(pathString, NULL); res = inotify_add_watch(fd, path, mask); env->ReleaseStringUTFChars(pathString, path); } #endif return res; }
不难看出,这里通过inotify的
inotify_add_watch()为上面生成的inotify对象添加watch对象,并将watch对象的句柄返回给ObserverThread.
停止监控
到现在我们已经了解了如何注册watch句柄到FileObserver对象.有了注册的过程,当然少不了反注册的过程.同样,FileObserver为我们提供了stopWatching()来实现反注册,即停止监控的过程:
public void stopWatching() { if (m_descriptor >= 0) {//已经注册过的才能反注册 s_observerThread.stopWatching(m_descriptor); m_descriptor = -1; } }
具体的实现也是交给了s_observerThread的
stopWatching()方法:
public void stopWatching(int descriptor) { stopWatching(m_fd, descriptor); }
接着委托给了natvie方法:
static void android_os_fileobserver_stopWatching(JNIEnv* env, jobject object, jint fd, jint wfd) { #if defined(__linux__) inotify_rm_watch((int)fd, (uint32_t)wfd); #endif }
这里的实现非常简单,就是调用inotify_rm_watch方法来解除inotify实例和watch实例的关系.
到现在为止我们已经弄明白了FileObserver的实现原理,为了方便理解,我们用一张简单的图来描述整个过程:
使用说明
想必你已经了解了FileObserver的实现原理,接下里我们来看看如何使用.要想实现文件监控,我们只需要继承FileObserver类,并在onEvent()处理相关事件即可,简单的用代码演示一下:
public class SDCardObserver extends FileObserver { public SDCardObserver(String path) { super(path); } @Override public void onEvent(int i, String s) { switch (i) { case FileObserver.ALL_EVENTS: //全部事件 break; case FileObserver.CREATE: //文件被创建 break; case FileObserver.DELETE: //文件被删除 break; case FileObserver.MODIFY: //文件被修改 break; } } }
注意事项
这里我们需要注意两个问题:1. 谨慎的选择你要处理的事件,否则可能造成死循环.
2. 当不再需要监听时,请记得停止监控
3. 需要注意FileObserver对象被垃圾回收的情况,从上面的原理中我们知道,该对象被回收后将不会再触发事件.
相关文章推荐
- 推荐系统大师项亮都来了,就问你约不约?
- “深度学习”和“多层神经网络”的区别?
- liunx删除了之后没有释放空间
- 如何在CodeBlocks中添加头文件graphics.h
- Shadow Map ———— PCSS(percentage-closer Soft Shadow)
- liunx误删文件回复方式
- Shadow Map ———— PCF(percentage-closer filtering)
- 慕课网实战—《用组件方式开发 Web App全站 》笔记二
- SHADOW MAP
- TangentSpace的法线转换到ViewSpace
- disney BRDF代码解释
- "Android 屏幕适配"-Android面试必问"精华技能点"汇总
- 软件光栅器的设计思想
- Hbasebulkload方法--63
- 复制pdf文字出来是乱码的一种可能的解决方案
- EffectCookBook笔记Chapter4-11
- EFFECT C++总结
- 【工具】CodeSmith Generator 7.0.2激活步骤
- Physically-Based Shading at Disney节选翻译
- Unreal Engine 4 PBR节选翻译 -------- Real Shading in Unreal Engine 4