Java锁及实现方式

33 篇文章 1 订阅
23 篇文章 0 订阅

锁的概念在数据库出现比较多,为了实现数据库的不同隔离级别,数据库会定义不同的锁类型。Java为了实现同步及线程安全,也会定义不同的锁。所谓的同步操作即原子操作(atomic operation)意为“不可被中断的一个或一系列操作”,类似数据库中的事务。

线程安全实现方式

互斥同步(锁机制)

互斥是实现同步的一种手段,临界区(Critical Section)、互斥量(Mutex)和信号量(Semaphore)都是主要的互斥实现方式。

Java主要实现方式:synchronized和ReentrantLock

ReentrantLock 实现等待可中断、 可实现公平锁, 以及锁可以绑定多个条件。

等待可中断是指当持有锁的线程长期不释放锁的时候,正在等待的线程可以选择放弃等待,改为处理其他事情,可中断特性对处理执行时间非常长的同步块很有帮助。

公平锁是指多个线程在等待同一个锁时, 必须按照申请锁的时间顺序来依次获得锁;而非公平锁则不保证这一点,在锁被释放时, 任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平的,ReentrantLock默认情况下也是非公平的, 但可以通过带布尔值的构造函数要求使用公平锁。

锁绑定多个条件是指一个ReentrantLock对象可以同时绑定多个Condition对象,而在synchronized中,锁对象的wait()和notify()或notifyAll() 方法可以实现一个隐含的条件, 如果要和多于一个的条件关联的时候,就不得不额外地添加一个锁,而ReentrantLock则无须这样做,只需要多次调用newCondition() 方法即可。

非阻塞同步(使用循环CAS实现原子操作)

基于冲突检测的乐观并发策略,通俗地说,就是先进行操作,如果没有其他线程争用共享数据,那操作就成功了;如果共享数据有争用,产生了冲突,那就再采取其他的补偿措施(最常见的补偿措施就是不断地重试,直到成功为止),这种乐观的并发策略的许多实现都不需要把线程挂起,因此这种同步操作称为非阻塞同步(Non-Blocking Synchronization)。

因为我们需要操作和冲突检测这两个步骤具备原子性,靠什么来保证呢? 如果这里再使用互斥同步来保证就失去意义了,所以我们只能靠硬件来完成这件事情,硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成,这类指令常用的有:

  • 测试并设置(Test-and-Set)
  • 获取并增加(Fetch-and-Increment)
  • 交换(Swap)
  • 比较并交换(Compare-and-Swap,下文称CAS)
  • 加载链接/条件存储(Load-Linked/Store-Conditional,下文称LL/SC)

