理解 JVM：Java 内存模型（三）—— 锁

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量102 收藏
点赞数
文章标签： java 运维
原文链接：https://my.oschina.net/u/588116/blog/1572527
版权

什么是线程安全？

线程安全是指当一个对象被多个线程访问操作时，最终都能得到正确的结果，那这个对象是线程安全的。Java 中可以通过同步块和加锁保障线程安全。

锁

锁是 Java 并发编程中最重要的同步机制，它可以让等待在临界区的线程互斥执行。

关键字 synchronized

synchronized 也是一种锁，它通过字节码指令 monitorenter 和 monitorexist 隐式的来使用 lock 和 unlock 操作。synchronized 具有原子性和可见性。

synchronized 示例：

/**
 * @Project Name:test
 * @File Name:SynchronizedTest.java
 * @Package Name:com.pdh
 * @Date:2017年2月12日下午5:36:46
 */

package com.pdh.test.thread;

/**
 * synchronized 具有原子性和可见性
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class SynchronizedDemo {

	private int safeNum = 0;
	private int unsafeNum = 0;

	/**
	 * 使用 synchronized 同步实现复合运算,线程安全的
	 */
	private synchronized void safeIncrease() {
		safeNum++;
	}

	/**
	 * 普通复合运算，线程不安全的
	 */
	private void unsafeIncrease() {
		unsafeNum++;
	}

	public static void main(String[] args) {
		SynchronizedDemo demo = new SynchronizedDemo();
		for (int i = 0; i < 20000; i++) {
			new Thread(() -> {
				demo.unsafeIncrease();
				demo.safeIncrease();
			}).start();
		}

		while (Thread.activeCount() > 2) {
			Thread.yield();
		}

		System.out.println("unsafeNum: " + demo.unsafeNum);
		System.out.println("safeNum: " + demo.safeNum);
	}
}

在示例中，申明了两个方法，一个是使用了 synchronized 修饰的同步块方法 safeIncrease() 对共享变量 safeNum 的自增操作，由于该方法使用了 synchronized 同步块实现了线程对变量 safeNum 的互斥操作，是线程安全的，所以最终获取到了正确的结果 20000；而另一个方法 unsafeIncrease() 为使用任何手段保护 全局变量 unsafeNum，是线程不安全的，所以最终获取到的结果大多数情况下是小于 20000 的。

重入锁（ReentrantLock）

从 JDK 5.0 开始，Java 并发包实现了高性能的支持重入的锁 ReentrantLock，属于一种排它锁。重入锁通过显示的请求获取和释放锁，为了避免获得锁后，没有释放锁，而造成其它线程无法获得锁而造成死锁，一般建议将释放锁操作放在finally块里。

重入锁示例：

