来自并行流中 I/O 代码的 SecurityException

Question

这个我没办法解释，但是我在别人的代码中发现了这个现象：

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.util.stream.Stream;

import org.junit.Test;

public class TestDidWeBreakJavaAgain
{
    @Test
    public void testIoInSerialStream()
    {
        doTest(false);
    }

    @Test
    public void testIoInParallelStream()
    {
        doTest(true);
    }

    private void doTest(boolean parallel)
    {
        Stream<String> stream = Stream.of("1", "2", "3");
        if (parallel)
        {
            stream = stream.parallel();
        }
        stream.forEach(name -> {
            try
            {
                Files.createTempFile(name, ".dat");
            }
            catch (IOException e)
            {
                throw new UncheckedIOException("Failed to create temp file", e);
            }
        });
    }
}

当运行启用安全管理器时，仅在流上调用 parallel()，或从集合中获取流时调用 parallelStream()，似乎可以保证所有尝试执行I/O 将抛出 SecurityException。（最有可能的是，调用任何可以抛出 SecurityException 的方法，将抛出。）

我知道 parallel() 意味着它会运行在另一个线程中运行，该线程可能与我们开始的线程没有相同的权限，但我想我认为框架会帮我们处理一下。

在整个代码库中删除对 parallel() 或 parallelStream() 的调用可以避免风险。插入 AccessController.doPrivileged 也可以修复它，但对我来说听起来并不安全，至少在所有情况下都不安全。还有其他选择吗？

Answer 1

并行流执行将使用 Fork/Join 框架，更具体地说，它将使用 Fork/Join 公共池。这是一个实现细节，但正如在本例中观察到的那样，这些细节可能会以意想不到的方式泄露出去。

请注意，使用 CompletableFuture 异步执行任务时也会发生相同的行为。

当存在安全管理器时，Fork/Join 公共池的线程工厂被设置为创建无害线程的工厂。这样一个 无害的 线程没有被授予任何权限，不是任何定义的线程组的成员，并且在顶级 Fork/Join 任务完成其执行后所有线程本地（如果创建）被清除。这种行为确保 Fork/Join 任务在共享公共池时相互隔离。

这就是为什么在示例中抛出 SecurityException 的原因，可能是：

java.lang.SecurityException: Unable to create temporary file or directory

有两种可能的解决方法。根据安全经理使用的原因，每个解决方法都可能增加不安全的风险。

第一个更通用的解决方法是通过系统属性注册一个 Fork/Join 线程工厂来告诉 Fork/Join 框架默认的线程工厂应该是什么公共游泳池。例如这里是一个非常简单的线程工厂：

public class MyForkJoinWorkerThreadFactory
        implements ForkJoinPool.ForkJoinWorkerThreadFactory {
    public final ForkJoinWorkerThread newThread(ForkJoinPool pool) {
        return new ForkJoinWorkerThread(pool) {};
    }
}

可以注册以下系统属性:

-Djava.util.concurrent.ForkJoinPool.common.threadFactory=MyForkJoinWorkerThreadFactory

MyForkJoinWorkerThreadFactory 的行为目前等同于 ForkJoinPool.defaultForkJoinWorkerThreadFactory.

第二个更具体的解决方法是创建一个新的 Fork/Join 池。在这种情况下，ForkJoinPool.defaultForkJoinWorkerThreadFactory 将用于不接受 ForkJoinWorkerThreadFactory 参数的构造函数。任何并行流执行都需要从该池中执行的任务中执行。请注意，这是一个实现细节，在未来的版本中可能会也可能不会。

Answer 2

你担心AccessController.doPrivileged是不必要的。它不会降低安全性如果做得对。采用单个操作参数的版本将在您的上下文中执行操作，忽略您的调用者但有重载方法，有一个额外的参数，一个先前记录的上下文：

private void doTest(boolean parallel)
{
    Consumer<String> createFile=name -> {
        try {
            Files.createTempFile(name, ".dat");
        }
        catch (IOException e) {
            throw new UncheckedIOException("Failed to create temp file", e);
        }
    }, actualAction;
    Stream<String> stream = Stream.of("1", "2", "3");

    if(parallel)
    {
        stream = stream.parallel();
        AccessControlContext ctx=AccessController.getContext();
        actualAction=name -> AccessController.doPrivileged(
          (PrivilegedAction<?>)()->{ createFile.accept(name); return null; }, ctx);
    }
    else actualAction = createFile;

    stream.forEach(actualAction);
}

第一行重要的是 AccessControlContext ctx=AccessController.getContext(); 语句，它记录了您当前的安全上下文，其中包括您的代码和当前调用者。（请记住，有效权限是所有调用者集合的交集）。通过将生成的上下文对象 ctx 提供给 Consumer 中的 doPrivileged 方法，您正在重新建立上下文，换句话说，PrivilegedAction 将具有与您的相同的权限单线程场景。

来自并行流中 I/O 代码的 SecurityException

SecurityException from I/O code in a parallel stream

java

parallel-processing

securitymanager

java-8

java-stream