由于Unsafe类不是提供给用户程序调用的类(Unsafe.getUnsafe(的代码中限制了只有启动类加载器(Bootstrap ClassLoader) 加载的Class才能访问它),因此,如果不采用反射手段,我们只能通过其他的Java API来间接使用它,如J.U.C包里面的整数原子类,其中的compareAndSet()和getAndIncrement()等方法都使用了Unsafe类的CAS操作。

无同步方案

可重入代码(Reentrant Code):这种代码也叫做纯代码(Pure Code),可以在代码执行的任何时刻中断它,转而去执行另外一段代码(包括递归调用它本身),而在控制权返回后,原来的程序不会出现任何错误。相对线程安全来说,可重入性是更基本的特性,它可以保证线程安全,即所有的可重入的代码都是线程安全的,但是并非所有的线程安全的代码都是可重入的。

可重入代码有一些共同的特征, 例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性:如果一个方法,它的返回结果是可以预测的,只要输入了相同的数据,就都能返回相同的结果,那它就满足可重入性的要求,当然也就是线程安全的。

线程本地存储(Thread Local Storage):如果一段代码中所需要的数据必须与其他代码共享,那就看看这些共享数据的代码是否能保证在同一个线程中执行?如果能保证,我们就可以把共享数据的可见范围限制在同一个线程之内,这样,无须同步也能保证线程之间不出现数据争用的问题。

Java 锁

队列同步器 AbstractQueuedSynchronizer

队列同步器AbstractQueuedSynchronizer(以下简称同步器),是用来构建锁或者其他同步组件的基础框架,它使用了一个int成员变量表示同步状态,通过内置的FIFO队列来完成资源获取线程的排队工作。

同步器是实现锁(也可以是任意同步组件)的关键,在锁的实现中聚合同步器,利用同步器实现锁的语义。

同步器的设计是基于模板方法模式的,也就是说,使用者需要继承同步器并重写指定的方法,随后将同步器组合在自定义同步组件的实现中,并调用同步器提供的模板方法,而这些模板方法将会调用使用者重写的方法。

重写同步器指定的方法时,需要使用同步器提供的如下3个方法来访问或修改同步状态。

  • getState():获取当前同步状态。
  • setState(int newState):设置当前同步状态。
  • compareAndSetState(int expect,int update):使用CAS设置当前状态,该方法能够保证状态设置的原子性。

队列同步器的实现分析

同步器依赖内部的同步队列(一个FIFO双向队列)来完成同步状态的管理,当前线程获取同步状态失败时,同步器会将当前线程以及等待状态等信息构造成为一个节点(Node)并将其加入同步队列,同时会阻塞当前线程,当同步状态释放时,会把首节点中的线程唤醒,使其再次尝试获取同步状态。

独占式同步状态获取与释放

通过调用同步器的acquire(int arg)方法可以获取同步状态,该方法对中断不敏感,也就是由于线程获取同步状态失败后进入同步队列中,后续对线程进行中断操作时,线程不会从同步队列中移出。

共享式同步状态获取与释放

共享式获取与独占式获取最主要的区别在于同一时刻能否有多个线程同时获取到同步状态。以文件的读写为例,如果一个程序在对文件进行读操作,那么这一时刻对于该文件的写操作均被阻塞,而读操作能够同时进行。写操作要求对资源的独占式访问,而读操作可以是共享式访问。

独占式超时获取同步状态

通过调用同步器的doAcquireNanos(int arg,long nanosTimeout)方法可以超时获取同步状态,即在指定的时间段内获取同步状态,如果获取到同步状态则返回true,否则,返回false。该方法提供了传统Java同步操作(比如synchronized关键字)所不具备的特性。

自定义同步组件——TwinsLock

首先,确定访问模式。TwinsLock能够在同一时刻支持多个线程的访问,这显然是共享式访问,因此,需要使用同步器提供的acquireShared(int args)方法等和Shared相关的方法,这就要求TwinsLock必须重写tryAcquireShared(int args)方法和tryReleaseShared(int args)方法,这样才能保证同步器的共享式同步状态的获取与释放方法得以执行。

其次,定义资源数。TwinsLock在同一时刻允许至多两个线程的同时访问,表明同步资源数为2,这样可以设置初始状态status为2,当一个线程进行获取,status减1,该线程释放,则status加1,状态的合法范围为0、1和2,其中0表示当前已经有两个线程获取了同步资源,此时再有其他线程对同步状态进行获取,该线程只能被阻塞。在同步状态变更时,需要使用compareAndSet(int expect,int update)方法做原子性保障。

public class TwinsLock implements Lock {
	private final Sync sync = new Sync(2);

	private static final class Sync extends AbstractQueuedSynchronizer {
		Sync(int count) {
			if (count <= 0) {
				throw new IllegalArgumentException("count must large than zero.");
			}
			setState(count);
		}

		public int tryAcquireShared(int reduceCount) {
			for (;;) {
				int current = getState();
				int newCount = current - reduceCount;
				if (newCount < 0 || compareAndSetState(current, newCount)) {
					return newCount;
				}
			}
		}

		public boolean tryReleaseShared(int returnCount) {
			for (;;) {
				int current = getState();
				int newCount = current + returnCount;
				if (compareAndSetState(current, newCount)) {
					return true;
				}
			}
		}
	}

	public void lock() {
		sync.acquireShared(1);
	}

	public void unlock() {
		sync.releaseShared(1);
	}
// 其他接口方法略
	@Override
	public void lockInterruptibly() throws InterruptedException {
		// TODO Auto-generated method stub
	}
	@Override
	public boolean tryLock() {
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public Condition newCondition() {
		// TODO Auto-generated method stub
		return null;
	}
}

重入锁 ReentrantLock

重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞,该特性的实现需要解决以下两个问题。

  1. 线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程,如果是,则再次成功获取。
  2. 锁的最终释放。线程重复n次获取了锁,随后在第n次释放该锁后,其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增,计数表示当前锁被重复获取的次数,而锁被释放时,计数自减,当计数等于0时表示锁已经成功释放。

读写锁 ReentrantReadWriteLock

在没有读写锁支持的时候,如果需要完成上述工作就要使用Java的等待通知机制,就是当写操作开始时,所有晚于写操作的读操作均会进入等待状态,只有写操作完成并进行通知之后,所有等待的读操作才能继续执行(写操作之间依靠synchronized关键进行同步),这样做的目的是使读操作能读取到正确的数据,不会出现脏读。改用读写锁实现上述功能,只需要在读操作时获取读锁,写操作时获取写锁即可。当写锁被获取到时,后续(非当前写操作线程)的读写操作都会被阻塞,写锁释放之后,所有操作继续执行,编程方式相对于使用等待通知机制的实现方式而言,变得简单明了。

读写锁的性能都会比排它锁好,因为大多数场景读是多于写的。

LockSupport工具

当需要阻塞或唤醒一个线程的时候,都会使用LockSupport工具类来完成相应工作。LockSupport定义了一组的公共静态方法,这些方法提供了最基本的线程阻塞和唤醒功能,而LockSupport也成为构建同步组件的基础工具。

Condition接口

任意一个Java对象,都拥有一组监视器方法(定义在java.lang.Object上),主要包括wait()、wait(long timeout)、notify()以及notifyAll()方法,这些方法与synchronized同步关键字配合,可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法,与Lock配合可以实现等待/通知模式,但是这两者在使用方式以及功能特性上还是有差别的。

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
public void conditionWait() throws InterruptedException {
    lock.lock();
    try {
        condition.await();
    } finally {
        lock.unlock();
    }
}
public void conditionSignal() throws InterruptedException {
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }
}

JVM锁的优化

锁状态类型

目的

原理
无锁  

偏向锁

在无竞争的情况下消除整个同步使用的互斥量,连CAS操作都不做

偏向锁会偏向第一个获得它的线程,如果在接下来的执行过程中该锁没有被其他线程获取,则持有偏向锁的线程以后进入这个锁相关的同步块不再需要进行同步

1.锁对象第一次被获取时,虚拟机会把对象头中的锁标志位设置为01,即偏向锁模式;

2.同时使用CAS操作将线程ID记录在对象的 Mark World 之中;

3.若CAS操作成功,则以后进入这个锁相关的同步块时不再进行任何同步操作。

当另一个线程尝试获取这个锁时,偏向模式结束。此时根据锁对象是否处于锁定状态,将锁对象恢复到未锁定状态或者轻量级锁状态(锁的升级,单向不可逆)。

轻量级锁在无竞争的情况下使用CAS操作去消除同步使用的互斥量

1.代码进入同步块的时候,若锁对象没有被锁定。

2.虚拟机首先在栈帧中建立一个名为锁记录(Lock Record)的空间,存储锁对象的 Mark World 的拷贝;

3.虚拟机使用CAS操作将对象的 Mark World 更新为指向 Lock Record 的指针;

4.若这个CAS操作成功,则此对象处于轻量级锁定状态;

5.若这个CAS操作失败,则检查对象的 Mark World 是否已经指向当前线程栈帧中的 Lock Record,

6.若已经指向,则表明当前线程拥有该对象的锁,继续执行,否则膨胀为重量级锁。

重量级锁 使用操作系统互斥量(mutex)来实现的传统锁。 当所有对锁的优化都失效时,将退回到重量级锁。它与轻量级锁不同竞争的线程不再通过自旋来竞争线程, 而是直接进入堵塞状态,此时不消耗CPU,然后等拥有锁的线程释放锁后,唤醒堵塞的线程, 然后线程再次竞争锁。但是注意,当锁膨胀(inflate)为重量锁时,就不能再退回到轻量级锁。
优点缺点适用场景
偏向锁加锁和解锁不需要额外的消耗,与执行非同步方法仅存在纳秒级的差距如果线程间存在竞争,会带来额外的锁撤销的消耗适用于只有一个线程访问同步块的情况
轻量级锁竞争的线程不会堵塞,提高了程序的响应速度始终得不到锁的线程,使用自旋会消耗CPU追求响应时间,同步块执行速度非常块,只有两个线程竞争锁
重量级锁线程竞争不使用自旋,不会消耗CPU线程堵塞,响应时间缓慢追求吞吐量,同步块执行速度比较慢,竞争锁的线程大于2个

 

 

  • 3
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Java分布式实现方式有多种,常见的包括: 1. 基于Redis的分布式:利用Redis单线程的特性,使用SETNX命令创建,利用EXPIRE设置的过期时间,同时使用DEL命令释放,确保的释放是原子的。 2. 基于Zookeeper的分布式:通过创建临时节点实现分布式,当某个服务占用了,其它服务将无法创建同名节点,从而保证同一时间只有一个服务占用该。 3. 基于数据库的分布式:使用数据库表中的一行记录来表示状态,使用事务确保的获取和释放是原子的。 4. 基于Redisson的分布式:Redisson是一个开源的Java分布式框架,提供了对分布式的支持,使用SETNX和EXPIRE命令实现的创建和过期,同时还提供了自旋、可重入等高级特性。 以上是Java分布式实现方式的几种常见方式,不同的实现方式有着各自的特点和适用场景,需要根据实际需求进行选择。 ### 回答2: Java分布式是分布式系统中实现数据同步和控制的关键技术之一,它用于保证多个分布式进程并发访问共享资源时的数据一致性和安全性。分布式与普通的相比,需要解决跨进程、跨节点的同步和并发控制问题。 Java分布式实现方式有以下几种: 1. 基于Zookeeper实现分布式 Zookeeper是一个高性能的分布式协调服务,它可以被用来实现分布式。Zookeeper的实现原理是基于它的强一致性和顺序性,可以保证多个进程访问同一个分布式时的数据同步和控制。 通过创建一个Zookeeper的持久节点来实现分布式,使用create()方法来创建节点,如果创建成功则说明获取成功。当多个进程同时请求获取时,只有一个进程能够创建节点成功,其它进程只能等待。当持有分布式的进程退出时,Zookeeper会自动删除对应的节点,其它进程就可以继续请求获取。 2. 基于Redis实现分布式 Redis是高性能的内存数据库,可以使用它的setnx()命令来实现分布式。setnx()命令可以在指定的key不存在时设置key的值,并返回1;如果key已经存在,则返回0。通过这个原子性的操作来实现分布式。 当多个进程同时请求获取时,只有一个进程能够成功执行setnx()命令,其它进程只能等待。进程在持有期间,可以利用Redis的expire()命令来更新的过期时间。当持有分布式的进程退出时,可以通过delete()命令来删除。 3. 基于数据库实现分布式 数据库通过ACID特性来保证数据的一致性、并发性和可靠性,可以通过在数据库中创建一个唯一索引来实现分布式。当多个进程同时请求获取时,只有一个进程能够成功插入唯一索引,其它进程只能等待。当持有分布式的进程退出时,可以通过删除索引中对应的记录来释放。 不同的实现方式各有优劣。基于Zookeeper的实现方式可以保证分布式的一致性和可靠性,但是需要引入额外的依赖;基于Redis可以实现较高性能的分布式,但是在高并发条件下可能会存在死等问题;基于数据库的实现方式简单,但在高并发条件下也可能会有争抢等问题。 总之,在选择分布式实现方式时,需要根据业务场景和需求来综合考虑各种因素,选择最适合自己的方式。 ### 回答3: 分布式系统中的并发控制是解决分布式系统中竞争资源的重要问题之一,而分布式作为一种并发控制工具,在分布式系统中被广泛采用。Java作为一种常用的编程语言,在分布式实现方面也提供了多种解决方案。下面就分别介绍Java分布式实现方式。 1. 基于ZooKeeper的分布式 ZooKeeper是分布式系统中常用的协调工具,其提供了一套完整的API用于实现分布式实现分布式的过程中需要创建一个Znode,表示,同时用于控制数据的访问。在这个Znode上注册监听器用于接收释放的成功/失败事件,从而控制加/解的过程。 2. 基于Redis的分布式 Redis作为一种高性能的Key-Value数据库,其提供了完整的API用于实现分布式实现分布式的过程中需要在Redis中创建一个Key,利用Redis的SETNX命令进行加,同时设置过期时间保证的生命周期。在解时需要判断是否持有并删除对应的Key。 3. 基于数据库的分布式 数据库作为分布式系统中常用的数据存储方式,其提供了事务机制用于实现分布式。在实现分布式的过程中需要在数据库中创建一个表,利用数据库的事务机制实现/解,同时需要设置过期时间保证的生命周期。 总之,以上三种方式都是常用的Java分布式实现方式。选择合适的方法需要综合考虑的使用场景、性能需求、可靠性要求等因素。同时,在实现分布式的过程中需要注意的加/解的正确性和过期时间的设置,保证分布式系统的并发控制的正确性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值