java 对文件进行加锁

1. 
   
2. ReentrantReadWriteLock 文件读写锁应用
   
3.  jdk 查看 java.util.concurrent.locks包下的类ReentrantReadWriteLock

方法摘要
protected Thread	getOwner() 返回当前拥有写入锁的线程，如果没有这样的线程，则返回 null。
protectedCollection<Thread>	getQueuedReaderThreads() 返回一个 collection，它包含可能正在等待获取读取锁的线程。
protectedCollection<Thread>	getQueuedThreads() 返回一个 collection，它包含可能正在等待获取读取或写入锁的线程。
protectedCollection<Thread>	getQueuedWriterThreads() 返回一个 collection，它包含可能正在等待获取写入锁的线程。
int	getQueueLength() 返回等待获取读取或写入锁的线程估计数目。
int	getReadHoldCount() 查询当前线程在此锁上保持的重入读取锁数量。
int	getReadLockCount() 查询为此锁保持的读取锁数量。
protectedCollection<Thread>	getWaitingThreads(Condition condition) 返回一个 collection，它包含可能正在等待与写入锁相关的给定条件的那些线程。
int	getWaitQueueLength(Condition condition) 返回正等待与写入锁相关的给定条件的线程估计数目。
int	getWriteHoldCount() 查询当前线程在此锁上保持的重入写入锁数量。
boolean	hasQueuedThread(Thread thread) 查询是否给定线程正在等待获取读取或写入锁。
boolean	hasQueuedThreads() 查询是否所有的线程正在等待获取读取或写入锁。
boolean	hasWaiters(Condition condition) 查询是否有些线程正在等待与写入锁有关的给定条件。
boolean	isFair() 如果此锁将公平性设置为 ture，则返回 true。
boolean	isWriteLocked() 查询是否某个线程保持了写入锁。
boolean	isWriteLockedByCurrentThread() 查询当前线程是否保持了写入锁。
ReentrantReadWriteLock.ReadLock	readLock() 返回用于读取操作的锁。
String	toString() 返回标识此锁及其锁状态的字符串。
ReentrantReadWriteLock.WriteLock	writeLock() 返回用于写入操作的锁。

1. 
   
2. package com.file.test;  
3.   
4. import java.io.File;  
5. import java.net.URI;  
6. import java.util.Hashtable;  
7. import java.util.concurrent.locks.ReentrantReadWriteLock;  
8.   
9. public class LockFile extends File{  
10.   
11.     private static Hashtable<String , ReentrantReadWriteLock> locks = new Hashtable<String , ReentrantReadWriteLock>();  
12.     private ReentrantReadWriteLock lock = null;  
13.       
14.     public LockFile(File arg0, String arg1) {  
15.         super(arg0, arg1);  
16.         lock = initLock(this.getAbsolutePath());  
17.     }  
18.   
19.     public LockFile(String arg0, String arg1) {  
20.         super(arg0, arg1);  
21.         lock = initLock(this.getAbsolutePath());  
22.     }  
23.   
24.     public LockFile(String arg0) {  
25.         super(arg0);  
26.         lock = initLock(this.getAbsolutePath());  
27.     }  
28.   
29.     public LockFile(URI arg0) {  
30.         super(arg0);  
31.         lock = initLock(this.getAbsolutePath());  
32.     }  
33.       
34.     /* 
35.      * 这里要注意使用 static synchronized，不然可能同时有多个进行初始化这个文件 
36.      */  
37.     private static synchronized ReentrantReadWriteLock initLock(String path) {  
38.         ReentrantReadWriteLock lock = locks.get(path);  
39.         if (lock == null) {  
40.             lock = new ReentrantReadWriteLock();  
41.             locks.put(path, lock);  
42.         }  
43.         return lock;  
44.     }  
45.       
46.     public ReentrantReadWriteLock getLock() {  
47.         return lock;  
48.     }  

1. package com.file.test;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileReader;  
7. import java.io.FileWriter;  
8. import java.io.IOException;  
9. import java.util.Random;  
10. import java.util.concurrent.locks.ReentrantReadWriteLock;  
11.   
12. public class LockFileTest {  
13.       
14.     private static final String FILE = "text.txt";  
15.       
16.     public static void main(String args[]) {  
17.         LockFileTest instance = new LockFileTest();  
18.         instance.run();  
19.     }  
20.       
21.     private void run() {  
22.         ReaderThread reader1 = new ReaderThread();  
23.         ReaderThread reader2 = new ReaderThread();  
24.         WriterThread writer1 = new WriterThread();  
25.         WriterThread writer2 = new WriterThread();  
26.           
27.         reader1.start();  
28.         reader2.start();  
29.         writer1.start();  
30.         writer2.start();  
31.     }  
32.       
33.     class ReaderThread extends Thread {  
34.           
35.         public void run() {  
36.               
37.             while (true) {  
38.                 String pre = null;  
39.                   
40.                 LockFile file = new LockFile(FILE);  
41.                 if (!file.exists()) continue;  
42.                 ReentrantReadWriteLock lock = file.getLock();  
43.                 lock.readLock().lock();  
44.                 try {  
45.                     BufferedReader reader = new BufferedReader(new FileReader(file));  
46.                     String line = reader.readLine();  
47.                     while (line != null) {  
48.                         if (pre == null) {  
49.                             pre = line;  
50.                         }  
51.                         else {  
52.                             if (!pre.equals(line)) {  
53.                                 System.out.println("read wrong");  
54.                             }  
55.                         }  
56.                         line = reader.readLine();  
57.                     }  
58.                 } catch (FileNotFoundException e) {  
59.                     e.printStackTrace();  
60.                 } catch (IOException e) {  
61.                     e.printStackTrace();  
62.                 }  
63.                 lock.readLock().unlock();  
64.             }  
65.         }  
66.     }  
67.       
68.     class WriterThread extends Thread {  
69.         Random random = new Random();  
70.         public void run() {  
71.             String s = String.valueOf(Math.abs(random.nextInt()));  
72.               
73.             LockFile file = new LockFile(FILE);  
74.             ReentrantReadWriteLock lock = file.getLock();  
75.             lock.writeLock().lock();  
76.             try {  
77.                 BufferedWriter writer = new BufferedWriter(new FileWriter(file));  
78.                 for (int i=0 ; i<1000 ; i++) {  
79.                           
80.                     for (int j=0 ; j<1000 ; j++) {  
81.                         writer.write(s + System.getProperty("line.separator"));  
82.                     }  
83.                 }  
84.                 writer.flush();  
85.                 writer.close();  
86.             } catch (IOException e) {  
87.                 e.printStackTrace();  
88.             }  
89.             lock.writeLock().unlock();  
90.         }  
91.     }  
92. }  

转载地址http://blog.csdn.net/sunnybuer/article/details/8263056