主页 / user-1343979

Bass's questions

Martin Hope
Bass
Asked: 2025-02-08 01:40:45 +0800 CST
  • 7

请考虑以下用 Kotlin 编写的 DCL 示例：

@Volatile
private var property: String? = null

private val lock = ReentrantLock()

fun singletonValue(): String {
    if (property == null) {
        lock.withLock {
            if (property == null) {
                property = "Hello World"
            }
        }
    }
    return property!!
}

它与二十年前讨论的 Java 对应部分非常相似，当时 Java 内存模型随着从 Java 1.4 到 Java 5 的过渡而得到修正。话虽如此，我完全确信上述代码片段在 JVM 上运行时会正常运行。

现在，让我们用lateinit var：

@Volatile
private lateinit var property: String

private val lock = ReentrantLock()

fun singletonValue(): String {
    if (!::property.isInitialized) {
        lock.withLock {
            if (!::property.isInitialized) {
                property = "Hello World"
            }
        }
    }
    return property
}

它在语义上与原始示例等同吗？它是否保持相同的原子性和可见性保证？

multithreading
Martin Hope
Bass
Asked: 2024-12-06 19:52:11 +0800 CST
  • 5

假设我有多个字符串值（动态生成）和一个线程池，并且我希望每个字符串值在任何时候都最多由一个线程独占。因此，例如，如果字符串“foo”在某个时间段被线程T1锁定，则等待处理“foo”（或任何其他等于“foo”的字符串Object.equals()）的所有其他线程都必须等到线程T1释放锁定。

所以我想实现以下接口：

interface Lock { 
    void lock(@NonNull String key); 

    void unlock(@NonNull String key); 
}

正如我所说的，如果密钥已被其他线程锁定，则进入该方法的任何线程都lock(String)应该等待（或可中断地等待，或超时等待）。

并且该unlock(String)方法应该有效地解锁密钥，在两种情况下抛出异常：

  1. 每当尝试解锁未锁定的钥匙时
  2. 每当尝试解锁由其他线程（不是当前线程）锁定的密钥时。

显然，在实现上述接口时，我必须将一个ReentrantLock实例与任何即将被锁定的键关联起来，并且在整个过程中它都保持锁定状态。

我该如何实现LockByKey接口？java.util.concurrent包中的哪些并发原语最适合此任务？

java
Martin Hope
Bass
Asked: 2024-11-15 21:04:34 +0800 CST
  • 6

假设我ExecutorService在守护线程池上有一个操作（这样我不需要明确关闭它）：

final var executor = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors(),
        r -> {
            final var t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
);

— 我想Future在一定超时后取消一项长时间运行的任务：

final var future = executor.submit(() -> {
    try {
        TimeUnit.SECONDS.sleep(Long.MAX_VALUE);
        return "42";
    } catch (final InterruptedException ie) {
        System.out.println("Task cancelled.");
        throw ie;
    }
});

try {
    System.out.println(future.get(5L, TimeUnit.SECONDS));
} catch (final TimeoutException ignored) {
    System.out.println("Timed out, cancelling...");
    future.cancel(true);
}

运行时，此代码将在大约 5 秒内产生以下输出：

Timed out, cancelling...
Task cancelled.

这意味着当前运行任务的线程确实会被中断，并且Thread.sleep()会抛出一个InterruptedException。现在，假设我想改用CompletableFutureAPI。以下是语义上相同的代码：

final var future = CompletableFuture.supplyAsync(() -> {
    try {
        TimeUnit.SECONDS.sleep(Long.MAX_VALUE);
        return "42";
    } catch (final InterruptedException ie) {
        System.out.println("Task cancelled.");
        throw new RuntimeException(ie);
    }
}, executor);

或者说我是这么想的。然而，第二版代码只会产生以下输出：

Timed out, cancelling...

后台执行线程将继续运行 Thread.sleep()，而不会被打断，因此这两个版本的代码在语义上并不相同。

同样，如果我调用future.orTimeout(timeout, unit)而不是future.get(timeout, unit)，后台线程也不会被中断。后台线程将继续运行（可能）计算量大的任务，直到 JVM 关闭，而且似乎没有办法中断它们。

中断后台线程的唯一方法是调用executor.shutdownNow()（仅仅这样executor.shutdown()做是不够的），但这当然不是一个解决方案，因为我想在任务取消后重用执行器。

问题：

  1. 如何取消CompletableFuture 并中断相应的工作线程，以及
  2. 这种行为有记录吗？

编辑：有一个类似的问题：如何取消 Java 8 可完成的未来？

java