最近需要在两个进程中对同一个文件进行操作，正好Java 提供了文件锁FileLock类，利用这个类可以控制不同程序(JVM)对同一文件的并发访问，实现进程间文件同步操作。

     FileLock是java 1.4 版本后出现的一个类，它可以通过对一个可写文件(w)加锁，保证同时只有一个进程可以拿到文件的锁，这个进程从而可以对文件做访问；而其它拿不到锁的进程要么选择被挂起等待，要么选择去做一些其它的事情， 这样的机制保证了众进程可以顺序访问该文件。也可以看出，能够利用文件锁的这种性质，在一些场景下，虽然我们不需要操作某个文件， 但也可以通过 FileLock 来进行并发控制，保证进程的顺序执行，避免数据错误。

 “Locks are associated with files, not channels. Use locks to coordinate with external processes, not between threads in the same JVM.”

1. 概念

  • 共享锁: 共享读操作，但只能一个写（读可以同时，但写不能）。共享锁防止其他正在运行的程序获得重复的独占锁，但是允许他们获得重复的共享锁。
  • 独占锁: 只有一个读或一个写（读和写都不能同时）。独占锁防止其他程序获得任何类型的锁。

2. FileLock FileChannel.lock(long position, long size, boolean shared)

  • shared的含义:是否使用共享锁,一些不支持共享锁的操作系统,将自动将共享锁改成排它锁。可以通过调用isShared()方法来检测获得的是什么类型的锁。

3. lock()和tryLock()的区别：

  • lock()阻塞的方法，锁定范围可以随着文件的增大而增加。无参lock()默认为独占锁；有参lock(0L, Long.MAX_VALUE, true)为共享锁。
  • tryLock()非阻塞,当未获得锁时,返回null.

4. FileLock的生命周期：在调用FileLock.release(),或者Channel.close(),或者JVM关闭

5. FileLock是线程安全的

6. 注意事项：

  • 同一进程内，在文件锁没有被释放之前，不可以再次获取。即在release()方法调用前,只能lock()或者tryLock()一次。
  • 文件锁的效果是与操作系统相关的。一些系统中文件锁是强制性的，就当Java的某进程获得文件锁后，操作系统将保证其它进程无法对文件做操作了。而另一些操作系统的文件锁是询问式的(advisory)，意思是说要想拥有进程互斥的效果，其它的进程也必须也按照API所规定的那样来申请或者检测文件锁，不然将起不到进程互斥的功能。所以文档里建议将所有系统都当做是询问式系统来处理，这样程序更加安全也更容易移植。
  • 如何避免死锁：在读写关键数据时加锁，操作完成后解锁；一次性申请所有需要的资源，并且在申请不成功的情况下放弃已申请到的资源。

7. 示例代码:

[java]  view plain  copy 


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. public class FileLockTest {  
10.   
11. public static void main(String[] args){  
12. null;  
13. null;  
14. try {  
15. //1. 对于一个只读文件通过任意方式加锁时会报NonWritableChannelException异常  
16. //2. 无参lock()默认为独占锁，不会报NonReadableChannelException异常，因为独占就是为了写  
17. //3. 有参lock()为共享锁，所谓的共享也只能读共享，写是独占的，共享锁控制的代码只能是读操作，当有写冲突时会报NonWritableChannelException异常  
18. new FileOutputStream("logfile.txt",true).getChannel();  
19. new RandomAccessFile("logfile.txt","rw");  
20.   
21. //在文件末尾追加内容的处理  
22.             raf.seek(raf.length());  
23.             channel = raf.getChannel();  
24.   
25. //获得锁方法一：lock()，阻塞的方法，当文件锁不可用时，当前进程会被挂起  
26. //无参lock()为独占锁  
27. //lock = channel.lock(0L, Long.MAX_VALUE, true);//有参lock()为共享锁，有写操作会报异常  
28.   
29. //获得锁方法二：trylock()，非阻塞的方法，当文件锁不可用时，tryLock()会得到null值  
30. //do {  
31. //  lock = channel.tryLock();  
32. //} while (null == lock);  
33.   
34. //互斥操作  
35. new Date()+" 写入\n").getBytes());  
36.             channel.write(sendBuffer);  
37. 5000);  
38. catch (FileNotFoundException e) {  
39.             e.printStackTrace();  
40. catch (IOException e) {  
41.             e.printStackTrace();  
42. catch (InterruptedException e) {  
43.             e.printStackTrace();  
44. finally {  
45. if (lock != null) {  
46. try {  
47.                     lock.release();  
48. null;  
49. catch (IOException e) {  
50.                     e.printStackTrace();  
51.                 }  
52.             }  
53.   
54. if (channel != null) {  
55. try {  
56.                     channel.close();  
57. null;  
58. catch (IOException e) {  
59.                     e.printStackTrace();  
60.                 }  
61.             }  
62.         }  
63.     }