package com.pdh.test.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * ReentrantLock 实现线程同步
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class ReentrantLockDemo implements Runnable {
	private int num = 0;
	private Lock lock = new ReentrantLock();

	/**
	 * 利用重入锁实现变量累加操作
	 */
	private void increase() {
		lock.lock();
		try {
			num++;
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}

	public static void main(String[] args) {
		ReentrantLockDemo demo = new ReentrantLockDemo();
		for (int i = 0; i < 2000; i++) {
			new Thread(() -> {
				demo.increase();
			}).start();
		}
		// 等待所有线程全部执行完
		while (Thread.activeCount() > 2) {
			Thread.yield();
		}
		System.out.println(demo.num);
	}
}

重入锁提供以下几个主要方法

  • lock()：获得锁，如果锁已经被占用，则等待；
  • lockInterruptibly()：获取锁，若获取成功立即返回；若获取不成功则阻塞等待。与lock方法不同的是，在阻塞期间，如果当前线程被打断（interrupt）则该方法抛出InterruptedException。该方法可以有效避免死锁题。
  • tryLock()：该方法尝试获取锁，如果成功，返回 true ，若失败返回 false。该方法不等待，立即返回。
  • tryLock(long time, TimeUnit unit)：该方法尝试获取锁，若成功，则返回 true，若失败，则等待相应的时间，如果该时间内能获得锁，则返回 true，如果相应的时间内仍未获取到锁则返回 false，如果在等待期间当前线程被中断则抛出 InterruptedException；
  • unlock()：释放锁；
synchronized 与 ReentrantLock 的区别
  1. 所有使用 synchronized 的地方都可以使用 ReentrantLock ；
  2. synchronized 是通过字节码指令 monitorenter 和 monitorexist 实现隐式加锁和解锁，而 ReentrantLock 是通过 lock 和 unlock 操作实现显示加锁和解锁；
  3. ReentrantLock 可以实现公平和非公平两种锁，而 synchronized 只能实现非公平锁；
  4. ReentrantLock 可以中断对锁的等待来避免 synchronized 可能带来的死锁问题；
Condition 条件锁

Condition 的用法与 wait() 和 notify() 作用类似，wait() 和 notify() 是和 synchronized 关键字搭配使用，而 Condition 是与重入锁搭配使用。利用 Condition 对象，就可以让线程在合适的时间等待，或者在某个特定的时刻得到通知，继续执行。

Condition 提供以下几个方法

  • await()：该方法会使当前线程等待，同时释放当前锁，当其它线程中使用 signal() 或者 singnalAll() 方法时，线程会重新获得锁并继续执行。或者当前线程被中断时，也能跳出等待。
  • awaitUninterruotibly()：该方法使用和 await() 基本相同，但是它不会再等待的过程中响应中断。
  • singal()：该方法用于唤醒一个在等待中的线程，而 singalAll() 方法会唤醒所有在等待的方法。

Condition 示例：

package com.pdh.test.thread;

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

/**
 * Condition 示例
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class ConditionDemo {

	public static void main(String[] args) {
		Lock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		new Thread(() -> {
			lock.lock();
			System.out.println("thread 1 is waiting");
			try {
				condition.await();
				System.out.println("thread 1 is wake up");
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
			}
		}).start();

		new Thread(() -> {
			lock.lock();
			try {
				System.out.println("thread 2 is running");
				Thread.sleep(3000);
				condition.signal();
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				lock.unlock();
			}
		}).start();
	}
}
信号量（Semaphore）

信号量为多线程协作提供了更为强大的控制方法，广义上说，信号量是对锁的扩展。无论是内部锁 synchronized 还是重入锁 ReentrantLock，一次都只允许一个线程访问一个资源，而信号量却可以指定多个线程，同时访问某一个资源。

信号量提供了以下方法

  • acquire()：该方法尝试获得一个许可。若无法获得，则线程会等待，直到有线程释放一个许可或者当前线程被中断。
  • acquire(int permits)： 申请 permits（必须为非负数）个许可，若获取成功，则该方法返回并且当前可用许可数减permits；若当前可用许可数少于 permits 指定的个数，则继续等待可用许可数大于等于 permits；若等待过程中当前线程被中断，则抛出 InterruptedException。
  • acquireUninterruptibly() ：该方法和 acquire() 类似，但不响应中断。
  • tryAcquire()：尝试获得一个许可 ，如果成功则返回 true，如果失败则返回 false，它不会进行等待，立即返回。
  • release()：用于在线程访问资源结束后，释放一个许可，以使其它等待许可的线程可以进行资源访问。

Semaphore 示例：

package com.pdh.test.thread;

import java.util.concurrent.Semaphore;

/**
 * 信号量示例
 *
 * @author pengdh
 * @date 2017/11/12
 */
public class SemaphoreDemo {
	private static final Semaphore semaphoreToken = new Semaphore(5);

	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			new Thread(() -> {
				// 获取令牌
				try {
					semaphoreToken.acquire();
					Thread.sleep(2000);
					System.out.println(Thread.currentThread().getId() + " finished");
					// 归还令牌
					semaphoreToken.release();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}).start();
		}
	}
}
读写锁（ReadWriteLock）

