synchronized、ReentrantLock和ReentrantReadWriteLock

最新推荐文章于 2023-12-27 13:09:47 发布
最新推荐文章于 2023-12-27 13:09:47 发布
阅读量130 收藏 1
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suchenbin/article/details/100994674
版权

简单看下不同情况下，它们的效率

1、读多读少的情况（读：1000，写：30）

synchronized

package com.su.mybatis.oracle.controller;

public class Test {
    
    private static int num = 100;
    //锁
    private static Object obj = new Object();
    //读线程数
    private static int readThreadNum = 1000;
    //写线程数
    private static int writeThreadNum = 30;
    //开始时间
    private static long startTime;

    public static void main(String[] args) {
        startTime = System.currentTimeMillis();
        for(int i = 0; i< readThreadNum; i++) {
            //读线程
            new Thread(new Runnable(){
                @Override
                public void run() {
                    try {
                        read();
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        for(int i = 0 ; i < writeThreadNum; i++) {
            //写线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        write();
                        Thread.sleep(15);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    //读业务
    public static void read() throws InterruptedException {
        synchronized(obj) {
            Thread.sleep(5);
            System.out.println("线程(" + Thread.currentThread().getName() + ")执行读业务，num：" + num
                    + "，耗时：" + ( System.currentTimeMillis()- startTime)+ "ms");
        }
    }

    //写业务
    public synchronized static void write() throws InterruptedException {
        synchronized(obj) {
            Thread.sleep(10);
            num++;
            System.out.println("线程(" + Thread.currentThread().getName() + ")执行写业务，num：" + num
                    + "，耗时：" + ( System.currentTimeMillis()- startTime)+ "ms");
        }
    }
}

输出结果：

线程(Thread-0)执行读业务，num：100，耗时：7ms
线程(Thread-55)执行读业务，num：100，耗时：13ms
.
.
.
线程(Thread-1002)执行写业务，num：129，耗时：6103ms
线程(Thread-1001)执行写业务，num：130，耗时：6114ms

ReentrantLock

package com.su.mybatis.oracle.controller;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    
    private static int num = 100;
    //重入锁
    private final static Lock lock = new ReentrantLock();
    //读线程数
    private static int readThreadNum = 1000;
    //写线程数
    private static int writeThreadNum = 30;
    //开始时间
    private static long startTime;

    public static void main(String[] args) {
        startTime = System.currentTimeMillis();
        for(int i = 0; i< readThreadNum; i++) {
            //读线程
            new Thread(new Runnable(){
                @Override
                public void run() {
                    try {
                        read();
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        for(int i = 0 ; i < writeThreadNum; i++) {
            //写线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        write();
                        Thread.sleep(15);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    //读业务
    public static void read() throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(5);
            System.out.println("线程(" + Thread.currentThread().getName() + ")执行读业务，num：" + num
                    + "，耗时：" + ( System.currentTimeMillis()- startTime)+ "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    //写业务
    public synchronized static void write() throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(10);
            num++;
            System.out.println("线程(" + Thread.currentThread().getName() + ")执行写业务，num：" + num
                    + "，耗时：" + ( System.currentTimeMillis()- startTime)+ "ms");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出结果：

线程(Thread-0)执行读业务，num：100，耗时：7ms
线程(Thread-1)执行读业务，num：100，耗时：14ms
.
.
.
线程(Thread-1002)执行写业务，num：129，耗时：6154ms
线程(Thread-1001)执行写业务，num：130，耗时：6165ms

ReentrantReadWriteLock

package com.su.mybatis.oracle.controller;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test {
    
    private static int num = 100;
    //读写锁
    private static ReadWriteLock lock = new ReentrantReadWriteLock();
    //读锁
    private static Lock r = lock.readLock();
    //写锁
    private static Lock w = lock.writeLock();
    
    //读线程数
    private static int readThreadNum = 1000;
    //写线程数
    private static int writeThreadNum = 30;
    //开始时间
    private static long startTime;

    public static void main(String[] args) {
        startTime = System.currentTimeMillis();
        for(int i = 0; i< readThreadNum; i++) {
            //读线程
            new Thread(new Runnable(){
                @Override
                public void run() {
                    try {
                        read();
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        for(int i = 0 ; i < writeThreadNum; i++) {
            //写线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        write();
                        Thread.sleep(15);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    //读业务
    public static void read() throws InterruptedException {
        try {
            r.lock();
            Thread.sleep(5);
            System.out.println("线程(" + Thread.currentThread().getName() + ")执行读业务，num：" + num
                    + "，耗时：" + ( System.currentTimeMillis()- startTime)+ "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            r.unlock();
        }
    }

    //写业务
    public synchronized static void write() throws InterruptedException {
        try {
            w.lock();
            Thread.sleep(10);
            num++;
            System.out.println("线程(" + Thread.currentThread().getName() + ")执行写业务，num：" + num
                    + "，耗时：" + ( System.currentTimeMillis()- startTime)+ "ms");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            w.unlock();
        }
    }
}

输出结果：

线程(Thread-1)执行读业务，num：100，耗时：8ms
线程(Thread-3)执行读业务，num：100，耗时：8ms
.
.
.
线程(Thread-1002)执行写业务，num：129，耗时：497ms
线程(Thread-1001)执行写业务，num：130，耗时：508ms

2、写多读少的情况（读：30，写：1000）

将上面代码中读线程数和写线程数交换

synchronized

输出结果：

线程(Thread-0)执行读业务，num：100，耗时：7ms
线程(Thread-30)执行写业务，num：101，耗时：18ms
.
.
.
线程(Thread-151)执行写业务，num：1099，耗时：10861ms
线程(Thread-150)执行写业务，num：1100，耗时：10872ms

ReentrantLock

输出结果：

线程(Thread-0)执行读业务，num：100，耗时：7ms
线程(Thread-1)执行读业务，num：100，耗时：13ms
.
.
.
线程(Thread-32)执行写业务，num：1099，耗时：10909ms
线程(Thread-31)执行写业务，num：1100，耗时：10920ms

 ReentrantReadWriteLock

输出结果：

线程(Thread-4)执行读业务，num：100，耗时：7ms
线程(Thread-3)执行读业务，num：100，耗时：7ms
.
.
.
线程(Thread-140)执行写业务，num：1099，耗时：10691ms
线程(Thread-141)执行写业务，num：1100，耗时：10702ms

对比：

1）、synchronized关键字是jdk提供的语言层次的内置锁，是不公平锁，ReentrantLock是显示锁，可以指定是否为公平锁，使用时是需要进行实例化，会占据一定的资源（如：内存等），在性能上，synchronized略优于ReentrantLock；

2）、使用上，ReentrantLock更加灵活，synchronized会自动释放锁，而使用ReentrantLock则要记得释放锁；

3）、ReentrantLock提供了特殊需求，如超时获取、，尝试非阻塞获取锁等；

结论：没有特殊需求，尽可能使用synchronized，有特殊需求，考虑ReentrantLock；同时存在读操作和写操作时，使用ReentrantReadWriteLock，读操作越多，性能优势越明显。

 

 

如果有写的不对的地方，请大家多多批评指正，非常感谢！

黑衣如墨剑如雪
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2019.11.14学习总结
qq_41641761的博客
11-15 324
Java开发中几种常见的锁 1.公平锁 是指多个线程按照申请锁的顺序来获取资源，类似于队列，先进先出（FIFO）。 2.非公平锁 是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程先获得锁。在高并发的情况下，有可能造成优先级反转或饥饿现象。 源码： public ReentrantLock(boolean fair) { sync = fair ? new F...
JUC知识点总结（三）ReentrantLock与ReentrantReadWriteLock源码解析
01-21
8. Lock接口 （ReentrantLock 可重入锁） 特性 ReentantLock 继承接口 Lock 并实现了接口中定义的方法， 它是一种可重入锁， 除了能完成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁...
synchronized、ReentrantLock、ReadWriteLock
yu487的专栏
01-22 280
1、synchronized和ReentrantLock的区别 synchronized是和if、else、for、while一样的关键字，ReentrantLock是类，这是二者的本质区别。既然ReentrantLock是类，那么它就提供了比synchronized更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量，ReentrantLock比synchronized的扩展性体现...
Synchronized、ReentrantLock、ReadWriteLock 介绍
最新发布
小湘西的博客
12-27 501
是包中的一个类，它提供了比 synchronized 更多的功能。是一个接口，它包含一对锁，一个读锁和一个写锁，通过分离读和写操作来提高并发性能。
synchronized，ReentrantLock、ReentrantReadWriteLock和StampedLock
进化的深山猿
01-23 891
java四种上锁方式原理及适用场景区分 synchronized（monitor）、ReentantLock（AQS）、AtomicLong（CAS）、LongAdder（XADD） 针对代码块需要同步的锁 synchronized---锁竞争不激烈的场景 竞争不激烈的时候，各种锁优化机制会发挥作用（如轻量级锁、偏向锁、自旋锁、锁消除等），如果竞争激烈，会使用重量级锁，性能下降。 Reentan...
ReentrantLock和ReentrantReadWriteLock
army27的专栏
01-09 73
contention-profiling:ReentrantLock 和 ReentrantReadWriteLock 上的配置文件争用
06-10
`ReentrantLock`和`ReentrantReadWriteLock`是Java并发包`java.util.concurrent.locks`中的两个重要工具，它们提供了比标准`synchronized`关键字更高级别的锁控制机制。本文将深入探讨这两个类，以及如何通过配置...
第15讲 synchronized和ReentrantLock有什么区别呢？1
08-03
在Java编程中，synchronized和ReentrantLock都是用于实现线程同步的重要工具，它们在并发控制方面扮演着关键角色。然而，两者之间存在一些显著的区别，这些差异体现在功能、灵活性、性能以及使用场景上。 首先，...
简单了解synchronized和lock的区别
08-25
Java中的synchronized和ReentrantLock等独占锁就是悲观锁思想的实现，而java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。 线程阻塞的代价是很高的，因为线程状态的切换...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
ReentrantLock VS ReentrantReadWriteLock
hills的专栏
07-23 374
java并发锁 ReentrantLock ReentrantReadWriteLock
多线程锁ReentrantLock和ReentrantReadWriteLock
zhangbeizhen18的博客
06-11 737
记录：271 场景：多线程并发访问同一个变量、方法、一段代码。对访问的变量、方法、一段代码，在它们的开始位置进行加锁，在它们结束位置进行解锁。并发的多线程，只有获得锁，才能访问。达到效果就是，对于加锁和解锁之间的代码，并发的多线程是串行逐个执行。 多线程锁ReentrantLock和ReentrantReadWriteLock。...
ReentrantLock 和 ReentrantReadWriteLock 详解
GeGe&YoYo的博客
07-29 484
ReentrantLock AQS ReentrantReadWriteLock 详解
ReentrantLock、ReentrantReadWriteLock、StampedLock讲解
Java程序员廖志伟
09-05 243
在多线程编程中，锁是必不可少的，因为许多并发问题都可以通过加锁来解决，例如线程安全的单例实现、线程安全的数据结构实现等等。Java提供了许多类型的锁，本文就来介绍其中三种常见的锁：ReentrantLock、ReentrantReadWriteLock、StampedLock。ReentrantLock是一种可重入锁，提供了公平锁和非公平锁、可中断获取锁和条件变量等特性，使用起来比较灵活，但也比较复杂，需要手动控制加锁和释放锁的过程。
Java多线程之Lock的使用--重入锁(ReentrantLock)、Condition、公平锁和非公平锁、ReentrantReadWriteLock的使用（读写锁）
ChangWen的博客
08-27 2433
一、ReentrantLock的使用　　在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加的灵活。 　　 1、使用ReentrantLock实现同步 　　 既然ReentrantL
Java并发编程：synchronized、Lock、ReentrantLock以及ReadWriteLock的那些事儿
weixin_34061042的博客
01-02 195
前言 多线程开发中，同步控制是必不可少的手段。而同步的实现需要用到锁，Java中提供了两种基本的锁，分别是synchronized 和 Lock。两种锁都非常常用，但也各有利弊，下面开始学习。 synchronized用法 synchronized 是Java的关键字，是应用最为广泛的同步工具之一。当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码，同时，值得...
java多线程ReentrantLock、sync、ReentrantReadWriteLock性能比较
云淡风轻、仅此一抹
06-05 2167
java多线程ReentrantLock、sync、ReentrantReadWriteLock性能比较 源代码下载地址：http://www.zuidaima.com/share/1796775925894144.htm
synchronized、ReentrantLock 、ReentrantReadWriteLock 随记
肆頭的博客
07-24 274
1. synchronized 实际使用的对象内部锁，那什么是对象内部锁？java中每个Object对象都有一个自己的内部锁，而在Object对象里的 wait、notify、notifyall方法都是针对这个对象内部锁的方法。所以有人认为对象内部锁有些违背 oop原则，因为我们看不见，摸不着… 使用在静态方法上时，使用的是这个类的class对象的内部锁 使用在非静态方法上时...
Java多线程13：读写锁和两种同步方式的对比
weixin_30788619的博客
10-05 94
读写锁ReentrantReadWriteLock概述 大型网站中很重要的一块内容就是数据的读写，ReentrantLock虽然具有完全互斥排他的效果（即同一时间只有一个线程正在执行lock后面的任务），但是效率非常低。所以在JDK中提供了一种读写锁ReentrantReadWriteLock，使用它可以加快运行效率。 读写锁表示两个锁，一个是读操作相关的锁，称为共享锁；另一个是写操作相关的锁...
ReentrantLock， ReentrantReadWriteLock
07-27
ReentrantLock和ReentrantReadWriteLock是Java中用于线程同步的锁机制。 ReentrantLock是一个可重入的互斥锁，也就是说同一个线程可以多次获得该锁。它提供了与synchronized关键字类似的功能，但是具有更灵活的控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值