Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

ReentrantLock和ReentrantReadWriteLock对比

追梦1819 2019-01-24 15:07:00 阅读数:214 评论数:0 点赞数:0 收藏数:0

本文系作者原创,转载请注明:https://www.cnblogs.com/yanfei1819/p/10314533.html

ReentrantLock

一、简介

ReentrantLock重入锁和synchronize关键字一样,是互斥锁。比synchronize关键字更加灵活。

二、基本方法

三、与synchronize对比

  1. demo演示

    线程不安全:

    public class WriteAndReadThread {
    public static void main(String[] args) {
    Person person = new Person();
    Thread t1 = new Output(person);
    Thread t2 = new Input(person);
    t1.start();
    t2.start();
    }
    }
    // 写数据的线程
    class Output extends Thread {
    private Person person;
    public Output(Person person) {
    this.person = person;
    }
    @Override
    public void run() {
    int count = 0;
    while (true) {
    if (count == 0) {
    person.name = "小明";
    person.gender = "男";
    } else {
    person.name = "小红";
    person.gender = "女";
    }
    count = (count + 1) % 2; // 奇数偶数轮流展现
    person.flag = true;
    }
    }
    }
    // 读数据的线程
    class Input extends Thread {
    private Person person;
    public Input(Person person) {
    this.person = person;
    }
    @Override
    public void run() {
    while (true) {
    System.out.println(person.name + "," + person.gender);
    }
    }
    }
    class Person {
    public String name;
    public String gender;
    public boolean flag = false;
    }

    以上代码没有考虑线程安全问题,读写线程会竞争共享资源,导致数据紊乱。

    1)线程安全(加synchronize关键字):

    public class ThreadTwo {
    public static void main(String[] args) {
    Person person = new Person();
    Thread t1 = new Output(person);
    Thread t2 = new Input(person);
    t1.start();
    t2.start();
    }
    }
    // 写的线程
    class Output extends Thread{
    private Person person;
    public Output(Person person){
    this.person=person;
    }
    @Override
    public void run(){
    int count = 0;
    while (true){
    synchronized (person){
    if(person.flag){
    try {
    person.wait(); // 唤醒等待的线程
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    if(count==0){
    person.name="小明";
    person.gender="男";
    }else {
    person.name="小红";
    person.gender="女";
    }
    count=(count+1)%2;
    person.flag=true;
    person.notify();
    }
    }
    }
    }
    // 读数据的线程
    class Input extends Thread{
    private Person person;
    public Input(Person person){
    this.person=person;
    }
    @Override
    public void run(){
    while (true){
    synchronized (person){
    if(!person.flag){
    try {
    person.wait();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    System.out.println(person.name+","+person.gender);
    person.flag=false;
    person.notify();
    }
    }
    }
    }
    class Person{
    public String name;
    public String gender;
    public boolean flag=false;
    }

    2)线程安全(用Lock):

    public class LockDemo {
    public static void main(String[] args) {
    Person2 person2 = new Person2();
    Condition condition = person2.lock.newCondition();
    Input2 input2 = new Input2(person2,condition);
    Output2 output2 = new Output2(person2,condition);
    input2.start();
    output2.start();
    }
    }
    // 写的线程
    class Output2 extends Thread {
    private Person2 person;
    private Condition condition;
    public Output2(Person2 person, Condition condition) {
    this.person = person;
    this.condition = condition;
    }
    @Override
    public void run() {
    int count = 0;
    while (true) {
    try {
    person.lock.lock();
    if (person.flag) {
    try {
    condition.await(); // 使线程休眠,作用等于synchronize中的thread.wait()方法
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    if (count == 0) {
    person.name = "小明";
    person.gender = "男";
    } else {
    person.name = "小红";
    person.gender = "女";
    }
    count = (count + 1) % 2;
    person.flag = true;
    condition.signal();
    }catch (Exception e){
    }finally {
    person.lock.unlock(); // 必须手动关闭线程
    }
    }
    }
    }
    // 读的线程
    class Input2 extends Thread {
    private Person2 person;
    private Condition condition; // 该接口的作用是精确控制锁的行为
    public Input2(Person2 person, Condition condition) {
    this.person = person;
    this.condition = condition;
    }
    @Override
    public void run() {
    while (true) {
    try {
    person.lock.lock();
    if (!person.flag) {
    try {
    condition.await();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    System.out.println(person.name + "," + person.gender);
    person.flag = false;
    condition.signal();//唤醒线程
    }catch (Exception e){
    }finally {
    person.lock.unlock();
    }
    }
    }
    }
    class Person2 {
    public String name;
    public String gender;
    public boolean flag = false; // 该属性是用来控制线程之间的通讯
    Lock lock = new ReentrantLock();
    }
  2. 总结

    相同点:

    ​ 都是用于线程同步锁,都是互斥锁。

    不同点:

    ​ 1.如果用汽车来类比,synchronize相当于自动挡,Lock相当于手动挡。即:synchronize是内置锁,只要加上synchronize的代码的地方开始,代码结束的地方自动释放资源。lock必须手动加锁,手动释放资源。

    ​ 2.synchronize优点是代码量少,自动化。缺点是扩展性低,不够灵活。

    ​ 3.Lock优点是扩展性好,灵活。缺点是代码量相对稍多。

    ​ 4.释放锁的情况:

    ​ synchronize:1)线程执行完毕;2)线程发生异常;3)线程进入休眠状态。

    ​ Lock:通过unLock()方法。

    注意点:

    ​ 1.wait()和notify()/notifyAll()必须出现在synchronize修饰的代码块中;

    ​ 2.资源的释放通常放在finally中;

    ​ 3.最好不要将lock()方法写在try{}中,因为如果 发生异常的话,抛出异常,同时锁资源无法释放。

ReentrantReadWriteLock

一、简介

​ ReentrantLock虽然可以灵活地实现线程安全,但是他是一种完全互斥锁,即某一时刻永远只允许一个线程访问共享资源,不管是读数据的线程还是写数据的线程。这导致的结果就是,效率低下。

​ ReentrantReadWriteLock类的出现很好的解决了该问题。该类实现了ReadWriteLock接口,而ReadWriteLock接口中维护了两个锁:读锁(共享锁)和写锁(排他锁)。

public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}

二、基本方法

三、使用

​ ReentrantReadWriteLock中维护了读锁和写锁。允许线程同时读取共享资源;但是如果有一个线程是写数据,那么其他线程就不能去读写该资源。即会出现三种情况:读读共享,写写互斥,读写互斥。

以下以代码演示:

 ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
Lock readLock = reentrantReadWriteLock.readLock();
Lock writeLock = reentrantReadWriteLock.readLock();
new Thread(new Runnable() {
@Override
public void run() {
// writeLock.lock(); // 写锁加锁
readLock.lock(); // 读锁加锁
try {
for (int i = 0; i < 10; i++) {
System.out.println("我是第一个线程,线程名是"+Thread.currentThread().getName()+",当前时间是"+System.currentTimeMillis());
}
Thread.sleep(2000); // 休眠2s
}catch (Exception e){
}finally {
// writeLock.unlock();// 写锁释放锁
readLock.unlock();// 读锁释放锁
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// writeLock.lock(); // 写锁加锁
readLock.lock();// 读锁加锁
try {
for (int i = 0; i < 10; i++) {
System.out.println("我是第二个线程,线程名是"+Thread.currentThread().getName()+",当前时间是"+System.currentTimeMillis());
}
}catch (Exception e){
}finally {
// writeLock.unlock();// 写锁释放锁
readLock.unlock();
}
}
}).start();

以上两个线程如果是读锁,则会同时执行(打印的时间几乎相等),但是如果是写锁,则不会同时执行(打印时间相差2s)。

版权声明
本文为[追梦1819]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/yanfei1819/p/10314533.html

编程之旅,人生之路,不止于编程,还有诗和远方。
阅代码原理,看框架知识,学企业实践;
赏诗词,读日记,踏人生之路,观世界之行;