Hibernate/hibernate-orm
1
0
Fork 0
mirror of https://github.com/hibernate/hibernate-orm synced 2025-02-09 12:44:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

HHH-17005 - Replace monitor with a Java lock to avoid pinning when using virtual threads

Browse Source 
This commit replaces a `synchronized` with a ReentrantLock in:

- PooledOptimizer
- PooledLoOptimizer
- LegacyHiLoAlgorithmOptimizer
- HiLoOptimizer

The other implementations do not use a monitor lock.
This commit is contained in:
Clement Escoffier 2023-07-27 10:15:50 +02:00 committed by Sanne Grinovero
parent d825801f0d
commit 71cb3477ca
4 changed files with 147 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
hibernate-core/src/main/java/org/hibernate/id/enhanced/HiLoOptimizer.java
View File

@ -9,6 +9,8 @@
import java.io.Serializable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.hibernate.HibernateException;
import org.hibernate.id.IntegralDataTypeHolder;
@ -80,7 +82,9 @@ public HiLoOptimizer(Class<?> returnClass, int incrementSize) {
}
@Override
public synchronized Serializable generate(AccessCallback callback) {
public Serializable generate(AccessCallback callback) {
lock.lock();
try {
final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() );
if ( generationState.lastSourceValue == null ) {
@ -102,7 +106,15 @@ else if ( ! generationState.upperLimit.gt( generationState.value ) ) {
}
return generationState.value.makeValueThenIncrement();
}
finally {
lock.unlock();
}
}
/**
* Use a lock instead of the monitor lock to avoid pinning when using virtual threads.
*/
private final Lock lock = new ReentrantLock();
private GenerationState noTenantState;
private Map<String,GenerationState> tenantSpecificState;
@ -139,9 +151,15 @@ private GenerationState noTenantGenerationState() {
}
@Override
public synchronized IntegralDataTypeHolder getLastSourceValue() {
public IntegralDataTypeHolder getLastSourceValue() {
lock.lock();
try {
return noTenantGenerationState().lastSourceValue;
}
finally {
lock.unlock();
}
}
@Override
public boolean applyIncrementSizeToSourceValues() {
@ -155,9 +173,15 @@ public boolean applyIncrementSizeToSourceValues() {
*
* @return Value for property 'lastValue'.
*/
public synchronized IntegralDataTypeHolder getLastValue() {
public IntegralDataTypeHolder getLastValue() {
lock.lock();
try {
return noTenantGenerationState().value.copy().decrement();
}
finally {
lock.unlock();
}
}
/**
* Getter for property 'upperLimit'.
@ -166,7 +190,13 @@ public synchronized IntegralDataTypeHolder getLastValue() {
*
* @return Value for property 'upperLimit'.
*/
public synchronized IntegralDataTypeHolder getHiValue() {
public IntegralDataTypeHolder getHiValue() {
lock.lock();
try {
return noTenantGenerationState().upperLimit;
}
finally {
lock.unlock();
}
}
}

31
hibernate-core/src/main/java/org/hibernate/id/enhanced/LegacyHiLoAlgorithmOptimizer.java
View File

@ -9,6 +9,8 @@
import java.io.Serializable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.hibernate.HibernateException;
import org.hibernate.id.IntegralDataTypeHolder;
@ -53,7 +55,9 @@ public LegacyHiLoAlgorithmOptimizer(Class<?> returnClass, int incrementSize) {
}
@Override
public synchronized Serializable generate(AccessCallback callback) {
public Serializable generate(AccessCallback callback) {
lock.lock();
try {
final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() );
if ( generationState.lo > generationState.maxLo ) {
@ -64,7 +68,16 @@ public synchronized Serializable generate(AccessCallback callback) {
generationState.value = generationState.hi.copy().add( generationState.lo++ );
return generationState.value.makeValue();
}
finally {
lock.unlock();
}
}
/**
* Use a lock instead of the monitor lock to avoid pinning when using virtual threads.
*/
private final Lock lock = new ReentrantLock();
private GenerationState noTenantState;
private Map<String,GenerationState> tenantSpecificState;
@ -108,9 +121,15 @@ private GenerationState noTenantGenerationState() {
}
@Override
public synchronized IntegralDataTypeHolder getLastSourceValue() {
public IntegralDataTypeHolder getLastSourceValue() {
lock.lock();
try {
return noTenantGenerationState().lastSourceValue.copy();
}
finally {
lock.unlock();
}
}
@Override
public boolean applyIncrementSizeToSourceValues() {
@ -124,7 +143,13 @@ public boolean applyIncrementSizeToSourceValues() {
*
* @return Value for property 'lastValue'.
*/
public synchronized IntegralDataTypeHolder getLastValue() {
public IntegralDataTypeHolder getLastValue() {
lock.lock();
try {
return noTenantGenerationState().value;
}
finally {
lock.unlock();
}
}
}

14
hibernate-core/src/main/java/org/hibernate/id/enhanced/PooledLoOptimizer.java
View File

@ -9,6 +9,8 @@
import java.io.Serializable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Lock;
import org.hibernate.HibernateException;
import org.hibernate.id.IntegralDataTypeHolder;
@ -53,7 +55,9 @@ public PooledLoOptimizer(Class<?> returnClass, int incrementSize) {
}
@Override
public synchronized Serializable generate(AccessCallback callback) {
public Serializable generate(AccessCallback callback) {
lock.lock();
try {
final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() );
if ( generationState.lastSourceValue == null
@ -68,7 +72,15 @@ public synchronized Serializable generate(AccessCallback callback) {
}
return generationState.value.makeValueThenIncrement();
}
finally {
lock.unlock();
}
}
/**
* Use a lock instead of the monitor lock to avoid pinning when using virtual threads.
*/
private final Lock lock = new ReentrantLock();
private GenerationState noTenantState;
private Map<String,GenerationState> tenantSpecificState;

14
hibernate-core/src/main/java/org/hibernate/id/enhanced/PooledOptimizer.java
View File

@ -9,6 +9,8 @@
import java.io.Serializable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.hibernate.HibernateException;
import org.hibernate.id.IntegralDataTypeHolder;
@ -65,7 +67,9 @@ public PooledOptimizer(Class<?> returnClass, int incrementSize) {
@Override
public synchronized Serializable generate(AccessCallback callback) {
public Serializable generate(AccessCallback callback) {
lock.lock();
try {
final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() );
if ( generationState.hiValue == null ) {
@ -94,7 +98,15 @@ else if ( generationState.value.gt( generationState.hiValue ) ) {
return generationState.value.makeValueThenIncrement();
}
finally {
lock.unlock();
}
}
/**
* Use a lock instead of the monitor lock to avoid pinning when using virtual threads.
*/
private final Lock lock = new ReentrantLock();
private GenerationState noTenantState;
private Map<String,GenerationState> tenantSpecificState;