synchronized、Lock和ReadWriteLock快速认识

最新推荐文章于 2022-09-15 18:46:54 发布
最新推荐文章于 2022-09-15 18:46:54 发布
阅读量212 收藏
点赞数
分类专栏： Java 文章标签： 同步 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40734247/article/details/111188081
版权

前言： 这里只是我自己对于synchronized、Lock和ReadWriteLock的一个简单认识，想要学习一样东西，先有一个大概的认识，以后再慢慢深入学习相关的知识。所以，这里就只是一个代码的展示和一些个人的理解。

线程安全和同步

为了提高CPU的利用效率，引入了多线程。但是为了线程的安全问题，又回到了同步（单线程一定是同步的）。

这里使用一个简单的示例代码，来展示synchronized、Lock和ReadWriteLock的作用。首先提供一个简单的模型类：

抽象投票类

说明：一个抽象的模型类，用于投票观察者获取票数。

package learn;

public abstract class Voter {
	public int vote;                        // 票数
	public abstract int getVote();          // 获取票数
	public abstract void setVote(int vote); // 设置票数
}

投票观察者类

说明：投票观察者类，多个线程同时观察同一个投票类，模拟多线程的同时读操作。

package learn;

public class VoteObserver implements Runnable {
	
	private Voter voter;
	
	public VoteObserver(String name, Voter voter) {
		Thread.currentThread().setName(name);
		this.voter = voter;
	}
	
	@Override
	public void run() {
		System.out.println("我是投票观察者：" + Thread.currentThread().getName() + " 现在有多少张票：" + voter.getVote());
	}
	
}

不考虑线程同步的投票类

说明：没有考虑同步措施的投票类，这里我并不会真的使用多线程去修改投票数，我这里是模拟同时去读取票数，所以getVote()方法会有一个耗时操作。

package learn;

public class UnsafeVoter extends Voter {
	
	private int vote;

	@Override
	public int getVote() {
		try {
			Thread.sleep(1000);    // 模拟耗时操作
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return vote;
	}

	@Override
	public void setVote(int vote) {
		this.vote = vote;
	}
}

同步测试类

说明：启动了一个具有十个固定线程的线程池，然后添加任务进行执行，然后对线程任务完成进行计时（这里不考虑主线程的耗时）。

package learn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 同步测试
 * */
public class SyncTest {
	
	public static void main(String[] args) {
		unThreadSafe();
	}
	
	// 非线程安全方式，多个线程并发执行，速度最快，但是有线程安全问题
	static void unThreadSafe() {
		ExecutorService service = Executors.newFixedThreadPool(10);
		Voter voter = new UnsafeVoter();
		voter.setVote(100);
		
		// 计时器
		long start = System.currentTimeMillis();
		
		for (int i = 0; i < 10; i++) {
			service.submit(new VoteObserver("observer_"+i, voter));
		}
		
		service.shutdown();  // 关闭线程池
		
		while (!service.isTerminated()) {}  // 利用CPU空转计时，效率不高，但是简单易用。
		System.out.println("总耗时：" + (System.currentTimeMillis()-start) + " ms");
	}
}

测试结果

说明：由于没有进行同步操作，所以多个线程是并发获取票数的，即几乎是同时完成了任务，总耗时接近1000ms。因此使用多线程以后，多线程的代码变成了并行执行。
在这里插入图片描述

使用synchronized关键字的线程安全投票类

说明：使用synchronized进行同步操作，保证线程安全。上面的操作速度虽然快，但是无法保证线程安全，所以需要使用同步来保证，这里使用Java的synchronized关键字来完成。

package learn;

public class SafeVoterSync extends Voter {

	private int vote;
	
	@Override
	synchronized public int getVote() {
		try {
			Thread.sleep(1000);    // 模拟耗时操作
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return vote;
	}

	@Override
	public void setVote(int vote) {
		this.vote = vote;
	}

}

使用synchronized关键字的测试方法

// 采用synchronized关键字进行同步的线程安全方式，多个线程同步执行，效率非常低下！
static void threadSafeSynchronized() {
	ExecutorService service = Executors.newFixedThreadPool(10);
	Voter voter = new SafeVoterSync();
	voter.setVote(100);
	
	// 计时器
	long start = System.currentTimeMillis();
	
	for (int i = 0; i < 10; i++) {
		service.submit(new VoteObserver("observer_"+i, voter));
	}
	
	service.shutdown();  // 关闭线程池
	
	while (!service.isTerminated()) {}  // 利用CPU空转计时，效率不高，但是简单易用。
	System.out.println("总耗时：" + (System.currentTimeMillis()-start) + " ms");
}

测试结果

说明：实际观察的话，可以发现每条记录是一次间隔接近1000ms的时间打印的，实际总耗时接近10*1000ms，因此同步以后，多线程的代码变成了串行执行。
在这里插入图片描述

使用Lock类的线程安全投票类

package learn;

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

public class SafeVoterLock extends Voter {
	
