在进行多线程编程时,经常遇到多个线程同时对一个变量进行修改的问题。这时候为了保证不出现意想不到的结果,需要为这些变量加锁,以保证同一时刻只有一个线程能够修改。
在Java语言中,为了解决这种同步互斥的访问,有两种方法:synchronized和Lock.
1,synchronized
synchronized是Java语言中的一个关键词,是Java语言内置的特性。
通过使用synchronized来修饰一个方法或者一个代码块,来获得相应对象的锁,使这个方法或者代码块实现同步互斥访问。
synchronized方法
当一个线程执行某个对象的synchronized方法时,其他线程不能访问该对象的所有synchronized方法,因为一个对象只有一把锁。但是可以访问非synchronized方法。
另外,每个类也有一个锁,用了控制对static 成员变量的访问。
当一个线程访问一个对象的非static synchronized方法时,另一个线程可以访问该对象所属类的static synchronized方法。因为他们分别占用的是对象锁和类锁,不存在同步互斥问题。
synchronized代码块
当synchronized修饰代码块时,是如下格式使用,即会指定一个对象或者某个属性,需要获取该对象或属性的锁,才能执行代码块:
synchronized(obj) { }
synchronized代码块比synchronized方法更加灵活,
当一个线程获得锁,执行到synchronized修饰的代码时,其他的线程只能是一直等待状态。当前已获取锁的线程只有在以下情况下释放锁:
a, 执行完现在的代码块,线程释放对锁的占用;
b, 执行时出现异常,JVM会让线程自动释放该锁;
c, 线程调用wait()从而进入等待状态,自动释放锁。
因此synchronized存在如下一些缺陷:
a,未获取锁的线程只能一直等待当前的线程执行结束,才能获得锁。无法选择中断,如果当前的线程有一些耗时的操作的话,会很浪费资源。
b,通过synchronized来实现同步互斥的粒度太大。synchronized修饰的方法或代码块,实际上并不是方法或代码块中的所有代码都需要同步互斥访问。
c,对资源的操作分为读操作和写操作。两个读操作并不会出现并发互斥问题,如果使用synchronized的话,即使是两个读操作,也会在同一时刻只能有一个读操作能执行,其他的线程执行读操作会被阻塞。
d,我们无法得知线程是否已经成功获得锁。
由于存在以上这些问题,因此Java又引进了Lock机制。
2,Lock
Lock是一个Java接口,基于JDK层面的实现,来实现同步互斥访问。Lock的实现机制是以对volatile变量的读/写和CAS来实现多线程同步互斥访问的。
volatile:
由于CPU执行代码时,为了提高效率,会维护一个高速缓存。使用Volatile修饰的变量,都会在执行代码时强制从内存中读取最新变量值,而不是使用高速缓存的值。Volatile还会禁止指令重排。因此保证了两个特性:1,可见性,2有序性。
CAS: Compare and Swap(比较并交换)
CAS针对内存的操作:内存值V,旧的预期值A,要修改的新值B,当且仅当旧的预期值A与内存值V相同时,将内存值V修改为新值B,否则什么都不做。
借助CAS完成这个过程,是通过JNI调用C语言操作CPU底层指令完成的。这样就能保证这些内存操作的原子性。
我们分析一个使用Lock加锁的实例来查看,Lock是如何保证多线程的同步互斥访问的。
public Lock lk = new ReentrantLock(); public void testlock(){ lk.lock(); try { //需要互斥访问的具体操作代码 } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } finally{ lk.unlock(); } }Lock的使用,是通过调用lk.lock()和lk.unlock()来完成同步互斥访问的。
具体的lock()方法具体执行流程如下,以使用非公平锁为例说明,公平锁的流程稍有区别:
获取锁的过程即是对AQS中state状态进行修改的过程。state字段使用volatile修饰,使用CAS的方法compareAndSetState进行修改。如果state字段的值为0时,表示空闲,可以获取锁。大于0时,表示已经获得锁。当锁的模式为独占锁时,表示锁的重入次数,当锁的模式为共享锁时,表示锁当前共享的线程数。
3,Lock相关的类分析
了解了获取锁的大概流程后,我们来具体看看与锁相关的类。
Lock
Lock是一个接口,有以下几种方法:
lock(): 获取锁;
lockInterruptibly(): 获取锁,如果获取失败在等待锁时,能够响应中断,抛出中断异常。
trylock(): 获取锁,并且立即返回,获取锁成功则返回True,失败则返回False.
trylock(long,TimeUnit):与trylock类似,只是获取锁失败后则继续等待指定的时间。并且可以响应中断。
Condition
Condition:接口,提供了一些方法,以达到对锁更精确的控制。
await(): 线程等待状态,直到收到信号或者被中断。
awaitUninterruptibly():线程等待状态,直到收到信号。
awaitNanos(long):线程等待状态,直到收到信号或者被中断,或者到达指定时间为止。
await(long,TimeUnit):线程等待状态,直到收到信号或者被中断,或者到达指定时间为止。
signal(): 唤醒一个等待线程。
signalAll():唤醒所有等待线程。
AbstractOwnableSynchronizer:抽象类,由一个线程独占的同步器。
AbstractQueuedSynchronizer(AQS):
继承AbstractOwnableSynchronizer的抽象类,维护一个等待获取锁的线程CLH队列。包含两个内部类: Node和ConditionObject.
AbstractQueuedSynchronizer-Node类: 等待队列的Node类。
Node分为两种模式:独占锁和共享锁模式。
Node分为5种状态: SIGNAL = -1 表示当前节点的后继节点包含的线程需要运行,需要unparking;
CANCELLED = 1 表示当前节点由于过期或者中断被取消了;
CONDITION = -2 表示当前节点在等待condition,即在Condition队列中;
PROPAGATE = -3 表示后续的acquireShared应该执行
0:表示当前节点在同步队列中,等待锁。
AbstractQueuedSynchronizer-ConditionObject类:Condition接口的实现类。
signal():移除一个等待时间最长的线程,即Condition等待队列的第一个线程,把这个线程从condition队列一道同步队列中,即把Node状态由CONDITION(-2)修改为0。
signalAll():同signal一样,移除Condition队列中的所有线程。
ReentrantLock
ReentrantLock是一个可重入锁,Lock接口的实现类。默认创建的ReentrantLock是非公平锁,ReentrantLock(boolean) 支持创建公平锁和非公平锁。包含一个抽象内部类Sync(继承AbstractQueuedSynchronizer)以及其两个子类FairSync和NonfairSync,分别实现公平锁和非公平锁。
FairSync类和NonfairSync类都只包含lock()和tryAcquire()。这两个方法实现的不同,展示了公平锁和非公平锁的不同。
FairSync的lock方法直接调用acquire(1),AQS的acquire方法如下,即先调用tryAcquire(arg)和addWaiter(),acquireQueued,然后根据条件调用selfinterrupt方法。
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }FairSync重写的tryAcquire方法,先判断是否队列中有前置节点,没有前置节点才会尝试获取锁,这样就保证了多个线程获取锁的公平性。获取锁失败则返回False,然后让acquire方法继续完成加入独占锁等待队列。
NonfairSync的lock方法则是首先抢占式的获取锁,直接调用compareAndSetState方法,失败之后才会调用acquire(1).
NonfairSync重写的tryAcquire方法,尝试获取锁,获取失败加入等待队列。
tryAcquire方法中,都会判断当前线程是否已经获取锁的线程。如果是的话,则会更新state值为state+1,此时就是完成重入锁的过程。
ReentrantReadWriteLock
同时,JUC包还提供了ReadLock 和 WriteLock.
ReadLock和WriteLock都作为ReentrantReadWriteLock的内部类,实现了Lock接口。ReentrantReadWriteLock也包含一个抽象类Sync继承自AbstractQueuedSynchronizer,和两个子类FairSync和NonfairSync。在AQS类中,state的值代表锁的状态,在Sync类中,对state进行了如下定义:高16位代表读锁的数量,低16位代表写锁的重入次数。如下图所示:
读锁和写锁的工作过程:
通过ReentrantReadWriteLock能直接获得读锁和写锁,可传入参数决定是公平锁或非公平锁。
public ReentrantReadWriteLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); readerLock = new ReadLock(this); writerLock = new WriteLock(this); }读锁的获取过程:
lock方法直接调用AQS的acquireShared(1),即以共享模式获取锁,然后调用Sync重写的tryAcquireShared(1),进行判断,如果是其他的线程已经持有独占锁,则直接返回-1,获取锁失败,进入共享锁等待队列; 否则获取锁成功。
protected final int tryAcquireShared(int unused) { /* * Walkthrough: * 1. If write lock held by another thread, fail. * 2. Otherwise, this thread is eligible for * lock wrt state, so ask if it should block * because of queue policy. If not, try * to grant by CASing state and updating count. * Note that step does not check for reentrant * acquires, which is postponed to full version * to avoid having to check hold count in * the more typical non-reentrant case. * 3. If step 2 fails either because thread * apparently not eligible or CAS fails or count * saturated, chain to version with full retry loop. */ Thread current = Thread.currentThread(); int c = getState(); //如果是其他的线程已经持有独占锁,则直接返回-1. if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) return -1; //获得共享锁的数量 int r = sharedCount(c); //如果不需要阻塞读锁,并且读锁数量没达到最大值,并且成功更新读锁的数量(在高16位加1); 、 //判断是否需要阻塞读锁,readerShouldBlock(),是公平锁和非公平锁的区别所在。 if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) { //r=0,表示当前线程就是第一个读锁。 if (r == 0) { firstReader = current; firstReaderHoldCount = 1; } else if (firstReader == current) { //firstReader就是当前线程,则是当前线程重入了,更新firstReaderHoldCount. firstReaderHoldCount++; } else { //当前线程和第一个线程不同,记录当前线程读锁+1. HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != getThreadId(current)) cachedHoldCounter = rh = readHolds.get(); else if (rh.count == 0) readHolds.set(rh); rh.count++; } return 1; } //否则,循环尝试 return fullTryAcquireShared(current); }公平锁和非公平锁的区别
在调用readerShouldBlock时体现: 非公平锁只需要判断第一个线程节点是否是独占模式;公平锁则是判断队列中是否有前置线程在排队等待。
在调用writeShouldBlack时体现:非公平锁直接返回false,不需要阻塞;公平锁则是判断队列中是否有前置线程在排队等待。
写锁的获取过程:
直接调用AQS的acquire(1),然后调用Sync重写的tryAcquire(1),
protected final boolean tryAcquire(int acquires) { /* * Walkthrough: * 1. If read count nonzero or write count nonzero * and owner is a different thread, fail. * 2. If count would saturate, fail. (This can only * happen if count is already nonzero.) * 3. Otherwise, this thread is eligible for lock if * it is either a reentrant acquire or * queue policy allows it. If so, update state * and set owner. */ Thread current = Thread.currentThread(); int c = getState(); int w = exclusiveCount(c); //c!=0代表当前已经有锁(读锁或者写锁)。 if (c != 0) { // (Note: if c != 0 and w == 0 then shared count != 0) //如果写锁为0,或者当前线程不是独占线程, //即代表当前有锁,但不符合重入条件,返回false。 if (w == 0 || current != getExclusiveOwnerThread()) return false; //写锁数量超过最大数; if (w + exclusiveCount(acquires) > MAX_COUNT) throw new Error("Maximum lock count exceeded"); // Reentrant acquire //设置当前写锁重入数 setState(c + acquires); return true; } //当前还没有锁的处理过程: //写锁应该阻塞或者直接修改标志位获取锁的操作(CAS)失败,返回false if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) return false; //成功获取锁,则设置当前线程为独占线程; setExclusiveOwnerThread(current); return true; }读锁和写锁的释放unlock,操作流程也跟lock类似,分别调用releaseShared(1)->tryReleaseShared(1)和release(1)->tryRelease(1)。
相关推荐
JAVA并发编程艺术 高清pdf : 1.并发变成的挑战 2. java并发机制的底层实现原理 3. java 内存模型 4. java并发编程基础 5.java中的锁。。。。。。。
《Java并发编程的艺术》内容涵盖Java并发编程机制的底层实现原理、Java内存模型、Java并发编程基础、Java中的锁、并发容器和框架、原子类、并发工具类、线程池、Executor框架等主题,每个主题都做了深入的讲解,同时...
主要总结了:本地内存和线程安全的问题、volatile、synchronized、处理器实现并发的方式、Java实现并发的方式。
1.1 并发简史 1.2 线程的优势 1.2.1 发挥多处理器的强大能力 1.2.2 建模的简单性 1.2.3 异步事件的简化处理 1.2.4 响应更灵敏的用户界面 1.3 线程带来的风险 1.3.1 安全性问题 1.3.2 活跃性问题 1.3.3 ...
Java并发编程Xmind思维导图,思路更清晰。内容来自《Java并发编程的艺术》,包括并发机制底层原理、Java内存模型、Java并发编程基础、锁机制、线程池、并发工具类、原子操作类、并发容器和框架。纯手打,非诚勿扰。
, 《Java并发编程的艺术》内容涵盖Java并发编程机制的底层实现原理、Java内存模型、Java并发编程基础、Java中的锁、并发容器和框架、原子类、并发工具类、线程池、Executor框架等主题,每个主题都做了深入的讲解,...
Java并发编程实战,第1章 简介,第2章 线程安全性 第3章 对象的共享 第4章 对象的组合 第5章 基础构建模块 第6章 任务执行 第7章 取消与关闭 第8章 线程池的使用 第9章 图形用户界面应用程序 第10章 避免...
Java 5以及6在开发并发程序取得了显著的进步,提高了Java虚拟机的性能,提高了并发类的可伸缩性,并加入了丰富的新并发构建块。在本书中,这些便利工具的创造者不仅解释了它们究竟如何工作、如何使用,同时,还阐释...
第30节通过生产者消费者模型理解等待唤醒机制00:20:50分钟 | 第31节Condition的使用及原理解析00:17:40分钟 | 第32节使用Condition重写wait/notify案例并实现一个有界队列00:22:05分钟 | 第33节深入解析Condition...
1.1 并发简史 1.2 线程的优势 1.2.1 发挥多处理器的强大能力 1.2.2 建模的简单性 1.2.3 异步事件的简化处理 1.2.4 响应更灵敏的用户界面 1.3 线程带来的风险 1.3.1 安全性问题 1.3.2 活跃性问题 1.3.3 ...
通过生产者消费者模型理解等待唤醒机制.mp4 Condition的使用及原理解析.mp4 使用Condition重写waitnotify案例并实现一个有界队列.mp4 深入解析Condition源码.mp4 实战:简易数据连接池.mp4 线程之间通信之join应用与...
龙果 java并发编程原理实战 第2节理解多线程与并发的之间的联系与区别 [免费观看] 00:11:59分钟 | 第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 [免费观看] 00:13:03分钟 | 第4节学习并发的四...
Java分布式应用学习笔记06浅谈并发加锁机制分析
Java并发编程 背景介绍 并发历史 必要性 进程 资源分配的最小单位 线程 CPU调度的最小单位 线程的优势 ... Java并发程序中的串行,主要来自独占的资源锁 优化策略 缩
由浅入深解析synchronized锁的机制,各种锁的概念的介绍,膨胀过程,基于redis的分布式锁demo。
锁:Java中的锁机制,包括synchronized关键字和ReentrantLock类。 线程池:Java中的线程池机制,包括线程池的创建、执行任务、关闭等操作。 并发集合:Java中的并发集合,包括ConcurrentHashMap、...