java多线程与并发原理学习笔记（三）——volatile与JUC之AQS原理

已于 2024-04-10 10:04:42 修改
阅读量457 收藏
点赞数 1
分类专栏： java分布式与高并发 文章标签： java 学习 开发语言
于 2022-02-18 15:19:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34609889/article/details/123000476
版权

一、volatile关键字

运行下面的代码，观察加了volatile和没加的区别。可以发现没加volatile，程序不会正常停止，而加了volatile程序会正常停止。这就说明thread线程没有读取到flag修改后的值，跨线程之间共享数据不可见。使用volatile关键字保证了跨线程之间数据的可见性。这是因为为了提高程序的执行性能，编译器和处理都会对指令做重排序，而加了volatile的变量会被禁止重排序。

public class VolatileDemo {
     public volatile static boolean flag=false; //观察加了volatile和没加的区别
     public static void main(String[] args) throws InterruptedException {
         Thread thread=new Thread(()->{
             int i=0;
             while(!flag){
                 i++; }
             System.out.println("i="+i);
             System.out.println("Thread end");
         });
         thread.start();
         System.out.println("Thread start");
         Thread.sleep(1000);
         flag=true;
     }
}

说明：要注意volatile和synchronized的区别。volatile只能保证变量修改订的可见性，不能保证原子性。而synchronized则可以保证变量的修改可见性和原子性。例如多个线程执行count++操作。因为count++实际上执行了三个操作：1.读取变量count的值 2.count的值+1 3.将值赋予变量count。这三个操作过程中，count的值被篡改，都不会出现预期的效果，所以必须要保证这三个操作的原子性，也就是要必须连续完成。而volatile只能保证多个线程都在主内存中操作count，而不能保证原子性。

二、AQS原理及Lock锁

java.util.concurrent是在并发编程中比较常用的工具类，里面包含很多用来在并发场景中使用的组件。比如线程池、阻塞队列、计时器、同步器并发集合等等。简称JUC。Lock是JUC中最核心的组件，本质上是一个接口，定义了锁的获得和释放的抽象方法。实现Lock接口的类有很多常用的有：

  1. ReentrantLock。表示重入锁，是唯一一个直接实现Lock接口的类。重入锁指的是线程获得锁之后，再次获得该锁不需要再阻塞，而是直接关联计数器增加一次重入次数即可。
  2. ReentrantReadWriteLock。表示重入读写锁。实现了ReadWriteLock接口。这个类中维护了两个锁，一个ReadLock，一个WriteLock，分别都实现了Lock接口。适合读多写少的的场景下解决线程安全问题。基本原则就是读读不互斥，读写互斥，写写互斥。
  3. StampedLock。可以认为是读写锁的改进版本。读写锁的读和写是互斥的，如果存在大量读线程，可能会引起写线程的饥饿，StampedLock是一种乐观读策略，使得乐观锁不会阻塞写线程。

ReentrantLock重入锁

重入锁实例：

public class ReentrantLockDemo { 
	private static int count=0; 
	static Lock lock=new ReentrantLock(); 
	public static void inc(){ 
		lock.lock(); 
		try { 
			Thread.sleep(1);
		} catch (InterruptedException e) { 
			e.printStackTrace();
		} 
		count++; 
		lock.unlock(); 
	} 
	public static void main(String[] args) throws InterruptedException { 
		for(int i=0;i<1000;i++){ 
			new Thread(()->{ReentrantLockDemo.inc();}).start();; 
		} 
		Thread.sleep(3000);
		System.out.println("result:"+count); 
	}
}

ReentrantReadWriteLock锁

ReentrantReadWriteLock锁是读写锁，维护了两个锁，一个ReadLock，一个WriteLock。允许多个线程在同一时刻访问，基本原则就是读读不互斥，读写互斥，写写互斥。

public class ReentrantReadWriteLockDemo{ 
	public static Map<String,Object> map=new HashMap<>(); 
	public static ReentrantReadWriteLock rwl=new ReentrantReadWriteLock(); 
	public static Lock readLock=rwl.readLock(); 
	public static Lock writeLock=rwl.writeLock();
	public static final Object get(String key) { 
		System.out.println("读数据"); 
		readLock.lock(); //读锁 
		try { 
			return map.get(key);
	    }finally { 
			readLock.unlock(); 
		} 
	} 
	public static final Object put(String key,Object value){ 
		writeLock.lock(); 
		System.out.println("写数据"); 
		try{ 
			return map.put(key,value); 
		}finally { 
			writeLock.unlock(); 
		} 
	}
}

AQS原理

