Java读取文件加锁代码Demo(利用Java的NIO)-阿里云开发者社区

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 }

本文转自SummerChill博客园博客，原文链接：http://www.cnblogs.com/DreamDrive/p/7425281.html，如需转载请自行联系原作者

Java读取文件加锁代码Demo(利用Java的NIO)

热门文章

最新文章

相关课程

相关电子书

相关实验场景