java多线程--ReentrantReadWriteLock的使用

java多线程--ReentrantReadWriteLock的使用

读写锁的使用，限制范围为：

 * 读读锁互斥，读写之间互斥，写写之间互斥

一.实例一，读读之间可以共享数据即可以同一时间获取读取锁

package readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
* 读写锁的使用，限制范围为：
* 读读锁互斥，读写之间互斥，写写之间互斥
*
* 本实例实现：读读共享，即读与读之间不互斥
* @author lxb
*
*/
public class Service {

private ReentrantReadWriteLock lock =new ReentrantReadWriteLock();

public void read(){
try{

try{
lock.readLock().lock(); //获取读取锁,因为是读取锁，所以这里不需要等待
System.out.println("获取读锁:"+Thread.currentThread().getName()+
" "+System.currentTimeMillis());

Thread.sleep(10000);
}finally{
lock.readLock().unlock();
}

}catch(InterruptedException e){

e.printStackTrace();
}

}
}


二.写锁之间互斥
package readwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
* 本实例实现写锁之间互斥
*
* @author lxb
*
*/
public class WriteService {

private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

public void write() {
try {

try {
lock.writeLock().lock(); // 获取读取锁,因为是读取锁，所以这里不需要等待
System.out.println("获取写锁:" + Thread.currentThread().getName()
+ " " + System.currentTimeMillis());

Thread.sleep(10000);
} finally {
lock.writeLock().unlock();
}

} catch (InterruptedException e) {

e.printStackTrace();
}
}

}


读锁测试线程：

package readwritelock;

public class ThreadA extends Thread{

private Service service;

public ThreadA(Service service){
this.service = service;
}

public void run(){
service.read();
}

}

package readwritelock;

public class ThreadB extends Thread{

private Service service;

public ThreadB(Service service){
this.service = service;
}

public void run(){
service.read();
}
}

写锁测试线程：
package readwritelock;

public class ThreadC extends Thread{

private WriteService service;

public ThreadC(WriteService service){
this.service = service;
}

public void run(){
service.write();
}
}


主线程：
package readwritelock;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub

//testReadLock();
testWriteLock();
}

public static void testReadLock() {

// service可看作是一个线程共享 的实例对象
Service service = new Service();

ThreadA a = new ThreadA(service);

a.setName("A");

ThreadB b = new ThreadB(service);

b.setName("B");
a.start();
b.start();
}

/**
* 打打印的结果应该是其中一个线程先获取锁，稍后 10秒后另一个线程再获取 锁
*/
public static void testWriteLock() {

// service可看作是一个线程共享 的实例对象
WriteService service = new WriteService();

ThreadC C = new ThreadC(service);

C.setName("C");

ThreadC D = new ThreadC(service);

D.setName("D");
C.start();
D.start();
}

}