本博文部分转载于:http://blog.csdn.net/wangbaochu/article/details/48546717
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所规定的那样来申请或者检测文件锁，不然将起不到进程互斥的功能。所以文档里建议将所有系统都当做是询问式系统来处理，这样程序更加安全也更容易移植。
如何避免死锁：在读写关键数据时加锁，操作完成后解锁；一次性申请所有需要的资源，并且在申请不成功的情况下放弃已申请到的资源。
Java文件锁定一般都通过FileChannel来实现。主要涉及如下2个方法：
tryLock() throws IOException 试图获取对此通道的文件的独占锁定。
tryLock(long position, long size, boolean shared) throws IOException 试图获取对此通道的文件给定区域的锁定。
tryLock等同于tryLock(0L, Long.MAX_VALUE, false) ，它获取的是独占锁，所以一定是在释放锁之后，才能读取到文件内容。
1.写文件的时候加锁:
Thread_writeFile.java
1 import java.io.File; 2 import java.io.IOException; 3 import java.io.RandomAccessFile; 4 import java.nio.channels.FileChannel; 5 import java.nio.channels.FileLock; 6 import java.util.Calendar; 7 8 public class Thread_writeFile extends Thread{ 9 public void run(){ 10 Calendar calstart=Calendar.getInstance(); 11 File file=new File("D:/test.txt"); 12 try { 13 if(!file.exists()){ 14 file.createNewFile(); 15 } 16 //对该文件加锁 17 RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw"); 18 FileChannel fileChannel=randomAccessFile.getChannel(); 19 FileLock fileLock=null; 20 while(true){ 21 try { 22 fileLock = fileChannel.tryLock(); 23 break; 24 } catch (Exception e) { 25 System.out.println("有其他线程正在操作该文件，当前线程"+Thread.currentThread().getName()+"休眠1000毫秒"); 26 sleep(1000); 27 } 28 29 } 30 for(int i=1;i<=1000;i++){ 31 sleep(10); 32 StringBuffer sb=new StringBuffer(); 33 sb.append("这是第"+i+"行对应的数据"); 34 sb.append("\n"); 35 randomAccessFile.write(sb.toString().getBytes("utf-8")); 36 } 37 fileLock.release(); 38 fileChannel.close(); 39 randomAccessFile.close(); 40 randomAccessFile=null; 41 } catch (IOException e) { 42 e.printStackTrace(); 43 } catch (InterruptedException e) { 44 e.printStackTrace(); 45 } 46 Calendar calend=Calendar.getInstance(); 47 System.out.println("线程:"+Thread.currentThread().getName()+",写文件共花了"+(calend.getTimeInMillis()-calstart.getTimeInMillis())+"秒"); 48 } 49 }
测试类:Thread_writeTest
1 public class Thread_writeTest { 2 3 public static void main(String[] args) { 4 Thread_writeFile writeFileThread=new Thread_writeFile(); 5 writeFileThread.setName("writeFileThread"); 6 Thread_writeFile writeFileThread2=new Thread_writeFile(); 7 writeFileThread2.setName("writeFileThread2"); 8 writeFileThread.start(); 9 writeFileThread2.start(); 10 } 11 }
运行结果:
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
有其他线程正在操作该文件，当前线程writeFileThread休眠1000毫秒
线程:writeFileThread2,写文件共花了10021秒
线程:writeFileThread,写文件共花了21026秒2.读取文件的时候加锁:
Thread_readFile.java
1 import java.io.File; 2 import java.io.FileNotFoundException; 3 import java.io.IOException; 4 import java.io.RandomAccessFile; 5 import java.nio.channels.FileChannel; 6 import java.nio.channels.FileLock; 7 import java.util.Calendar; 8 9 public class Thread_readFile extends Thread{ 10 public void run(){ 11 try { 12 Calendar calstart=Calendar.getInstance(); 13 sleep(5000); 14 File file=new File("D:/test.txt"); 15 //给该文件加锁 16 RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw"); 17 FileChannel fileChannel=randomAccessFile.getChannel(); 18 FileLock fileLock=null; 19 while(true){ 20 try { 21 fileLock = fileChannel.tryLock(); 22 break; 23 } catch (Exception e) { 24 System.out.println("有其他线程正在操作该文件，当前线程"+Thread.currentThread().getName()+"休眠1000毫秒"); 25 sleep(1000); 26 } 27 } 28 byte[] buf = new byte[1024]; 29 StringBuffer sb=new StringBuffer(); 30 while((randomAccessFile.read(buf))!=-1){ 31 sb.append(new String(buf,"utf-8")); 32 buf = new byte[1024]; 33 } 34 35 System.out.println(sb.toString()); 36 37 fileLock.release(); 38 fileChannel.close(); 39 randomAccessFile.close(); 40 randomAccessFile=null; 41 42 Calendar calend=Calendar.getInstance(); 43 System.out.println("当前线程:"+Thread.currentThread().getName()+",读文件共花了"+(calend.getTimeInMillis()-calstart.getTimeInMillis())+"秒"); 44 }catch (FileNotFoundException e) { 45 e.printStackTrace(); 46 } catch (IOException e) { 47 e.printStackTrace(); 48 } catch (InterruptedException e) { 49 e.printStackTrace(); 50 } 51 } 52 }
测试类:Thread_readTest.java
1 public class Thread_readTest { 2 3 public static void main(String[] args) { 4 Thread_readFile readFileThread=new Thread_readFile(); 5 readFileThread.setName("readFileThread"); 6 Thread_readFile writeFileThread2=new Thread_readFile(); 7 writeFileThread2.setName("readFileThread2"); 8 9 readFileThread.start(); 10 writeFileThread2.start(); 11 } 12 }
运行结果:
有其他线程正在操作该文件，当前线程readFileThread休眠1000毫秒
这是第1行对应的数据
这是第2行对应的数据
当前线程:readFileThread2,读文件共花了5009秒
这是第1行对应的数据
这是第2行对应的数据
当前线程:readFileThread,读文件共花了6009秒
//================================另外一个例子================================
1 import java.io.FileNotFoundException; 2 import java.io.FileOutputStream; 3 import java.io.IOException; 4 import java.io.RandomAccessFile; 5 import java.nio.ByteBuffer; 6 import java.nio.channels.FileChannel; 7 import java.nio.channels.FileLock; 8 import java.util.Date; 9 10 public class FileLockTest { 11 12 public static void main(String[] args){ 13 FileChannel channel = null; 14 FileLock lock = null; 15 try { 16 //1. 对于一个只读文件通过任意方式加锁时会报NonWritableChannelException异常 17 //2. 无参lock()默认为独占锁，不会报NonReadableChannelException异常，因为独占就是为了写 18 //3. 有参lock()为共享锁，所谓的共享也只能读共享，写是独占的，共享锁控制的代码只能是读操作，当有写冲突时会报NonWritableChannelException异常 19 channel = new FileOutputStream("test.txt",true).getChannel(); 20 RandomAccessFile raf = new RandomAccessFile("test.txt","rw"); 21 22 //在文件末尾追加内容的处理 23 raf.seek(raf.length()); 24 channel = raf.getChannel(); 25 26 //获得锁方法一：lock()，阻塞的方法，当文件锁不可用时，当前进程会被挂起 27 lock = channel.lock();//无参lock()为独占锁 28 //lock = channel.lock(0L, Long.MAX_VALUE, true);//有参lock()为共享锁，有写操作会报异常 29 30 //获得锁方法二：trylock()，非阻塞的方法，当文件锁不可用时，tryLock()会得到null值 31 //do { 32 // lock = channel.tryLock(); 33 //} while (null == lock); 34 35 //互斥操作 36 ByteBuffer sendBuffer=ByteBuffer.wrap((new Date()+" 写入\n").getBytes()); 37 channel.write(sendBuffer); 38 Thread.sleep(5000); 39 } catch (FileNotFoundException e) { 40 e.printStackTrace(); 41 } catch (IOException e) { 42 e.printStackTrace(); 43 } catch (InterruptedException e) { 44 e.printStackTrace(); 45 } finally { 46 if (lock != null) { 47 try { 48 lock.release(); 49 lock = null; 50 } catch (IOException e) { 51 e.printStackTrace(); 52 } 53 } 54 55 if (channel != null) { 56 try { 57 channel.close(); 58 channel = null; 59 } catch (IOException e) { 60 e.printStackTrace(); 61 } 62 } 63 } 64 } 65 }
推荐一个帖子:
https://stackoverflow.com/questions/128038/how-can-i-lock-a-file-using-java-if-possible
关于JavaNIO的总结还可以看我的博客：