读写锁适用于多线程编程中读多写少的场景中，对于原子性而言，更多是关注写操作，读和读操作之间并不需要互斥操作，只需要保证读和写或者写和写之间是互斥操作即可。所以如果在某个场景下读操作次数远远大于写操作次数，则可以使用读写锁来提高效率。

读写锁示例

package com.pdh.test.thread;

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

/**
 * 读写锁示例
 *
 * @author pengdh
 * @date 2017/11/13
 */
public class ReadWriteLockDemo {

	public static void main(String[] args) {
		ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
		new Thread(() -> {
			readWriteLock.readLock().lock();
			try {
				System.out.println("the first read lock begin");
				Thread.sleep(1000);
				System.out.println("the first read lock end");
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				readWriteLock.readLock().unlock();
			}
		}).start();

		new Thread(() -> {
			readWriteLock.readLock().lock();
			try {
				System.out.println("the second read lock begin");
				Thread.sleep(1000);
				System.out.println("the second read lock end");
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				readWriteLock.readLock().unlock();
			}
		}).start();

		new Thread(() -> {
			readWriteLock.writeLock().lock();
			try {
				System.out.println("the write lock begin");
				Thread.sleep(1000);
				System.out.println("the write read lock end");
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				readWriteLock.writeLock().unlock();
			}
		}).start();
	}
}

参考文献

  • <span style="color:red;font-size:14px;font-family:Microsoft YaHei;">深入理解 Java 虚拟机</span>

欢迎扫一扫关注 程序猿pdh 公众号！

欢迎关注公众号 程序猿pdh

转载于:https://my.oschina.net/u/588116/blog/1572527