	private static Lock lock = new ReentrantLock();

	private int vote;
	
	@Override
	public int getVote() {
		lock.lock();
		try {
			Thread.sleep(1000);    // 模拟耗时操作
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
		return vote;
	}

	@Override
	public void setVote(int vote) {
		this.vote = vote;
	}
}

使用Lock类的测试方法

// 采用Lock关键字进行同步的线程安全方式，多个线程同步执行，效率非常低下！
static void threadSafeLock() {
	ExecutorService service = Executors.newFixedThreadPool(10);
	Voter voter = new SafeVoterLock();
	voter.setVote(100);
	
	// 计时器
	long start = System.currentTimeMillis();
	
	for (int i = 0; i < 10; i++) {
		service.submit(new VoteObserver("observer_"+i, voter));
	}
	
	service.shutdown();  // 关闭线程池
	
	while (!service.isTerminated()) {}  // 利用CPU空转计时，效率不高，但是简单易用。
	System.out.println("总耗时：" + (System.currentTimeMillis()-start) + " ms");
}

测试结果

说明：效果和synchronized是差不多的，听说java对synchronized进行了优化，现在性能和Lock也差不多了，但是我对这个的认识还比较浅显。
在这里插入图片描述

使用ReadWriteLock的线程安全投票类

说明：前面我们看到了，我们只是获取投票数这个读取的过程，如果加了多线程同步以后，代码的效率下降的非常严重，这个和日常生活也有点相似，任何事情一旦进入了排队等待，就感觉是一种煎熬——排队买票、排队领书、排队买奶茶等等。
但是，如果不会对状态进行修改，那就没必要进行同步。

package learn;

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

public class SafeVoterRWLock extends Voter {

	/**
	 * 这里可以切换读写锁来测试，只使用读锁，我们就回到了那个并发执行的春天了，
	 * 使用写锁的话就和前面的同步没有区别了。所以，这也引出了它的应用场景，
	 * 即读多于写的场景下，效率很高，最坏情况下，基本同普通的Lock和synchronized一样。
	 * */
	private static ReadWriteLock rwLock = new ReentrantReadWriteLock();
	private static Lock readLock = rwLock.readLock();    // 读锁
	private static Lock writeLock = rwLock.writeLock();  // 写锁 
	
	
	private int vote;
	
	@Override
	public int getVote() {
		readLock.lock();  // 加锁放在try块外部
		try {
			Thread.sleep(1000);    // 模拟耗时操作
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();        // 注意上下两个都要修改为一样的，即加锁必须释放，否则就死锁了！
		}
		return vote;
	}