在Lock中，用到了一个同步队列AQS，全称AbstractQueuedSynchronizer。是Lock用来实现线程同步的核心组件。AQS功能分为两种，独占锁和共享锁。

独占锁：每次只能有一个线程获得锁。如 ReentrantLock。
共享锁：允许多个线程同时获取锁，如ReentrantReadWriteLock

AQS内部实际上是维护一个FIFO双向链表。这种结构的特点是每个数据结构都有两个指针，分别指向直接的后继节点和直接前驱节点。所以双向链表可以从任意一个节点开始很方便的访问前驱和后继。每个 Node 其实是由线程封装，当线程争抢锁失败后会封装成 Node 加入到 ASQ 队列中去；当获取锁的线程释放锁以后，会从队列中唤醒一个阻塞的节点(线程)。
在这里插入图片描述

当出现锁竞争时：

  1. 新的线程将自己封装成新的Node节点，设置 prev 节点以及修改当前节点的前置节点的 next 节点指向自己
  2. 通过CAS操作将tail 重新指向新的尾部节点

在这里插入图片描述
释放锁时：
head节点表示获取锁成功的节点，当头节点释放锁后，会唤醒后续节点，如果后续节点获得锁成功，会把自己设置为头节点。

  1. 修改 head 节点指向下一个获得锁的节点，删除释放锁的节点
  2. 新获得锁的节点，将 prev 的指针指向 null
    在这里插入图片描述
    AQS的原理基本就是这样，当然，程序中更复杂。还要考虑公平锁和非公平锁。
    非公平锁：非公平锁在获取锁的时候，各个节点会先通过 CAS 进行抢占，谁抢到就是谁的。
    公平锁：锁的获取顺序就应该符合请求的绝对时间顺序。

其他并发工具

Condition

Condition的用法和wait/notify方法类似。都是用来进行线程间的通信。代码示例：