chidutou4505
关注
详解synchronized关键字（无锁、偏向锁、轻量级锁（自旋锁）、重量级锁四种锁状态）-多线程与高并发
phs999的博客
09-26 1594
介绍CAS（compare and swap）、对象内存分布、markword、synchronized中锁的状态（无锁、偏向锁、轻量级锁、重量级锁）研究、Java Object Layout
Java 内存模型（三）—— 锁
alexpdh的博客
11-13 327
什么是线程安全？线程安全是指当一个对象被多个线程访问操作时，最终都能得到正确的结果，那这个对象是线程安全的。Java 中可以通过同步块和加锁保障线程安全。
java中的锁
oyc的博客
02-20 1756
一、jmm 内存模型 volitale 二、java中的锁 在 JDK 1.5 之前共享对象的协调机制只有 synchronized 和 volatile，在 JDK 1.5 中增加了新的机制 ReentrantLock，该机制的诞生并不是为了替代 synchronized，而是在 synchronized 不适用的情况下，提供一种可以选择的高级功能。 2.1 synchronized vs ReentrantLock synchronized 属于独占式悲观锁，是通过 JVM 隐式实现的，synchron
java 内存模型 锁的理解
老根儿的博客
06-05 372
java 内存模型 锁的理解 Java SE 1.6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”。 个人对锁的理解： 偏向锁 引入目的是消除在无竞争情况下的同步原语，进一步提高程序的运行性能。 在没有线程竞争同步代码块的时候，会在对象头和栈帧中的锁记录里存储偏向锁的线程ID，以后该线程在进入和退出同步块的时候不需要进行CAS操作来加锁解锁，只需简单地测试一下对象头...
java之两种并发模型 以及 锁
平安使者
06-23 309
java之两种并发模型 在我们的并发介绍中，我们看到了两种并发编程模型：共享内存和消息传递。 • 在共享内存模型中 ：并发模块通过在内存中读取和写入共享可变对象来进行交互。在单个Java进程中创建多个线程是我们共享内存并发的主要示例。 • 在消息传递模型中：并发模块通过通信通道相互发送不可变消息进行交互。该通信通道可以通过网络连接不同的计算机，如我们的一些初始示例：Web浏览，即时消息等。 ...
彻底理解Java并发：Java内存模型
栗筝i的博客
10-27 5767
本篇内容包括：进程与线程&并行与并发的基本概念，Java内存模型中的内存划分、内存交互、内存交互，以及JMM的相关概念，包括了 CPU 和缓存一致性、重排序、处理器重排序与内存屏障指令、JMM 的重排序屏障、数据依赖性、as-if-serial 语句、happens-before 规则，还有JMM三大特征（原子性、可见性、有序性）。
JVM——Java内存模型 （JDK1.8）
小马不奔腾的博客
02-21 2129
一. 程序计数器 1.什么是程序计数器 ​ 程序计数器（Program Counter Register）是一块较小的内存空间,它可以看作是当前线程所执行的字节码行号 的指示器。 2.程序计数器的作用 字节码解释器工作通过改变程序计数器的值来选取下一条需要执行的字节码指令。如：分支、循环、跳转、异常处理、线程恢复等基础功能。 多线程情况下，程序计数器表示当前线程执行的位置，从而...
JVM——一文搞懂JMM（Java内存模型）
xdx_dili的博客
10-08 808
JVM——一文搞懂JMM（Java虚拟机）
深入理解java虚拟机(一)JVM内存模型
热门推荐
少说，多做
08-10 1万+
文章目录前言一、JVM内存模型1.程序计数器2.Java虚拟机栈3.本地方法栈4.Java堆5.方法区6.运行时常量池7.直接内存二、HotSpot虚拟机对象探秘1.对象的创建2.对象的内存布局3.对象的访问定位结尾 前言 对于从事C、 C++程序开发的开发人员来说，在内存管理领域，他们既是拥有最高权力的“皇帝”，又是从事最基础工作的劳动人民——既拥有每一个对象的“所有权”，又担负着每一个对象生命从开始到终结的维护责任。 对于Java程序员来说，在虚拟机自动内存管理机制的帮助下，不再需要为每一个new操作
深入理解JVM—JVM内存模型
01-27
理解JVM内存模型对于开发者来说非常重要，因为它可以帮助我们理解内存分配、垃圾收集的工作原理，以及如何有效地管理内存，从而编写出更高效、更稳定的Java应用程序。在多线程环境下，还需要注意线程安全问题，确保...
30+个视频+深入理解Java虚拟机（jvm优化+内存模型+虚拟机原理）
02-25
JVM提供了一套自动内存管理系统——垃圾回收器(Garbage Collector)，用于跟踪不再使用的对象并释放其占用的内存空间。常见的垃圾回收算法包括标记-清除算法、复制算法、标记-整理算法等。不同版本的JVM可能会采用...
jdk1.8的jvm内存模型——实习生必须了解的
12-21
JVM（Java Virtual Machine）内存模型是Java程序运行的基础，对于实习生来说，理解JVM的工作原理是面试中的常见考点。JDK 1.8的内存模型主要由以下几个部分组成： 1. **程序计数器**： - 程序计数器是线程私有的，...
JAVA内存模型——同步操作规则1
08-08
Java内存模型（JVM Memory Model，简称JMM）是Java平台中用于定义程序中各个变量（包括实例字段、静态字段和局部变量）的可见性和有序性的一种抽象概念。它为多线程环境下如何保证数据一致性提供了理论基础。下面将...
【JVM】JVM08(java内存模型解析[JMM])_java 8 jvm内存模式
2301_82241775的博客
04-20 1083
在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 708
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 665
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 478
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 761
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 310
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
深入理解Java内存模型：缓存一致性与乱序执行
"Java内存模型原理，你真的理解吗？" 在深入探讨Java内存模型之前，我们首先要了解物理计算机在处理并发问题时所面临的挑战，这些挑战为理解内存模型的出现提供了上下文。物理计算机在执行任务时，处理器通常需要与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值