	@Override
	public void setVote(int vote) {
		this.vote = vote;
	}

}

使用ReadWriteLock的测试方法

// 采用ReadWriteLock关键字进行同步的线程安全方式，多个读线程并发执行，效率非常高！
static void threadSafeRWLock() {
	ExecutorService service = Executors.newFixedThreadPool(10);
	Voter voter = new SafeVoterRWLock();
	voter.setVote(100);
	
	// 计时器
	long start = System.currentTimeMillis();
	
	for (int i = 0; i < 10; i++) {
		service.submit(new VoteObserver("observer_"+i, voter));
	}
	
	service.shutdown();  // 关闭线程池
	
	while (!service.isTerminated()) {}  // 利用CPU空转计时，效率不高，但是简单易用。 注意，不能使用isShutDown方法。
	System.out.println("总耗时：" + (System.currentTimeMillis()-start) + " ms");
}

/**
 * synchronized代码块中的代码才是耗时的，其它代码都是并行执行的！
 * 
 * 读写锁：
 * 读读共享
 * 读写互斥
 * 写读互斥
 * 写写互斥
 * */

测试结果
多个读锁之间是共享的，即会并发执行。但是读锁和写锁、写锁和写锁还是需要互斥进行的，即会串行执行（这里只有读锁的并发执行）。
在这里插入图片描述

说明

这里只是对synchronized、Lock和ReadWirteLock的进行一个使用，先掌握一个简单的用法，可能这里的场景不是很合适。但是，这反正也只是学习的第一步，先慢慢来吧。先写一个例子，记录一下自己学习的过程，多线程确实是一个难点，需要多想、多练、多看。

CrazyDragon_King
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
HIDL学习笔记之HIDL C++（第二天）
青青子衿
11-06 5924
快速消息队列 (FMQ) HIDL 的远程过程调用 (RPC) 基础架构使用 Binder 机制，这意味着调用涉及开销、需要内核操作，并且可以触发调度程序操作。 不过，对于必须在开销较小且无内核参与的进程之间传输数据的情况，则使用快速消息队列 (FMQ) 系统。 FMQ 会创建具有所需属性的消息队列。MQDescriptorSync 或 MQDescriptorUnsync 对象可通过 HIDL ...
JUC学习笔记 -- (9) ReadWriteLock读写锁的使用
YellowStar的博客
10-24 711
  说到Java并发编程，很多开发第一个想到同时也是经常常用的肯定是Synchronized，但是Synchronized存在明显的一个性能问题就是读与读之间互斥，简言之就是，我们编程想要实现的最好效果是，可以做到读和读互不影响，读和写互斥，写和写互斥，提高读写的效率，这就要用到本章的重点ReadWriteLock读写锁。 之前文章已经介绍了Lock的一种实现ReentrantLock的使用，其...
synchronized 读写同步
weixin_30265171的博客
12-08 296
synchronized 读写同步这是一道面试题，很多人也遇到了。要求：1.读-读 不用线程同步。2.读-写 要求线程同步，写的时候不能读。3.写-写同步。写的时候不能写。java lock读写锁是好的处理方案。这里不说了。但人家问的是synchronized 读写同步。假设两个方法，write() ,read(); read()之间不需要同步，正常的就行。 read()与wr...
读写锁 ReadWriteLock和Synchronized的比较
geniusLesserPanda的博客
08-18 335
排他锁： 同一时刻只允许一个线程访问 读写锁： 同一时刻允许多个读线程同时访问，但是写线程访问的时候，所有的读、写都被会被阻塞，适用于读多写少的场景。 ReadWriteLock接口和读写锁ReentrantReadWriteLock 读写锁的实现 public class RwLockImpl implements GoodsService{ private Goods g...
快速消息队列 (FMQ)
探索未知，成就非凡
02-25 9112
HIDL 的远程过程调用 (RPC) 基础架构使用 Binder 机制，这意味着调用涉及开销、需要内核操作，并且可以触发调度程序操作。不过，对于必须在开销较小且无内核参与的进程之间传输数据的情况，则使用快速消息队列 (FMQ) 系统。FMQ 会创建具有所需属性的消息队列。MQDescriptorSync 或 MQDescriptorUnsync 对象可通过 HIDL RPC 调用发送，并可供接收进程用于访问消息队列。
Lock、synchronized和ReadWriteLock的区别和联系以及Condition
allen的博客
11-18 6244
在java多线程编程中，可能我们经常会遇到线程同步的问题，可以使用synchronized或者Lock去控制同步锁，他们都能实现线程的同步，下面来分析下这两种方式的区别：1.synchronized可以锁住一个方法或者一段代码块，伪代码如下：//锁住方法 public synchronized void test(){ doSomething... } //锁住代码块 public sync
并发编程中Lock, synchronized和 ReadWriteLock的异同、重入锁 和不可重入锁的区别
weixin_39684625的博客
01-24 803
最近在做MVCC的project，其中使用到了ReadWriteLock锁机制，特此写篇博客来记录一下 一、synchronized 它可以锁住一个方法或者一段代码块，伪代码如下： //锁住方法 public synchronized void test(){ doSomething... } //锁住代码块 public synchronized void test(){
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
Java编程synchronized与lock的区别【推荐】
08-29
synchronized 和 Lock 是 Java 编程中两种常用的同步机制，用于实现线程安全的访问。两者都可以实现同步访问，但是它们有着不同的设计理念和使用场景。 synchronized 的缺陷 synchronized 是 Java 语言内置的...
关于synchronized、Lock的深入理解
12-21
1. **使用方式**：`synchronized`是隐式同步，无需手动释放，而`Lock`是显式同步，需手动调用`lock()`和`unlock()`。 2. **控制能力**：`Lock`提供了更多控制选项，如可中断、可选择公平性、锁分离等。 3. **异常...
Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁
09-03
然而，与内置锁不同的是，使用ReentrantLock需要显式调用`lock()`和`unlock()`方法来获取和释放锁，这增加了更多的控制和高级功能。 ReentrantLock实现了Lock接口，提供了以下几个关键方法： 1. `lock()`: 阻塞直到...
Java多线程基础——Lock类
08-31
与`synchronized`不同，Lock需要显式地获取和释放锁。在使用Lock时，程序员必须确保正确地调用`lock()`和`unlock()`方法，否则可能会导致死锁或线程不安全的情况。 2. **Lock类其他功能**： - **可重入性**：`...
快速消息队列
xixinliyan的专栏
12-05 1498
转载：https://source.android.com/devices/architecture/hidl/fmq?hl=zh-cn HIDL 的远程过程调用 (RPC) 基础架构使用 Binder 机制，这意味着调用涉及开销、需要内核操作，并且可以触发调度程序操作。不过，对于必须在开销较小且无内核参与的进程之间传输数据的情况，则使用快速消息队列 (FMQ) 系统。 FMQ 会创建
Java中的锁 synchronized、Lock、ReentrantLock、ReadWriteLock 和可重入锁、可中断锁、公平锁、读写锁
zehuawong的博客
10-12 1614
参考 https://www.cnblogs.com/dolphin0520/p/3923167.html 在上一篇文章中我们讲到了如何使用关键字synchronized来实现同步访问。本文我们继续来探讨这个问题，从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。 也许有朋友会问，既然都可以通过synchronized来...
比较ReentrantReadWriteLock和synchronized
小白杨
05-13 848
synchronized我们都不陌生，我们使用他可以让我们的代码变的线程安全；而ReentrantReadWriteLock也可以达到相同的效果，但是ReentrantReadWriteLock相比synchronized有一些不同，synchronized同时只能有一个线程得到相同对象的锁，我得到了其他任何人都不能得到。而ReentrantReadWriteLock中有读锁和写锁，读读不互斥，R
Java多线程：synchronized | Volatile 和Lock和ReadWriteLock多方位剖析（一）
血煞长虹 的专栏
02-19 1222
本文较为系统，全面的介绍了在多线程中，synchronized理论和用法 | Lock和ReentrantLock Volatile 区别和联系，主要涉及常区分不清的理论，不涉及过深的源码剖析，是多线程爱好者不可多得的好文，点击进入一饱眼福吧！............
两种线程锁java_java中三种线程锁：Lock、synchronized和ReadWriteLock
weixin_31263231的博客
02-27 133
在java多线程编程中，可能我们经常会遇到线程同步的问题，可以使用synchronized或者Lock和ReadWriteLock去控制同步锁，他们都能实现线程的同步，下面来分析下这几种方式的区别：1.synchronized它可以锁住一个方法或者一段代码块，伪代码如下：//锁住方法public synchronized void test(){doSomething...}//锁住代码块publ...
java并发编程系列之ReadWriteLock读写锁的使用
热门推荐
牛奋lch
12-09 1万+
前面我们讲解了Lock的使用，下面我们来讲解一下ReadWriteLock锁的使用，顾明思义，读写锁在读的时候，上读锁，在写的时候，上写锁，这样就很巧妙的解决synchronized的一个性能问题：读与读之间互斥。 ReadWriteLock也是一个接口，原型如下： public interface ReadWriteLock { Lock readLock(); Lock w
Java中的锁（synchronized、Lock、ReadWriteLock）及常用线程安全类原理（CopyOnWriteArrayList、ConcurrentHashMap）
cyc头发还挺多的博客
09-15 566
Synchronized本身已经做了优化，不再是始终是重量级锁，Synchronized是加在table中链表（红黑树）的单个结点上的，细粒度比Segment更细，冲突概率很小，Synchronized相比ReentrantLock，在使用偏向锁时甚至都不需要自旋。自旋锁：一直占用着CPU，在未获得锁的情况下，一直运行（自旋），性能高，但是废资源，适合等待时间短，并发量不高的情况；线程通过CAS获取并设置同步器状态，如果获取失败，会被丢进队列，在队列中自旋获取，直到获取到同步器状态后，退出队列。
ReentrantLock ReadWriteLock 和 synchronized 区别
最新发布
03-29
ReentrantLock、ReadWriteLock和synchronized都是Java中用于实现线程同步的机制，它们之间有以下区别： 1. ReentrantLock是一个可重入锁，它允许同一个线程多次获取锁。而synchronized是隐式锁，同一个线程在获取锁...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值