Java处理多人同时读写文件的文件锁处理

http://blog.csdn.net/gxy3509394/article/details/7435993

最近项目中有遇到并发同时访问一个文件读写的情况、但是同时读写就会出错、所以我研究了一下java文件锁这个机制下面直接贴代码

我通过的是线程来模拟多人同时读写的情况

写文件

[java]  view plain copy

1. package com.dnion.test;  
2.   
3. import java.io.File;  
4. import java.io.IOException;  
5. import java.io.RandomAccessFile;  
6. import java.nio.channels.FileChannel;  
7. import java.nio.channels.FileLock;  
8. import java.util.Calendar;  
9. /** 
10.  * @author chb 
11.  */  
12. public class Thread_writeFile extends Thread{  
13.     public void run(){  
14.         Calendar calstart=Calendar.getInstance();  
15.         File file=new File("D:/test.txt");          
16.         try {  
17.             if(!file.exists())  
18.                 file.createNewFile();  
19.                           
20.             //对该文件加锁  
21.             RandomAccessFile out = new RandomAccessFile(file, "rw");  
22.             FileChannel fcout=out.getChannel();  
23.             FileLock flout=null;  
24.             while(true){    
25.                 try {  
26.                     flout = fcout.tryLock();  
27.                     break;  
28.                 } catch (Exception e) {  
29.                      System.out.println("有其他线程正在操作该文件，当前线程休眠1000毫秒");   
30.                      sleep(1000);    
31.                 }  
32.                   
33.             }  
34.           
35.             for(int i=1;i<=1000;i++){  
36.                 sleep(10);  
37.                 StringBuffer sb=new StringBuffer();  
38.                 sb.append("这是第"+i+"行，应该没啥错哈 ");  
39.                 out.write(sb.toString().getBytes("utf-8"));  
40.             }  
41.               
42.             flout.release();  
43.             fcout.close();  
44.             out.close();  
45.             out=null;  
46.         } catch (IOException e) {  
47.             e.printStackTrace();  
48.         } catch (InterruptedException e) {  
49.             e.printStackTrace();  
50.         }  
51.         Calendar calend=Calendar.getInstance();  
52.         System.out.println("写文件共花了"+(calend.getTimeInMillis()-calstart.getTimeInMillis())+"秒");  
53.     }  
54. }  

读文件

[java]  view plain copy

1. package com.dnion.test;  
2.   
3. import java.io.File;    
4. import java.io.FileInputStream;    
5. import java.io.FileNotFoundException;    
6. import java.io.IOException;    
7. import java.io.RandomAccessFile;  
8. import java.nio.channels.FileChannel;    
9. import java.nio.channels.FileLock;    
10. import java.util.Calendar;    
11. /**  
12.  * @author chb  
13.  */    
14. public class Thread_readFile extends Thread{    
15.     public void run(){    
16.         try {    
17.             Calendar calstart=Calendar.getInstance();    
18.             sleep(5000);    
19.             File file=new File("D:/test.txt");        
20.                 
21.             //给该文件加锁    
22.             RandomAccessFile fis = new RandomAccessFile(file, "rw");   
23.             FileChannel fcin=fis.getChannel();    
24.             FileLock flin=null;    
25.             while(true){    
26.                 try {  
27.                     flin = fcin.tryLock();  
28.                     break;  
29.                 } catch (Exception e) {  
30.                      System.out.println("有其他线程正在操作该文件，当前线程休眠1000毫秒");   
31.                      sleep(1000);    
32.                 }  
33.                   
34.             }    
35.             byte[] buf = new byte[1024];    
36.             StringBuffer sb=new StringBuffer();    
37.             while((fis.read(buf))!=-1){                    
38.                 sb.append(new String(buf,"utf-8"));        
39.                 buf = new byte[1024];    
40.             }    
41.                 
42.             System.out.println(sb.toString());    
43.                 
44.             flin.release();    
45.             fcin.close();    
46.             fis.close();    
47.             fis=null;    
48.                 
49.             Calendar calend=Calendar.getInstance();    
50.             System.out.println("读文件共花了"+(calend.getTimeInMillis()-calstart.getTimeInMillis())+"秒");    
51.         }catch (FileNotFoundException e) {    
52.             e.printStackTrace();    
53.         } catch (IOException e) {    
54.             e.printStackTrace();    
55.         } catch (InterruptedException e) {    
56.             e.printStackTrace();    
57.         }    
58.     }    
59. }    

调用

[java]  view plain copy

1. /** 
2.  *  
3.  */  
4. package com.dnion.test;  
5.   
6. /** 
7.  * @author Administrator 
8.  * 
9.  */  
10. public class Test {  
11.   
12.     /** 
13.      * @param args 
14.      */  
15.     public static void main(String[] args) {  
16.         Thread_writeFile thf3=new Thread_writeFile();    
17.         Thread_readFile thf4=new Thread_readFile();    
18.         thf3.start();    
19.         thf4.start();    
20.   
21.     }  
22.   
23. }  

这里我们要讲解一下文件锁

我们通过RandomAccessFile这个随机读取流来操作文件速度上面会有一点慢、但不是极其大的文件一般可以忽略。

我们通过FileChannel对象来获得锁

Trylock 与lock方法

tryLock()是非阻塞式的，它设法获取锁，但如果不能获得，例如因为其他一些进程已经持有相同的锁，而且不共享时，它将直接从方法调用返回。

lock()是阻塞式的，它要阻塞进程直到锁可以获得，或调用lock()的线程中断，或调用lock()的通道关闭。

对独占锁和共享锁的支持必须由底层的操作系统提供。锁的类型可以通过FileLock.isShared()进行查询。另外，我们不能获取缓冲器上的锁，只能是通道上的。

OverlappingFileLockException 与锁的作用域

    在某个文件加锁锁只会作用在此文件上对其他文件无效

    单个 Java 虚拟机在某个特定文件上所保持的锁定是不重叠的，即同一个jvm中不同线程去拿同一文件的锁时，先拿到的获得锁，后获取的无法获得锁，tryLock（）方法不会抛出异常，但获得锁值为null。

       不同jvm或者不同操作系统获取同一文件锁时，先拿到的获得锁，后获取的抛出文件重叠锁异常【OverlappingFileLockException】。以上是windows才会出现如此现象，如果是linux 会抛出异常：【java.io.IOException:Permission denied】

 

共享锁与独占锁区别

独占锁：也称排它锁，如果一个线程获得一个文件的独占锁，那么其它线程就不能再获得同一文件的独占锁或共享锁，直到独占锁被释放。
共享锁：如果一个线程获得一个文件的共享锁，那么其它线程可以获得同一文件的共享锁或同一文件部分内容的共享锁，但不能获取排它锁

 

当a.txt文件被加独占锁时 其他线程不可读也不可写

当a.txt文件被加共享锁时 其他线程可读也不可写

 

如何获得共享锁

       fc.tryLock(position,size,isShare);第三个参数为true时 为共享锁