文件锁FileLock

1.文件锁的定义

　　FileLock是文件锁，进程锁，用于进程间并发，控制不同程序（JVM）对同一文件的并发访问。

　　FileLock是java 1.4 版本后出现的一个类，它可以通过对一个可写文件(w)加锁，保证同时只有一个进程可以拿到文件的锁，这个进程从而可以对文件做访问；而其它拿不到锁的进程要么选择被挂起等待，要么选择去做一些其它的事情，这样的机制保证了众进程可以顺序访问该文件。

　　可以看出，能够利用文件锁的这种性质，在一些场景下，虽然我们不需要向文件中写入数据，不受其他程序的打扰，文件锁就很合适。

　　java.nio.channels.FileChannel，FileChannel是NIO中的一个类。

2.独占锁与共享锁

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

　　共享锁：如果一个线程获得一个文件的共享锁，那么其它线程可以获得同一文件的共享锁或同一文件部分内容的共享锁，但不能获取排它锁

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

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

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

　　所以一个进程中的线程获得了文件锁，希望进程内其他线程可以做读操作时，可以使用共享锁。写操作是不被支持的。

3.使用tryLock来获取锁

　　 lock()阻塞的方法，锁定范围可以随着文件的增大而增加。

　　 tryLock()非阻塞,当未获得锁时,返回null。

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

　　boolean java.nio.channels.FileLock.overlaps(long position, long size)，true表示当前锁在区域内，false表示当前锁的区域与参数区域不重叠。

　　文件锁的效果是与操作系统相关的，是由操作系统底层来实现的。比如，在windows下，进程间不能同时读写一个文件，而在Linux下，不同的进程可以同时读写一个文件。

　　在读写关键数据时加锁，操作完成后解锁，lock.release();放到finally中。

　　一次性申请所有需要的资源，并且在申请不成功的情况下放弃已申请到的资源;　　

public class FileLockTest {

    /**

     * 如代码所示，需要进行互斥的进程只要将自己的代码替换掉//互斥操作即可，

     * 每个进程在运行实际逻辑功能代码之前，会尝试获取锁文件锁，

     * 得到文件锁的进程可以继续执行后续的代码，而没有获得锁文件的进程将被操作系统挂起(suspend)，

     * 等到其它进程将文件锁释放后再重新开始尝试获取文件锁。

     * 这样子，进程就可以通过FileLock来实现间的互斥运行。

     * @param args

     */

    public static void main(String[] args){

        FileChannel channel = null;

        FileLock lock = null;

        try {

//            对于一个只读文件通过任意方式加锁时会报NonWritableChannelException异常

//            同样对写通道通过有参lock()方式加锁时也会报NonReadableChannelException异常

//            无参lock()默认为独占锁，不会报NonReadableChannelException异常，因为独占就是为了写

//            所谓的共享也只能读共享，写是独占的，共享锁控制的代码只能是读操作

//            channel = new FileOutputStream("logfile.txt",true).getChannel();

            RandomAccessFile raf = new RandomAccessFile("logfile.txt","rw");

            raf.seek(raf.length());//raf在文件末尾追加内容的处理

            channel = raf.getChannel();

//            获得锁方法一lock，阻塞的方法，当文件锁不可用时，当前进程会被挂起

//            lock = channel.lock(0L, Long.MAX_VALUE, true);//共享锁，有写操作会报异常

            lock = channel.lock();//独占锁

//            获得锁方法二trylock，非阻塞的方法，当文件锁不可用时，tryLock()会得到null值

//            do {

//                lock = channel.tryLock();

//            } while(null == lock);

//            互斥操作

            ByteBuffer sendBuffer=ByteBuffer.wrap((new Date()+" 写入\n").getBytes());

            channel.write(sendBuffer);

            Thread.sleep(5000);

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } catch (InterruptedException e) {

            e.printStackTrace();

        } finally {

            if(lock != null) {

                try {

                    lock.release();

                    lock = null;

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(channel != null) {

                try {

                    channel.close();

                    channel = null;

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

/**

 *     间隔一秒钟两次运行本程序，程序会在文件锁的控制下对logfile.txt进行互斥操作

    logfile.txt内容：

    Thu Aug 16 15:39:02 CST 2012 写入

    Thu Aug 16 15:39:07 CST 2012 写入

    当采用第二种方法时，若还未获得文件锁就对文件进行操作，则会报以下异常：

    Exception in thread "main" java.io.IOException: 另一个程序已锁定文件的一部分，进程无法访问。

    at sun.nio.ch.FileDispatcher.write0(Native Method)

    at sun.nio.ch.FileDispatcher.write(Unknown Source)

    at sun.nio.ch.IOUtil.writeFromNativeBuffer(Unknown Source)

    at sun.nio.ch.IOUtil.write(Unknown Source)

    at sun.nio.ch.FileChannelImpl.write(Unknown Source)

    at FileLockTest.main(FileLockTest.java:19)

 */