Java并发编程之重入锁与读写锁

重入锁

重入锁，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞，该特性的实现需要解决以下两个问题。

1、线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。

2、锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。

java里面内置锁(synchronize)和lock(reentrantlock)都是可重入的

synchronized 实例

package com.home;
public class synchronizedtest implements runnable {
  public synchronized void method1() {
    system.out.println("method1获得锁，正常运行!");
    method2();
  }
  public synchronized void method2() {
    system.out.println("method2获得锁，也正常运行!");
  }
  @override
  public void run() {
    method1();
  }
  public static void main(string[] args) {
    synchronizedtest st = new synchronizedtest();
    new thread(st).start();
    new thread(st).start();
  }
}

lock 实例

package com.home;
import java.util.concurrent.locks.lock;
import java.util.concurrent.locks.reentrantlock;
public class locktest implements runnable {
  lock lock = new reentrantlock();
  public void method1() {
    lock.lock();
    system.out.println("method1获得锁，正常运行!");
    method2();
    lock.unlock();
  }
  public void method2() {
    lock.lock();
    system.out.println("method2获得锁，也正常运行!");
    lock.unlock();
  }
  @override
  public void run() {
    method1();
  }
  public static void main(string[] args) {
    locktest lt = new locktest();
    new thread(lt).start();
    new thread(lt).start();
  }
}

两个例子最后的结果都是正确的，结果如下：

method1获得锁，正常运行!
method2获得锁，也正常运行!
method1获得锁，正常运行!
method2获得锁，也正常运行!

可重入锁最大的作用是避免死锁

读写锁

读写锁维护了一对相关的锁，一个用于只读操作，一个用于写入操作。只要没有writer，读取锁可以由多个reader线程同时保持。写入锁是独占的。

可重入读写锁 reentrantreadwritelock

reentrantreadwritelock对象提供了readlock()和writelock()方法, 用于获取读取锁和写入锁.

读取锁允许多个reader线程同时持有, 而写入锁最多只能有一个writter线程持有.

读写锁的使用场合: 读取共享数据的频率远大于修改共享数据的频率. 在上述场合下, 使用读写锁控制共享资源的访问, 可以提高并发性能.

如果一个线程已经持有了写入锁, 则可以再持有读写锁. 相反, 如果一个线程已经持有了读取锁, 则在释放该读取锁之前, 不能再持有写入锁.

可以调用写入锁的newcondition()方法获取与该写入锁绑定的condition对象, 此时与普通的互斥锁并没有什么区别. 但是调用读取锁的newcondition()方法将抛出异常.

例子

package com.home;
import java.util.random;
import java.util.concurrent.locks.readwritelock;
import java.util.concurrent.locks.reentrantreadwritelock;
class readwrte {
  // 共享数据，可以多个线程读数据，只能有一个线程写数据
  private int data;
  // 创建读写锁
  readwritelock rwlock = new reentrantreadwritelock();
  /**
   * 读数据，上读锁
   */
  public void get() {
    // 读锁
    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 (exception e) {
      e.printstacktrace();
    } finally {
      rwlock.readlock().unlock();
    }
  }
  /**
   * 写数据，上写锁
   *
   * @param data
   */
  public void put(int data) {
    // 写锁
    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 (interruptedexception e) {
      e.printstacktrace();
    } finally {
      rwlock.writelock().unlock();
    }
  }
  public int getdata() {
    return data;
  }
  public void setdata(int data) {
    this.data = data;
  }
}
/**
 * 测试类
 *
 * @author itmyhome
 *
 */
public class readwritelocktest {
  /**
   * @param args
   */
  public static void main(string[] args) {
    // 创建readwrte对象
    final readwrte rw = new readwrte();
    for (int i = 0; i < 10; i++) {
      // 创建并启动10个读线程
      new thread(new runnable() {
          @override
          public void run() {
            rw.get();
          }
        }).start();
      // 创建并启动10个写线程
      new thread(new runnable() {
          @override
          public void run() {
            // 写入一个随机数
            rw.put(new random().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并发编程之重入锁与读写锁的全部内容，希望对大家有所帮助。欢迎各位参阅本站其他专题，有什么问题可以随时留言，小编会及时回复大家的。感谢大家对本站的支持。