Java并发编程之重入锁与读写锁
重入锁
重入锁，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞，该特性的实现需要解决以下两个问题。
1、线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
2、锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。
Java里面内置锁(synchronize)和Lock(ReentrantLock)都是可重入的
synchronized实例
packagecom.home;
publicclassSynchronizedTestimplementsRunnable{
publicsynchronizedvoidmethod1(){
System.out.println("method1获得锁，正常运行!");
method2();
}
publicsynchronizedvoidmethod2(){
System.out.println("method2获得锁，也正常运行!");
}
@Override
publicvoidrun(){
method1();
}
publicstaticvoidmain(String[]args){
SynchronizedTestst=newSynchronizedTest();
newThread(st).start();
newThread(st).start();
}
}
Lock实例
packagecom.home;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
publicclassLockTestimplementsRunnable{
Locklock=newReentrantLock();
publicvoidmethod1(){
lock.lock();
System.out.println("method1获得锁，正常运行!");
method2();
lock.unlock();
}
publicvoidmethod2(){
lock.lock();
System.out.println("method2获得锁，也正常运行!");
lock.unlock();
}
@Override
publicvoidrun(){
method1();
}
publicstaticvoidmain(String[]args){
LockTestlt=newLockTest();
newThread(lt).start();
newThread(lt).start();
}
}
两个例子最后的结果都是正确的，结果如下：
method1获得锁，正常运行! method2获得锁，也正常运行! method1获得锁，正常运行! method2获得锁，也正常运行!
可重入锁最大的作用是避免死锁
读写锁
读写锁维护了一对相关的锁，一个用于只读操作，一个用于写入操作。只要没有writer，读取锁可以由多个reader线程同时保持。写入锁是独占的。
可重入读写锁ReentrantReadWriteLock
ReentrantReadWriteLock对象提供了readLock()和writeLock()方法,用于获取读取锁和写入锁.
读取锁允许多个reader线程同时持有,而写入锁最多只能有一个writter线程持有.
读写锁的使用场合:读取共享数据的频率远大于修改共享数据的频率.在上述场合下,使用读写锁控制共享资源的访问,可以提高并发性能.
如果一个线程已经持有了写入锁,则可以再持有读写锁.相反,如果一个线程已经持有了读取锁,则在释放该读取锁之前,不能再持有写入锁.
可以调用写入锁的newCondition()方法获取与该写入锁绑定的Condition对象,此时与普通的互斥锁并没有什么区别.但是调用读取锁的newCondition()方法将抛出异常.
例子
packagecom.home;
importjava.util.Random;
importjava.util.concurrent.locks.ReadWriteLock;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
classReadWrte{
//共享数据，可以多个线程读数据，只能有一个线程写数据
privateintdata;
//创建读写锁
ReadWriteLockrwLock=newReentrantReadWriteLock();
/**
*读数据，上读锁
*/
publicvoidget(){
//读锁
rwLock.readLock().lock();
try{
System.out.println(Thread.currentThread().getName()+",Read!");
Thread.sleep((long)Math.random()*1000);
System.out.println(Thread.currentThread().getName()+"读出的数据为："+
this.getData());
}catch(Exceptione){
e.printStackTrace();
}finally{
rwLock.readLock().unlock();
}
}
/**
*写数据，上写锁
*
*@paramdata
*/
publicvoidput(intdata){
//写锁
rwLock.writeLock().lock();
try{
System.out.println(Thread.currentThread().getName()+",Write!");
Thread.sleep((long)Math.random()*1000);
this.setData(data);
System.out.println(Thread.currentThread().getName()+"写入的数据为："+
this.getData());
}catch(InterruptedExceptione){
e.printStackTrace();
}finally{
rwLock.writeLock().unlock();
}
}
publicintgetData(){
returndata;
}
publicvoidsetData(intdata){
this.data=data;
}
}
/**
*测试类
*
*@authoritmyhome
*
*/
publicclassReadWriteLockTest{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//创建ReadWrte对象
finalReadWrterw=newReadWrte();
for(inti=0;i<10;i++){
//创建并启动10个读线程
newThread(newRunnable(){
@Override
publicvoidrun(){
rw.get();
}
}).start();
//创建并启动10个写线程
newThread(newRunnable(){
@Override
publicvoidrun(){
//写入一个随机数
rw.put(newRandom().nextInt(8));
}
}).start();
}
}
}
输出为
Thread-0,Read! Thread-4,Read! Thread-8,Read! Thread-12,Read! Thread-0读出的数据为：0 Thread-4读出的数据为：0 Thread-8读出的数据为：0 Thread-12读出的数据为：0 Thread-19,Write! Thread-19写入的数据为：5 Thread-7,Write! Thread-7写入的数据为：7 Thread-3,Write! Thread-3写入的数据为：4 Thread-16,Read! Thread-16读出的数据为：4 Thread-11,Write! Thread-11写入的数据为：0 Thread-15,Write! Thread-15写入的数据为：5 Thread-2,Read! Thread-2读出的数据为：5 Thread-17,Write! Thread-17写入的数据为：2 Thread-6,Read! Thread-6读出的数据为：2 Thread-1,Write! Thread-1写入的数据为：5 Thread-13,Write! Thread-13写入的数据为：4 Thread-9,Write! Thread-9写入的数据为：7 Thread-5,Write! Thread-5写入的数据为：2 Thread-10,Read! Thread-10读出的数据为：2 Thread-18,Read! Thread-14,Read! Thread-18读出的数据为：2 Thread-14读出的数据为：2
从图中我们可以看出，可以多个线程同时读，但只能一个线程写，即写数据和写入数据一并完成。
总结
以上就是本文关于Java并发编程之重入锁与读写锁的全部内容，希望对大家有所帮助。欢迎各位参阅本站其他专题，有什么问题可以随时留言，小编会及时回复大家的。感谢大家对本站的支持。