Chinaunix首页 | 论坛 | 博客
  • 博客访问: 2339335
  • 博文数量: 321
  • 博客积分: 3440
  • 博客等级: 中校
  • 技术积分: 2992
  • 用 户 组: 普通用户
  • 注册时间: 2007-05-24 09:08
个人简介

我就在这里

文章分类

全部博文(321)

文章存档

2015年(9)

2014年(84)

2013年(101)

2012年(25)

2011年(29)

2010年(21)

2009年(6)

2008年(23)

2007年(23)

分类: Java

2013-06-24 14:56:14


  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.  * FileLocke是文件锁,进程锁,控制不同程序(JVM)对同一文件的并发访问
  10.  * FileLock是java 1.4 版本后出现的一个类,它可以通过对一个可写文件(w)加锁,
  11.  * 保证同时只有一个进程可以拿到文件的锁,这个进程从而可以对文件做访问;
  12.  * 而其它拿不到锁的进程要么选择被挂起等待,要么选择去做一些其它的事情,
  13.  * 这样的机制保证了众进程可以顺序访问该文件。
  14.  * 也可以看出,能够利用文件锁的这种性质,在一些场景下,虽然我们不需要操作某个文件,
  15.  * 但也可以通过 FileLock 来进行并发控制,保证进程的顺序执行,避免数据错误。
  16.  * ---用于进程间并发
  17.  * Locks are associated with files, not channels. Use locks to coordinate
  18.  * with external processes, not between threads in the same JVM.
  19.  * ---概念
  20.  * 共享锁:共享读操作,但只能一个写
  21.  * 排它锁:只有一个读或一个写
  22.  * API中说:文件锁是独占或者共享的,共享锁防止其他正在运行的程序获得重复的独占锁,但是允许他们获得
  23.  * 重复的共享锁,独占锁防止其他程序获得任何类型的锁。一旦锁释放,它就对其他程序可能要获得的锁没有了后续影响.
  24.  * ---FileLock FileChannel.lock(long position, long size, boolean shared),文件锁
  25.  * shared的含义:是否使用共享锁,一些不支持共享锁的操作系统,将自动将共享锁改成排它锁.
  26.  * 可以通过调用isShared()方法来检测获得的是什么类型的锁
  27.  * ---lock()和tryLock()的区别
  28.  * lock()阻塞的方法,锁定范围可以随着文件的增大而增加
  29.  * tryLock()非阻塞,当未获得锁时,返回null.
  30.  * ---FileLock的生命周期
  31.  * 在调用FileLock.release(),或者Channel.close(),或者JVM关闭
  32.  * ---FileLock是线程安全的
  33.  * ---boolean java.nio.channels.FileLock.overlaps(long position, long size)
  34.  * true表示当前锁在区域内,false表示当前锁的区域与参数区域不重叠
  35.  *     注意事项:
  36.     1.同一进程内,在文件锁没有被释放之前,不可以再次获取。
  37.      即在release()方法调用前,只能lock()或者tryLock()一次。
  38.     2.文件锁的效果是与操作系统相关的。一些系统中文件锁是强制性的(mandatory),
  39.      就当Java的某进程获得文件锁后,操作系统将保证其它进程无法对文件做操作了。
  40.      而另一些操作系统的文件锁是询问式的(advisory),意思是说要想拥有进程互斥的效果,
  41.      其它的进程也必须也按照API所规定的那样来申请或者检测文件锁,不然,将起不到进程互斥的功能。
  42.      所以,文档里建议将所有系统都当做是询问式系统来处理,这样程序更加安全也更容易移植。
  43.     *如何避免死锁
  44.     在读写关键数据时加锁,操作完成后解锁;
  45.     一次性申请所有需要的资源,并且在申请不成功的情况下放弃已申请到的资源;
  46.  * @author shijin
  47.  *
  48.  */
  49. public class FileLockTest {
  50.     /**
  51.      * 如代码所示,需要进行互斥的进程只要将自己的代码替换掉//互斥操作即可,
  52.      * 每个进程在运行实际逻辑功能代码之前,会尝试获取锁文件锁,
  53.      * 得到文件锁的进程可以继续执行后续的代码,而没有获得锁文件的进程将被操作系统挂起(suspend),
  54.      * 等到其它进程将文件锁释放后再重新开始尝试获取文件锁。
  55.      * 这样子,进程就可以通过FileLock来实现间的互斥运行。
  56.      * @param args
  57.      */
  58.     public static void main(String[] args){
  59.         FileChannel channel = null;
  60.         FileLock lock = null;
  61.         try {
  62. //            对于一个只读文件通过任意方式加锁时会报NonWritableChannelException异常
  63. //            同样对写通道通过有参lock()方式加锁时也会报NonReadableChannelException异常
  64. //            无参lock()默认为独占锁,不会报NonReadableChannelException异常,因为独占就是为了写
  65. //            所谓的共享也只能读共享,写是独占的,共享锁控制的代码只能是读操作
  66. //            channel = new FileOutputStream("logfile.txt",true).getChannel();
  67.             
  68.             RandomAccessFile raf = new RandomAccessFile("logfile.txt","rw");
  69.             raf.seek(raf.length());//raf在文件末尾追加内容的处理
  70.             channel = raf.getChannel();
  71.             
  72. //            获得锁方法一lock,阻塞的方法,当文件锁不可用时,当前进程会被挂起
  73. //            lock = channel.lock(0L, Long.MAX_VALUE, true);//共享锁,有写操作会报异常
  74.             lock = channel.lock();//独占锁
  75.             
  76. //            获得锁方法二trylock,非阻塞的方法,当文件锁不可用时,tryLock()会得到null值
  77. //            do {
  78. //                lock = channel.tryLock();
  79. //            } while(null == lock);

  80. //            互斥操作
  81.             ByteBuffer sendBuffer=ByteBuffer.wrap((new Date()+" 写入\n").getBytes());
  82.             channel.write(sendBuffer);
  83.             Thread.sleep(5000);
  84.         } catch (FileNotFoundException e) {
  85.             e.printStackTrace();
  86.         } catch (IOException e) {
  87.             e.printStackTrace();
  88.         } catch (InterruptedException e) {
  89.             e.printStackTrace();
  90.         } finally {
  91.             if(lock != null) {
  92.                 try {
  93.                     lock.release();
  94.                     lock = null;
  95.                 } catch (IOException e) {
  96.                     e.printStackTrace();
  97.                 }
  98.             }
  99.             if(channel != null) {
  100.                 try {
  101.                     channel.close();
  102.                     channel = null;
  103.                 } catch (IOException e) {
  104.                     e.printStackTrace();
  105.                 }
  106.             }
  107.         }
  108.     }
  109. }
  110. /**
  111.  *     间隔一秒钟两次运行本程序,程序会在文件锁的控制下对logfile.txt进行互斥操作
  112.     logfile.txt内容:
  113.     Thu Aug 16 15:39:02 CST 2012 写入
  114.     Thu Aug 16 15:39:07 CST 2012 写入
  115.     
  116.     当采用第二种方法时,若还未获得文件锁就对文件进行操作,则会报以下异常:
  117.     Exception in thread "main" java.io.IOException: 另一个程序已锁定文件的一部分,进程无法访问。
  118.     at sun.nio.ch.FileDispatcher.write0(Native Method)
  119.     at sun.nio.ch.FileDispatcher.write(Unknown Source)
  120.     at sun.nio.ch.IOUtil.writeFromNativeBuffer(Unknown Source)
  121.     at sun.nio.ch.IOUtil.write(Unknown Source)
  122.     at sun.nio.ch.FileChannelImpl.write(Unknown Source)
  123.     at FileLockTest.main(FileLockTest.java:19)
  124.  */
转自:http://blog.csdn.net/shijinupc/article/details/7875826
阅读(9851) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~