- 浏览: 145156 次
- 性别:
- 来自: 深圳
文章分类
最新评论
-
lyaqys:
lz实现的OptimisticExclusiveLock有点问 ...
java park/unpark 【java并发】基于JUC CAS原理,自己实现简单独占锁
LockSupport.park(); 停止
System.out.println("======");
为阻塞线程提供基础的功能,它由一对park和unpark组成,park会阻塞当前线程,unpark“唤醒”等待线程;内部使用了类似信号量的“许可”机制,该许可为0,park会在许可等于0的时候下阻塞,等于1的时候立即返回,并且将许可减为0,umpark会尝试唤醒线程,并且将许可+1(最大值就是1)。因此,如果先调用unpark方法,再调用park是无效的
unpark /patk 成对出现
synchronized的基本原理回顾
在jvm内部,所有对象都含有单一的锁,jvm负责跟踪监视被加锁次数,叫做对象监视器。当线程第一次给对象加锁的时候,计数器会加1,离开时会减1.同样任务是可重入的,每次重入也是加1,离开减1.
synchronized是独占式的,拿到对象锁才能继续,没有获取到锁就会阻塞。
JUC CAS乐观锁基本原理
synchronized就是一种独占锁,会导致其它所有需要锁的线程挂起,等待持有锁的线程释放锁。
乐观锁就是假设没有冲突而去完成某项操作,如果因为冲突失败就重试。
原理有点类似于在数据库记录字段增加一个版本号,每次更新的时候做两个事情:
1.检查数据库记录当前的版本号和读取到的版本号是否一致,不一致说明数据已不是最新,更新失败需要重试.
2.如果版本号一致,更新成功,同时将版本号加1.
在jdk1.5开始,Doug Lea在JUC类库里提供了类似的乐观锁的机制叫CAS.
CAS简介:compareAndSet的意思,就是先比较是否是期望值(是期望值,说明没人更改过,当然也有可能有ABA情况),如果是再设值,不是就设值失败,线程阻塞。如果是基于这个,就要保证比较和设值这两个动作是原子性的,如何保证呢?这个是借助于JNI,利用CPU硬件支持来完成的。利用硬件提供swap和test_and_set指令,单CPU下同一指令的多个指令周期不可中断,SMP中通过锁总线支持这两个指令的原子性。
volilate关键字
Java语言规范允许线程保存共享成员变量的私有拷贝,当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。这样就延伸出可见性的一个问题。
CAS解决了比较和更新的原子性,但是还有另外一个问题就是要保证可见性。Volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
volatile关键字有两层含义:
1.对于这个成员变量不能保存它的私有拷贝,而应直接与共享成员变量交互。
2.volatile前后的代码不能重排
其他话题
volilate和cas只能乐观锁保证的状态控制的正确,而在设置状态失败的时候,仍然需要阻塞线程。juc里提供了LockSupport的park和unpark方法用于阻塞线程。而不同的场景下需要不同的等待策略和锁共享策略,juc提供了AbstractQueuedSynchronizer(AQS)为基类的一序列不同的锁,底层都是基于CAS、LocakSupport和Queue来管理,后续有时间细细分析。
juc基于的CAS,提供了带有原子性的基本类型封装类,如AtomicInteger、AtomicLong等。
AtomicInteger原理:
如自增:
Java代码
/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next)) //cas
return current;
}
}
compareAndSet的实现如下:
Java代码
public final boolean compareAndSet(int expect, int update) {
urn unsafe.compareAndSwapInt(this, valueOffset, expect, update); //JNI调用
}
自己实现简单乐观独占锁
基于cas,本人简单实现了一个乐观独占锁,代码如下:
基于CAS简单乐观独占锁
Java代码
package lock.test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.LockSupport;
/**
* 简单乐观独占锁
*/
public class OptimisticExclusiveLock {
/**
* 独占锁标记 true 锁不可用 false 锁可用
*/
private AtomicBoolean state = new AtomicBoolean(false);
List<Thread> queue = new ArrayList<Thread>();//阻塞队列
public boolean lock() {
if (!state.get()&&state.compareAndSet(false, true)) {//取锁成功不会阻塞,程序会继续执行
return true; // 利用CAS
} else {
queue.add(Thread.currentThread());//加入阻塞队列
LockSupport.park();//阻塞线程
return false;
}
}
public boolean unLock() {
if (state.get()) {
queue.remove(Thread.currentThread());//从队列里移除
if (state.compareAndSet(true, false)) {// 利用CAS
if(!queue.isEmpty()){
LockSupport.unpark(queue.get(0));//唤醒第一个等待线程
}
return true;
}
return false;
} else {
return false;
}
}
}
简单乐观独占锁测试
Java代码
package lock.test;
/**
* @author Administrator 独占锁测试
*/
public class OptimisticExclusiveLockTest {
public static OptimisticExclusiveLock lock = new OptimisticExclusiveLock(); // 独占锁
public static volatile int i = 0; // 保证可见性
public class Task implements Runnable {
@Override
public void run() {
while (true) {
try {
lock.lock();//加锁
i += 2;
System.out.println("thread name:" + Thread.currentThread().getName() + " i=" + i);
} finally {
lock.unLock();//释放锁
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public void runTask() {
for (int i = 0; i < 100; i++) {
Thread t = new Thread(new Task(), "thread" + i);
t.start();
}
}
public static void main(String[] args) {
OptimisticExclusiveLockTest test = new OptimisticExclusiveLockTest();
test.runTask();
}
}
这里实现的简单乐观独占锁很简单,但是能保证并发性。
JUC里面基于CAS实现了很多的锁,主要是基于AQS实现,如ReentrantLock,CountDownLatch,Semaphore,FutureTask等,适用于不同的锁场景。
System.out.println("======");
为阻塞线程提供基础的功能,它由一对park和unpark组成,park会阻塞当前线程,unpark“唤醒”等待线程;内部使用了类似信号量的“许可”机制,该许可为0,park会在许可等于0的时候下阻塞,等于1的时候立即返回,并且将许可减为0,umpark会尝试唤醒线程,并且将许可+1(最大值就是1)。因此,如果先调用unpark方法,再调用park是无效的
unpark /patk 成对出现
synchronized的基本原理回顾
在jvm内部,所有对象都含有单一的锁,jvm负责跟踪监视被加锁次数,叫做对象监视器。当线程第一次给对象加锁的时候,计数器会加1,离开时会减1.同样任务是可重入的,每次重入也是加1,离开减1.
synchronized是独占式的,拿到对象锁才能继续,没有获取到锁就会阻塞。
JUC CAS乐观锁基本原理
synchronized就是一种独占锁,会导致其它所有需要锁的线程挂起,等待持有锁的线程释放锁。
乐观锁就是假设没有冲突而去完成某项操作,如果因为冲突失败就重试。
原理有点类似于在数据库记录字段增加一个版本号,每次更新的时候做两个事情:
1.检查数据库记录当前的版本号和读取到的版本号是否一致,不一致说明数据已不是最新,更新失败需要重试.
2.如果版本号一致,更新成功,同时将版本号加1.
在jdk1.5开始,Doug Lea在JUC类库里提供了类似的乐观锁的机制叫CAS.
CAS简介:compareAndSet的意思,就是先比较是否是期望值(是期望值,说明没人更改过,当然也有可能有ABA情况),如果是再设值,不是就设值失败,线程阻塞。如果是基于这个,就要保证比较和设值这两个动作是原子性的,如何保证呢?这个是借助于JNI,利用CPU硬件支持来完成的。利用硬件提供swap和test_and_set指令,单CPU下同一指令的多个指令周期不可中断,SMP中通过锁总线支持这两个指令的原子性。
volilate关键字
Java语言规范允许线程保存共享成员变量的私有拷贝,当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。这样就延伸出可见性的一个问题。
CAS解决了比较和更新的原子性,但是还有另外一个问题就是要保证可见性。Volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
volatile关键字有两层含义:
1.对于这个成员变量不能保存它的私有拷贝,而应直接与共享成员变量交互。
2.volatile前后的代码不能重排
其他话题
volilate和cas只能乐观锁保证的状态控制的正确,而在设置状态失败的时候,仍然需要阻塞线程。juc里提供了LockSupport的park和unpark方法用于阻塞线程。而不同的场景下需要不同的等待策略和锁共享策略,juc提供了AbstractQueuedSynchronizer(AQS)为基类的一序列不同的锁,底层都是基于CAS、LocakSupport和Queue来管理,后续有时间细细分析。
juc基于的CAS,提供了带有原子性的基本类型封装类,如AtomicInteger、AtomicLong等。
AtomicInteger原理:
如自增:
Java代码
/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next)) //cas
return current;
}
}
compareAndSet的实现如下:
Java代码
public final boolean compareAndSet(int expect, int update) {
urn unsafe.compareAndSwapInt(this, valueOffset, expect, update); //JNI调用
}
自己实现简单乐观独占锁
基于cas,本人简单实现了一个乐观独占锁,代码如下:
基于CAS简单乐观独占锁
Java代码
package lock.test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.LockSupport;
/**
* 简单乐观独占锁
*/
public class OptimisticExclusiveLock {
/**
* 独占锁标记 true 锁不可用 false 锁可用
*/
private AtomicBoolean state = new AtomicBoolean(false);
List<Thread> queue = new ArrayList<Thread>();//阻塞队列
public boolean lock() {
if (!state.get()&&state.compareAndSet(false, true)) {//取锁成功不会阻塞,程序会继续执行
return true; // 利用CAS
} else {
queue.add(Thread.currentThread());//加入阻塞队列
LockSupport.park();//阻塞线程
return false;
}
}
public boolean unLock() {
if (state.get()) {
queue.remove(Thread.currentThread());//从队列里移除
if (state.compareAndSet(true, false)) {// 利用CAS
if(!queue.isEmpty()){
LockSupport.unpark(queue.get(0));//唤醒第一个等待线程
}
return true;
}
return false;
} else {
return false;
}
}
}
简单乐观独占锁测试
Java代码
package lock.test;
/**
* @author Administrator 独占锁测试
*/
public class OptimisticExclusiveLockTest {
public static OptimisticExclusiveLock lock = new OptimisticExclusiveLock(); // 独占锁
public static volatile int i = 0; // 保证可见性
public class Task implements Runnable {
@Override
public void run() {
while (true) {
try {
lock.lock();//加锁
i += 2;
System.out.println("thread name:" + Thread.currentThread().getName() + " i=" + i);
} finally {
lock.unLock();//释放锁
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public void runTask() {
for (int i = 0; i < 100; i++) {
Thread t = new Thread(new Task(), "thread" + i);
t.start();
}
}
public static void main(String[] args) {
OptimisticExclusiveLockTest test = new OptimisticExclusiveLockTest();
test.runTask();
}
}
这里实现的简单乐观独占锁很简单,但是能保证并发性。
JUC里面基于CAS实现了很多的锁,主要是基于AQS实现,如ReentrantLock,CountDownLatch,Semaphore,FutureTask等,适用于不同的锁场景。
评论
1 楼
lyaqys
2014-12-30
lz实现的OptimisticExclusiveLock有点问题哦,
1. List<Thread> queue = new ArrayList<Thread>();//阻塞队列 不是线程安全的
2. The park method may also return at any other time, for "no reason", so in general must be invoked within a loop that rechecks conditions upon return. In this sense park serves as an optimization of a "busy wait" that does not waste as much time spinning, but must be paired with an unpark to be effective.----park可能无缘无故return,因此要用while包起来。
可以参看LockSupport源码里面给的例子
class FIFOMutex {
private final AtomicBoolean locked = new AtomicBoolean(false);
private final Queue<Thread> waiters
= new ConcurrentLinkedQueue<Thread>();
public void lock() {
boolean wasInterrupted = false;
Thread current = Thread.currentThread();
waiters.add(current);
// Block while not first in queue or cannot acquire lock
while (waiters.peek() != current ||
!locked.compareAndSet(false, true)) {
LockSupport.park(this);
if (Thread.interrupted()) // ignore interrupts while waiting
wasInterrupted = true;
}
waiters.remove();
if (wasInterrupted) // reassert interrupt status on exit
current.interrupt();
}
public void unlock() {
locked.set(false);
LockSupport.unpark(waiters.peek());
}
}
1. List<Thread> queue = new ArrayList<Thread>();//阻塞队列 不是线程安全的
2. The park method may also return at any other time, for "no reason", so in general must be invoked within a loop that rechecks conditions upon return. In this sense park serves as an optimization of a "busy wait" that does not waste as much time spinning, but must be paired with an unpark to be effective.----park可能无缘无故return,因此要用while包起来。
可以参看LockSupport源码里面给的例子
class FIFOMutex {
private final AtomicBoolean locked = new AtomicBoolean(false);
private final Queue<Thread> waiters
= new ConcurrentLinkedQueue<Thread>();
public void lock() {
boolean wasInterrupted = false;
Thread current = Thread.currentThread();
waiters.add(current);
// Block while not first in queue or cannot acquire lock
while (waiters.peek() != current ||
!locked.compareAndSet(false, true)) {
LockSupport.park(this);
if (Thread.interrupted()) // ignore interrupts while waiting
wasInterrupted = true;
}
waiters.remove();
if (wasInterrupted) // reassert interrupt status on exit
current.interrupt();
}
public void unlock() {
locked.set(false);
LockSupport.unpark(waiters.peek());
}
}
发表评论
-
java 栈内存解惑
2013-10-23 23:41 634int j = 0; j = j++; ... -
Google Guava Collections 使用介绍
2013-07-16 18:10 646Google Guava Collections 使用介绍 J ... -
Google Collections(Guava)中强大的Concurrent MapMaker
2013-07-16 18:07 1291仔细研究了刚发布1.0版本的Google Collection ... -
java wait 研究
2013-06-28 17:07 728[color=red]java wait 的使用必须放在实例对 ... -
java钩子函数的使用已经kill
2013-06-27 22:31 1502package com.aircoder.test; imp ... -
java获取所有的线程信息
2013-06-24 20:02 1553public class T2 { public sta ... -
java 获取mysql datetime 时间注意
2013-05-16 14:43 1470class SPubinfo implements RowMa ... -
java wait的解锁理解********
2013-04-18 10:49 879很多书都说wait会释放线程加的锁,其实经过试验不是这样的, ... -
jvm 关闭处理注册方法
2013-04-08 16:11 720import java.lang.*; public cla ... -
wget ftp 下载文件java代码
2013-04-05 15:16 1081private boolean wget(String fil ... -
xPath 解析xml
2013-04-05 15:14 695使用xPath 根据路径解析文件. xpath 具有多个版本。 ... -
java callable疑惑:
2013-04-05 15:12 540看了 线程持的源码和Futuretask的源码终于明白了 Fu ... -
ubuntu eclipse 问题
2013-04-05 03:30 730Eclipse 3.6 在 Ubuntu 10.04 下会出现 ... -
ehchahe 例子
2013-01-23 15:40 934package test; import net.sf.eh ... -
java 类加载
2012-12-24 15:21 6981: 访问一个类的静态方法的时候。不会引起一个类的初始化,即类 ... -
java 获取图片高和宽
2012-12-13 17:01 1315public static Map<String,Int ... -
java建立socket,返回浏览器的请求
2012-12-01 01:58 952package com.jdk.api.test; impo ... -
schedulePool.scheduleAtFixedRate 是个误解
2012-11-22 20:34 1166我们经常使用的java定时器单线程执行,例如: 一个任务每个 ... -
ExecutorCompletionService
2012-11-19 22:36 657package com.jdk.api; import ja ...
相关推荐
Java多线程(Synchronized+Volatile+JUC 并发工具原理+线程状态+CAS+线程池)
java高级技术JUC高并发编程教程2021(1.5G) 〖课程介绍〗: java高级技术JUC高并发编程教程2021(1.5G) 〖课程目录〗: 01-JUC高并发编程-课程介绍.mp4 02-JUC高并发编程-JUC概述和进程线程概念(1).mp4 03-JUC...
Java 并发编程中的 JUC(java.util.concurrent)库以及其核心组件 AQS(AbstractQueuedSynchronizer)在构建高性能、可伸缩性的多线程应用方面具有重要的地位。 AQS 是 JUC 中的核心组件,它提供了一个框架,让...
而了解 Java 并发编程以及其中的 JUC(java.util.concurrent)线程池,对于构建高性能、高可伸缩性的应用程序具有重要意义。 多核处理器的出现使得并发执行成为一种重要的优化手段。了解并发编程和线程池的工作原理...
Java 并行程序开发的基础, 包括 Java 中 Thread 的基本使用方法等第3章介绍了 JDK 内部对并行程序开发的支持, 主要介绍 JUC (Java.util.concurrent) 中些工具的使用方法、 各自特点及它们的内部实现原理。...
JUC代码收集,java高并发多线程学习
资源概要:1,多线程;2,synchronized;3,volatile;4,多线程在JVM中的实现...原子类Atomic-CAS及其实现原理 锁Lock-AQS核心原理剖析 并发工具类、并发容器、阻塞队列 线程池原理剖析 线程池案例-Web容器-压力测试
JUC并发编程知识点梳理思维导图
自己总结的,有需要的朋友可以借鉴借鉴,大家互相学习,相互进步,感觉有问题的地方,欢迎大家留言~~~
课程内容包括了JAVA手写线程池,UC线程池API详解,线程安全根因详解,锁与原子类,分布式锁原理与实现方式,并发编程-AQS等等针对性非常强的JAVA编程开发教程,这其中的内容对JAVA开发技能的拔尖,非常的有帮助。...
java高并发源码 java-concurrent Java 高并发,JUC,相关源码。 1、马士兵高并发视频源码(听课时练习)
深入了解Java的并发开发工具包的基本原理,有兴趣的可以学习下。
课程从技术原理和细节上,进行非常详细的解读,是目前听过关于JUC企业级高并发最专业的课程,而高手往往在这些关键技术点上容易忽略,期待这个课程带给你更多技术的体验。 (1)\代码;目录中文件数:7个 ├─day01-...
B站楠哥JUC Java并发编程
JUC 笔记 基于JDK 17
JUC最详细思维导图,一次了解读写锁,可重入锁,Cas原理,volatile 关键字原理
cehi
Java 多线程与并发(10_26)-JUC锁_ 锁核心类AQS详解
JUC底层实现原理分析,结构多线程更加贯彻同步知识
自己学习过程对Java JUC包知识的总结,看完并理解基本能应付各种基本的问题点,墙裂推荐分享 博客跳转链接: https://blog.csdn.net/qq_35642036/article/details/82767070