import java.lang.management.ThreadMXBean;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionDemo {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        Thread threadA = new Thread(()->{
            System.out.println("begin condition await");

            try {
                lock.lock();
                condition.await();  //相当于wait
                System.out.println("end condition await");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        Thread threadB = new Thread(()->{
            System.out.println("begin condition signal");
            try {
                lock.lock();
                condition.signal();  //相当于notify，signalAll相当于notifyAll
                System.out.println("end condition signal");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        threadA.start();
        threadB.start();
    }
}

结果是
begin condition await
begin condition signal
end condition signal
end condition await

Condition的原理

condition的await/signal方法的用法和wait/notify类似。原理也类似。执行await时会将当前线程加入到一个等待队列中，随即释放锁，然后挂起，等待同一个condition对象执行signal方法唤醒。执行signal方法时，会将当前线程加入到同步队列中（即上文提到的AQS队列），然后去争抢锁。

在这里插入图片描述

CountDownLatch

Countdownlatch 是一个同步工具类。它允许一个或多个线程一直等待，直到其他线程的操作执行完毕再执行。Countdownlatch提供了两个方法。await()和countDown()。Countdownlatch初始化时需要传一个整数参数，这个参数相当于一个倒计时，countDown()每次被调用，都会减一，直到这个数变为0。这时，所有因为执行了Countdownlatch的await()方法被阻塞的线程都会被唤醒，继续执行。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(1);

        System.out.println("begin create Thread");
        for(int i=0;i<10;i++){
            new Thread(()->{
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ThreadName:"+Thread.currentThread().getName());
            }).start();
        }

        System.out.println("end create Thread");
        System.out.println("begin run Thread");
        countDownLatch.countDown();

    }
}

Semaphore

Semaphore用来控制同时访问的线程个数。创建实例时需要一个permits参数，代码许可数，提供了acquire和release方法。acquire方法获取一个许可，当达到许可的最大值时，阻塞当前线程。release方法释放一个许可，并唤醒被acquire方法阻塞的线程。

import java.util.concurrent.Semaphore;

public class SemaphoreDemo {


    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i=0;i<5;i++){
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println("ThreadName:"+Thread.currentThread().getName()+"获取一个许可");
                    Thread.currentThread().sleep(2000);
                    System.out.println("ThreadName:"+Thread.currentThread().getName()+"释放一个许可");
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

CyclicBarrier

CyclicBarrier表示循环屏障。功能是设置一个屏障，也叫同步点，让一组线程到达这个屏障处时阻塞，直到最后一个线程到达后，屏障才会打开，所有被拦截的线程才会继续工作。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;


public class CyclicBarrierDemo {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier =new CyclicBarrier(3,
                new Thread(()->{
                    System.out.println("所有线程都已到达屏障，继续执行！");
                })
        );

        for (int i=0;i<3;i++){
            new Thread(()->{
                System.out.println("ThreadName:"+Thread.currentThread().getName()+"到达屏障");
                try {
                    cyclicBarrier.await();
                    System.out.println("ThreadName:"+Thread.currentThread().getName()+"继续执行!");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }
}

注意事项：

  1. 由于指定了计数值，若没有足够的线程执行CyclicBarrier的awai方法。那所有调用CyclicBarrier的await方法的线程都将被阻塞。可以给await设置超时时间await(long timeout, TimeUnit unit)。在设定时间内，如果没有足够线程到达，则解除阻塞状态，继续执行。
  2. 通过 reset 重置计数，会使得进入 await 的线程出现BrokenBarrierException
  3. 如果采用是 CyclicBarrier(int parties, Runnable barrierAction) 构造方法，执行 barrierAction 操作的是最后一个到达的线程。
飞!!!!
关注
专栏目录
AQS底层原理、运用和volatile详解
暮暮频顾惜的博客
02-20 586
AbstractQueuedSynchronizer 什么叫做AQS？从名字可以看出，AQS就是抽象队列同步器，是用来构建锁或者其他同步组件的基础框架。它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。并发包的大师（Doug Lea）期望它能够成为实现大部分同步需求的基础。 AQS使用方式和其中的设计模式 AQS的主要使用方式是继承，子类通过继承AQS并实现它的抽象方法来管理同步状态，在AQS里由一个int型的state来代表这个状态，在抽象方法的实现过程中免不
关于volatile，CAS，AQS，锁
m0_37822939的博客
04-22 3618
关键字volatile1.volatile保证可见性。保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。2.volatile不能确保原子性。以变量inc自增为例，初始化值为10：线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量...
JUC —— Volatile
weixin_46540606的博客
02-09 1018
Volatile Volatile是java虚拟机提供的轻量级的同步机制 保证可见性 不保证原子性 禁止指令重排序 什么是JMM JMM：java内存模型，不存在的东西，是一个概念、一个约定 关于JMM的一些同步的约定： 线程解锁前，必须把共享变量立刻刷会主存 线程加锁前，必须读取主存中的最新值到工作内存中 加锁和解锁是同一把锁 线程 工作内存 主内存 JMM八种操作 关于主内存与工作内存之间的交互协议，即一个变量如何从主内存拷贝到工作内存。如何从工作内存同步到主内存中的实现细节。java内存模型
【Java 并发】 之 AQS 详解 & volatile关键字
AI天才研究院
05-04 8884
Java并发之AQS详解 谈到并发，不得不谈ReentrantLock；而谈到ReentrantLock，不得不谈AbstractQueuedSynchronizer（AQS）！ 类如其名，抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDow...
volatile原理 + volatile在AQS框架中的应用
xxx
05-23 346
volatile的作用 1 保证变量的可见性：1 当前线程变量改变后，强制刷新主内存(堆内存)变量 2 所有线程每次在使用变量时都从主内存中获取 2 禁止指令重排：禁止操作系统对指令的优化重排序 volatile使用实例:ReentrantLock非公平锁的state值(继承AQS)就是用volatile修饰的 为啥AQS的state变量用volatile？普通变量不行吗？ volatile + CAS实现非阻塞式线程同步：通过Syncronized的方式当然可以实现线程同步，但是消.
JUC源码学习笔记1——AQS和ReentrantLock
xuhss_com的博客
07-11 232
一丶Lock 锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁可以防止多个线程同时访问共享资源（这种锁称为独占锁，排他锁）但是有些锁可以允许多个线程并发访问共享资源，比如读写锁 3.使用Lock的经典范式 获取锁的过程不要写在try中，避免获取锁失败最后finally释放其他线程持有的锁使用一个int成员变量state表示同步状态，内置的FIFO队列来完成资源的获取和线程的排队工作，支持独占也支持共享的获取同步状态。三个变量被volatile修饰，保证其线程可见性等待状态是一个枚举，具备下列可选的值
笔记整理-多线程与高并发
qq_42114504的博客
03-13 451
多线程与高并发 目录 多线程与高并发 https://www.cnblogs.com/Zs-book1/p/14318992.html?share_token=641d3935-0525-44d5-a772-9764bf2fad2a 一、了解多线程 什么是进程？ 什么是线程? 并发与并行的区别 临界区 学习线程必须知道的概念： 二、 线程的使用 三种方式的区别 线程的方法 线程的状态三、Synchronized JMM模型 volatile synchronized syn
JUC并发编程(12.Java线程-原理之 volatile）
weixin_45428910的博客
02-23 88
JUC并发编程(12.Java线程-原理之 volatile）
Java深入学习并发原理总结
u012497653的博客
11-26 503
Java 并发多线程基础总结 线程池 线程池的简介 线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。 为什么要使用线程池 如果不使用线程池，每一个任务都会新开一个线程处理。 为了减少创建和销毁线程的次数，让每个线程可以多次使用，可根据系统情况调整执行的线程数量，防止消耗过多内存，所以我们可
volatile原理解析——JUC多线程与高并发系列笔记
Vincent_xy的博客
12-25 295
1、volatile特性 保证可见性 禁止指令重排序【与sychronized的重要区别】 不保证原子性【与sychronized的重要区别】 2、什么是主内存与工作内存 每个线程私有自己的工作内存，线程间的交互通过主内存实现 主内存是共享内存 当A线程修改了成员变量的值，并刷新到主内存中，如果变量是不可见的。不管是主线程还是其他线程都不会重新到主内存中拿到A线程修改后的值，只有当变量被vol...
Java volatile的内存语义与AQS锁内存可见性
勿忘初心
05-23 3454
提到volatile首先想到就是： 保证此变量对所有线程的可见性，这里的 “可见性” 是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。 禁止指令重排序优化。 &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;
Java高并发之volatitle、synchronized、Lock接口、AQS（三种核心方法、重写方法、模板方法）
lucyLee的博客
10-06 908
1. volatitle和synchronized关键字 ① volatitle关键字 对共享变量进行准确和一致的更新时，线程需要通过排它锁单独获得这个共享变量。 使用排他锁的代价是非常大的，我们使用volatitle来保证共享变量的可见性。 可见性： 一个线程修改共享变量时，其他线程能获得共享变量修改后的值。 定义为volatitle的共享变量具有的特性： 线程之间的可见性 允许多个线程同...
如何应对Android面试官-＞AQS原理和volatile详解，手写ReentrantLock核心实现
IT_Android的博客
12-28 886
AbstractQueuedSynchronizer，JDK提供的一个抽象类；这些全是 AbstractQueuedSynchronizer 的子类；AbstractQueuedSynchronizer 是 JDK 中用来构建同步并发的基础组件；AQS 中有一个比较重要的同步变量：private volatile int state // 同步状态；不管是 JDK 还是我们自己，在实现一个同步类的时候，都要围绕着这个 state 来做文章，修改它的值来表示当前的同步状态发生了变化；
多线程相关（5）
Great_est的博客
02-25 893
JAVA多线程相关（5） - 内存模型
Java Volatile（同步机制）关键字详解
Hern（宋兆恒）
09-11 657
Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。 　　在访问volatile变量时不会...
Java并发体系，java拦截器实现原理
m0_64383736的博客
12-08 311
多线程环境下的理论参考模型 为程序提供了极强的内存可见性保证 特性 一个线程中的所有操作必须按照程序的顺序来执行 所有线程都只能看到一个单一的操作执行顺序，不管程序是否同步 每个操作都必须原子执行且立刻对所有线程可见 happens-before MM中最核心的理论，保证内存可见性 在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。 理论 如果一个操作happens-before另一个操作，那么第一个操作的执行结果..
【JUC多线程与高并发】volatile详解
一个只有绵薄之力的老年人
07-19 268
volatile详解什么是volatilevolatile与JMM（volatile的特点）保证可见性禁止指令重排案例1：结果与分析不保证原子性案例1：案例结果与分析案例2结果与分析volatile与单例模式单线程下的单例模式示例1运行结果与分析多线程下的单例模式代码运行结果与分析 什么是volatile 我们使用翻译软件翻译一下volatile，会发现它有以下几个意思：易变的;无定性的;无常性的;可能急剧波动的;不稳定的;易恶化的;易挥发的;易发散的。这也正式使用volatile关键字的语义。 当你使
volatile关键字
kking_edc的博客
08-28 458
一、相关知识 1.1 内存可见性 线程对共享变量修改的可见性。当一个线程修改了共享变量的值，其他线程能够立刻得知这个修改。 volatile使用Lock前缀的指令禁止线程本地内存缓存，保证不同线程之间的内存可见性。 Java代码如下： //instance是volatile变量 Singleton volatile instance = new Singleton(); 转变成汇编代码如下： 0x01a3de1d: movb $0×0,0×1104800(%esi); 0x01a3de24: lock
Mybatis
最新发布
庸不易的博客
11-15 808
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 946
Rest请求处理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值