FileChannel tryLock/lock method

 写了几个测试程序for tryLock/lock method，分成几种情况：

Case 1:  your java app lock file, then other software (e.g. notepad) can't modify and save the locked file

 

Case 2:  When another software (e.g. Excel) lock a file, if your java app try to lock it, will throw FileNotFoundException

 

Case 3: if you try to lock file  more than once in same thread or different thread, it will throw OverlappingFileLockException

 

Case 4: when one JVM is locking a file, if u try to call tryLock/Lock method in another JVM, tryLock method returns null immediately, lock method blocks until the previous JVM release lock.

 

 

Example for Case 1:

1.         File f = new File(filename);
2.         RandomAccessFile raf;
3.         try {
4.             raf = new RandomAccessFile(f, "rw");
5.             FileChannel fc = raf.getChannel();
6.             FileLock fl = fc.tryLock();
7.             System.out.println("locked");
8.             if (fl.isValid()) {
9.                 // do something here, use notepad to modify and try to save the
10.                 // lock file, Fail!
11.                 Thread.sleep(10000);
12.                 fl.release();
13.                 System.out.println("release lock");
14.             }
15.             raf.close();
16.         } catch (IOException e) {
17.             e.printStackTrace();
18.         } catch (InterruptedException e) {
19.             e.printStackTrace();
20.         }

 

Example for Case 2:

1. //before run this class, you must use excel to open e:/test.csv first, because excel can lock file
2.         File f = new File(filename);
3.         RandomAccessFile raf = null;
4.         
5.         System.out.println("**************Test lock method************");
6.         try {
7.             raf = new RandomAccessFile(f, "rw");
8.             FileChannel fc = raf.getChannel();
9.             FileLock fl = fc.lock();
10.             System.out.println("locked");
11.             if (fl.isValid()) {
12.                 fl.release();
13.                 System.out.println("release lock");
14.             }
15.         } catch (IOException e) {
16.             System.out.println(e);
17.         } finally {
18.             if (raf != null)
19.                 try {
20.                     raf.close();
21.                 } catch (IOException e) {
22.                     e.printStackTrace();
23.                 }
24.         }
26.         System.out.println("**************Test tryLock method************");
27.         try {
28.             raf = new RandomAccessFile(f, "rw");
29.             FileChannel fc = raf.getChannel();
30.             FileLock fl = fc.tryLock();
31.             System.out.println("locked");
32.             if (fl.isValid()) {
33.                 fl.release();
34.                 System.out.println("release lock");
35.             }
36.         } catch (IOException e) {
37.             System.out.println(e);
38.         } finally {
39.             if (raf != null)
40.                 try {
41.                     raf.close();
42.                 } catch (IOException e) {
43.                     e.printStackTrace();
44.                 }
45.         }

Example for Case 3:

1.     public void testLockInSameThread() {
2.         System.out
3.                 .println("*********************Test lock in the same thread***************");
4.         RandomAccessFile raf1 = null;
5.         RandomAccessFile raf2 = null;
6.         try {
7.             raf1 = new RandomAccessFile(filename, "rw");
8.             FileChannel fc1 = raf1.getChannel();
10.             raf2 = new RandomAccessFile(filename, "rw");
11.             FileChannel fc2 = raf2.getChannel();
13.             System.out.println("Grabbing first lock");
14.             fc1.lock();
16.             System.out.println("Grabbing second lock");
17.             fc2.tryLock();
18.         } catch (Exception e) {
19.             e.printStackTrace();
20.         } finally {
21.             try {
22.                 if (raf1 != null)
23.                     raf1.close();
24.                 if (raf2 != null)
25.                     raf2.close();
26.             } catch (Exception e) {
27.             }
28.         }
30.         System.out.println("Exiting");
31.     }
33.     public void testLockInDifferentThread() throws Exception {
34.         System.out
35.                 .println("*********************Test lock in the different thread***************");
36.         RandomAccessFile raf1 = new RandomAccessFile(filename, "rw");
37.         FileChannel fc1 = raf1.getChannel();
38.         System.out.println("Grabbing first lock");
39.         fc1.lock();
41.         new Thread() {
42.             public void run() {
43.                 RandomAccessFile raf2;
44.                 try {
45.                     raf2 = new RandomAccessFile(filename, "rw");
46.                     FileChannel fc2 = raf2.getChannel();
47.                     System.out.println("Grabbing second lock");
48.                     fc2.tryLock();
49.                 } catch (Exception e) {
50.                     e.printStackTrace();
51.                 }
52.             }
53.         }.start();
55.         System.out.println("Done");
57.     }

 

Example for Case 4:

1. public class TryLockReturnNullAndLockBlockDemoStep1 {
2.     public static void main(String args[]) {
3.         String fileName="e://locktest.txt";
4.         try {
5.             RandomAccessFile r = new RandomAccessFile(fileName, "rw");
6.             FileChannel channel = r.getChannel();
7.             FileLock fl = channel.tryLock();
8.             System.out.println("FileLock obj is valid? " + fl.isValid());
9.             Thread.sleep(10000);
10.             System.out.println("release lock");
11.             channel.close();
12.         } catch (IOException e) {
13.             e.printStackTrace();
14.         } catch (InterruptedException e) {
15.             e.printStackTrace();
16.         }
17.     }
19. }
21. /**
22.  * !!NOTE: before run TryLockReturnNullAndLockBlockDemoStep2, you must run
23.  * TryLockReturnNullAndLockBlockDemoStep1 first
24.  * 
25.  * this class is used to test when one JVM is locking a file, what happen when
26.  * try to call tryLock/Lock method in another JVM
27.  * 
28.  * following codes show that:
29.  * 
30.  * 1. when u call tryLock method, the method return (return value is null)
31.  * immediately
32.  * 
33.  * 2. when u call Lock method, the method will block until
34.  * TryLockReturnNullAndLockBlockDemoStep1 release lock (after 30 secconds)
35.  * 
36.  */
37. public class TryLockReturnNullAndLockBlockDemoStep2 {
38.     public static void main(String args[]) {
39.         try {
40.             RandomAccessFile r = new RandomAccessFile("e://locktest.txt", "rw");
41.             FileChannel channel = r.getChannel();
43.             System.out.println("calling tryLock method...");
44.             FileLock f1 = channel.tryLock();
45.             System.out
46.                     .println("tryLock return value is null?  " + (f1 == null));
48.             System.out
49.                     .println("calling Lock method... (it will block until TryLockReturnNullAndLockBlockDemoStep1 release lock (after 30 secconds)");
50.             FileLock f2 = channel.lock();
51.             System.out.println("lock method is not blocked");
52.             System.out.println("lock return value is null?  " + (f2 == null));
54.         } catch (IOException e) {
55.             e.printStackTrace();
56.         }
57.     }
58. }