Upstream/Minestom
1
0
Fork 0
mirror of https://github.com/Minestom/Minestom.git synced 2024-06-24 13:34:53 +02:00
Code Issues Projects Releases Wiki Activity

Acquirable style cleanup

Browse Source 
Signed-off-by: TheMode <themode@outlook.fr>
This commit is contained in:
TheMode 2021-09-09 17:16:20 +02:00
parent 1c719a2fd7
commit acb8634b4b
3 changed files with 24 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/main/java/net/minestom/server/acquirable/Acquirable.java
View File

@ -8,7 +8,6 @@ import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
import java.util.Collection;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.Stream;
@ -85,7 +84,7 @@ public interface Acquirable<T> {
* @see #sync(Consumer) for auto-closeable capability
*/
default @NotNull Acquired<T> lock() {
var optional = local();
final Optional<T> optional = local();
return optional.map(Acquired::local).orElseGet(() -> Acquired.locked(this));
}
@ -100,11 +99,8 @@ public interface Acquirable<T> {
* {@link Optional#empty()} otherwise
*/
default @NotNull Optional<T> local() {
final Thread currentThread = Thread.currentThread();
final TickThread tickThread = getHandler().getTickThread();
if (Objects.equals(currentThread, tickThread)) {
if (Thread.currentThread() == getHandler().getTickThread())
return Optional.of(unwrap());
}
return Optional.empty();
}
@ -117,7 +113,7 @@ public interface Acquirable<T> {
* @see #async(Consumer)
*/
default void sync(@NotNull Consumer<T> consumer) {
var acquired = lock();
Acquired<T> acquired = lock();
consumer.accept(acquired.get());
acquired.unlock();
}
@ -153,8 +149,7 @@ public interface Acquirable<T> {
@ApiStatus.Internal
@NotNull Handler getHandler();
class Handler {
final class Handler {
private volatile ThreadProvider.ChunkEntry chunkEntry;
public ThreadProvider.ChunkEntry getChunkEntry() {
@ -167,8 +162,8 @@ public interface Acquirable<T> {
}
public TickThread getTickThread() {
return chunkEntry != null ? chunkEntry.getThread() : null;
final ThreadProvider.ChunkEntry entry = this.chunkEntry;
return entry != null ? entry.getThread() : null;
}
}
}

38
src/main/java/net/minestom/server/acquirable/AcquirableImpl.java
View File

@ -10,10 +10,9 @@ import java.util.Collections;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReentrantLock;
class AcquirableImpl<T> implements Acquirable<T> {
protected static final ThreadLocal<Collection<ThreadProvider.ChunkEntry>> ENTRIES = ThreadLocal.withInitial(Collections::emptySet);
protected static final AtomicLong WAIT_COUNTER_NANO = new AtomicLong();
final class AcquirableImpl<T> implements Acquirable<T> {
static final ThreadLocal<Collection<ThreadProvider.ChunkEntry>> ENTRIES = ThreadLocal.withInitial(Collections::emptySet);
static final AtomicLong WAIT_COUNTER_NANO = new AtomicLong();
/**
* Global lock used for synchronization.
@ -38,30 +37,23 @@ class AcquirableImpl<T> implements Acquirable<T> {
return handler;
}
protected static @Nullable ReentrantLock enter(@Nullable Thread currentThread, @Nullable TickThread elementThread) {
static @Nullable ReentrantLock enter(@Nullable Thread currentThread, @Nullable TickThread elementThread) {
// Monitoring
long time = System.nanoTime();
final long time = System.nanoTime();
ReentrantLock currentLock;
{
final TickThread current = currentThread instanceof TickThread ?
(TickThread) currentThread : null;
currentLock = current != null && current.getLock().isHeldByCurrentThread() ?
current.getLock() : null;
final ReentrantLock lock = currentThread instanceof TickThread ?
((TickThread) currentThread).getLock() : null;
currentLock = lock != null && lock.isHeldByCurrentThread() ? lock : null;
}
if (currentLock != null)
currentLock.unlock();
if (currentLock != null) currentLock.unlock();
GLOBAL_LOCK.lock();
if (currentLock != null) currentLock.lock();
if (currentLock != null)
currentLock.lock();
final var lock = elementThread != null ? elementThread.getLock() : null;
final ReentrantLock lock = elementThread != null ? elementThread.getLock() : null;
final boolean acquired = lock == null || lock.isHeldByCurrentThread();
if (!acquired) {
lock.lock();
}
if (!acquired) lock.lock();
// Monitoring
AcquirableImpl.WAIT_COUNTER_NANO.addAndGet(System.nanoTime() - time);
@ -69,10 +61,8 @@ class AcquirableImpl<T> implements Acquirable<T> {
return !acquired ? lock : null;
}
protected static void leave(@Nullable ReentrantLock lock) {
if (lock != null) {
lock.unlock();
}
static void leave(@Nullable ReentrantLock lock) {
if (lock != null) lock.unlock();
GLOBAL_LOCK.unlock();
}
}

11
src/main/java/net/minestom/server/acquirable/Acquired.java
View File

@ -6,8 +6,7 @@ import org.jetbrains.annotations.NotNull;
import java.util.concurrent.locks.ReentrantLock;
public class Acquired<T> {
public final class Acquired<T> {
private final T value;
private final boolean locked;
@ -15,11 +14,11 @@ public class Acquired<T> {
private boolean unlocked;
protected static <T> Acquired<T> local(@NotNull T value) {
static <T> Acquired<T> local(@NotNull T value) {
return new Acquired<>(value, false, null, null);
}
protected static <T> Acquired<T> locked(@NotNull Acquirable<T> acquirable) {
static <T> Acquired<T> locked(@NotNull Acquirable<T> acquirable) {
final Thread currentThread = Thread.currentThread();
final TickThread tickThread = acquirable.getHandler().getTickThread();
return new Acquired<>(acquirable.unwrap(), true, currentThread, tickThread);
@ -40,13 +39,11 @@ public class Acquired<T> {
public void unlock() {
checkLock();
this.unlocked = true;
if (!locked)
return;
if (!locked) return;
AcquirableImpl.leave(lock);
}
private void checkLock() {
Check.stateCondition(unlocked, "The acquired element has already been unlocked!");
}
}