详解进程文件锁FileLock

1. import java.io.FileNotFoundException;  
2. import java.io.IOException;  
3. import java.io.RandomAccessFile;  
4. import java.nio.ByteBuffer;  
5. import java.nio.channels.FileChannel;  
6. import java.nio.channels.FileLock;  
7. import java.util.Date;  
8.   
9. /** 
10.  * FileLocke是文件锁，进程锁，控制不同程序（JVM）对同一文件的并发访问 
11.  * FileLock是java 1.4 版本后出现的一个类，它可以通过对一个可写文件(w)加锁， 
12.  * 保证同时只有一个进程可以拿到文件的锁，这个进程从而可以对文件做访问； 
13.  * 而其它拿不到锁的进程要么选择被挂起等待，要么选择去做一些其它的事情， 
14.  * 这样的机制保证了众进程可以顺序访问该文件。 
15.  * 也可以看出，能够利用文件锁的这种性质，在一些场景下，虽然我们不需要操作某个文件， 
16.  * 但也可以通过 FileLock 来进行并发控制，保证进程的顺序执行，避免数据错误。 
17.  * ---用于进程间并发 
18.  * Locks are associated with files, not channels. Use locks to coordinate  
19.  * with external processes, not between threads in the same JVM. 
20.  * ---概念 
21.  * 共享锁:共享读操作，但只能一个写 
22.  * 排它锁:只有一个读或一个写 
23.  * API中说：文件锁是独占或者共享的，共享锁防止其他正在运行的程序获得重复的独占锁，但是允许他们获得 
24.  * 重复的共享锁，独占锁防止其他程序获得任何类型的锁。一旦锁释放，它就对其他程序可能要获得的锁没有了后续影响. 
25.  * ---FileLock FileChannel.lock(long position, long size, boolean shared),文件锁 
26.  * shared的含义:是否使用共享锁,一些不支持共享锁的操作系统,将自动将共享锁改成排它锁. 
27.  * 可以通过调用isShared()方法来检测获得的是什么类型的锁 
28.  * ---lock()和tryLock()的区别 
29.  * lock()阻塞的方法，锁定范围可以随着文件的增大而增加 
30.  * tryLock()非阻塞,当未获得锁时,返回null. 
31.  * ---FileLock的生命周期 
32.  * 在调用FileLock.release(),或者Channel.close(),或者JVM关闭 
33.  * ---FileLock是线程安全的 
34.  * ---boolean java.nio.channels.FileLock.overlaps(long position, long size) 
35.  * true表示当前锁在区域内,false表示当前锁的区域与参数区域不重叠 
36.  *  注意事项： 
37.     1.同一进程内，在文件锁没有被释放之前，不可以再次获取。 
38.          即在release()方法调用前,只能lock()或者tryLock()一次。 
39.     2.文件锁的效果是与操作系统相关的。一些系统中文件锁是强制性的（mandatory）， 
40.          就当Java的某进程获得文件锁后，操作系统将保证其它进程无法对文件做操作了。 
41.          而另一些操作系统的文件锁是询问式的(advisory)，意思是说要想拥有进程互斥的效果， 
42.          其它的进程也必须也按照API所规定的那样来申请或者检测文件锁，不然，将起不到进程互斥的功能。 
43.          所以，文档里建议将所有系统都当做是询问式系统来处理，这样程序更加安全也更容易移植。 
44.     *如何避免死锁 
45.     在读写关键数据时加锁，操作完成后解锁；  
46.     一次性申请所有需要的资源，并且在申请不成功的情况下放弃已申请到的资源; 
47.  * @author shijin 
48.  * 
49.  */  
50. public class FileLockTest {  
51.     /** 
52.      * 如代码所示，需要进行互斥的进程只要将自己的代码替换掉//互斥操作即可， 
53.      * 每个进程在运行实际逻辑功能代码之前，会尝试获取锁文件锁， 
54.      * 得到文件锁的进程可以继续执行后续的代码，而没有获得锁文件的进程将被操作系统挂起(suspend)， 
55.      * 等到其它进程将文件锁释放后再重新开始尝试获取文件锁。 
56.      * 这样子，进程就可以通过FileLock来实现间的互斥运行。 
57.      * @param args 
58.      */  
59.     public static void main(String[] args){  
60.         FileChannel channel = null;  
61.         FileLock lock = null;  
62.         try {  
63. //          对于一个只读文件通过任意方式加锁时会报NonWritableChannelException异常  
64. //          同样对写通道通过有参lock()方式加锁时也会报NonReadableChannelException异常  
65. //          无参lock()默认为独占锁，不会报NonReadableChannelException异常，因为独占就是为了写  
66. //          所谓的共享也只能读共享，写是独占的，共享锁控制的代码只能是读操作  
67. //          channel = new FileOutputStream("logfile.txt",true).getChannel();  
68.               
69.             RandomAccessFile raf = new RandomAccessFile("logfile.txt","rw");  
70.             raf.seek(raf.length());//raf在文件末尾追加内容的处理  
71.             channel = raf.getChannel();  
72.               
73. //          获得锁方法一lock，阻塞的方法，当文件锁不可用时，当前进程会被挂起  
74. //          lock = channel.lock(0L, Long.MAX_VALUE, true);//共享锁，有写操作会报异常  
75.             lock = channel.lock();//独占锁  
76.               
77. //          获得锁方法二trylock，非阻塞的方法，当文件锁不可用时，tryLock()会得到null值  
78. //          do {  
79. //              lock = channel.tryLock();  
80. //          } while(null == lock);  
81.   
82. //          互斥操作  
83.             ByteBuffer sendBuffer=ByteBuffer.wrap((new Date()+" 写入\n").getBytes());  
84.             channel.write(sendBuffer);  
85.             Thread.sleep(5000);  
86.         } catch (FileNotFoundException e) {  
87.             e.printStackTrace();  
88.         } catch (IOException e) {  
89.             e.printStackTrace();  
90.         } catch (InterruptedException e) {  
91.             e.printStackTrace();  
92.         } finally {  
93.             if(lock != null) {  
94.                 try {  
95.                     lock.release();  
96.                     lock = null;  
97.                 } catch (IOException e) {  
98.                     e.printStackTrace();  
99.                 }  
100.             }  
101.             if(channel != null) {  
102.                 try {  
103.                     channel.close();  
104.                     channel = null;  
105.                 } catch (IOException e) {  
106.                     e.printStackTrace();  
107.                 }  
108.             }  
109.         }  
110.     }  
111. }  
112. /** 
113.  *  间隔一秒钟两次运行本程序，程序会在文件锁的控制下对logfile.txt进行互斥操作 
114.     logfile.txt内容： 
115.     Thu Aug 16 15:39:02 CST 2012 写入 
116.     Thu Aug 16 15:39:07 CST 2012 写入 
117.      
118.     当采用第二种方法时，若还未获得文件锁就对文件进行操作，则会报以下异常： 
119.     Exception in thread "main" java.io.IOException: 另一个程序已锁定文件的一部分，进程无法访问。 
120.     at sun.nio.ch.FileDispatcher.write0(Native Method) 
121.     at sun.nio.ch.FileDispatcher.write(Unknown Source) 
122.     at sun.nio.ch.IOUtil.writeFromNativeBuffer(Unknown Source) 
123.     at sun.nio.ch.IOUtil.write(Unknown Source) 
124.     at sun.nio.ch.FileChannelImpl.write(Unknown Source) 
125.     at FileLockTest.main(FileLockTest.java:19) 
126.  */