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的尝试都会抛出{ {1}}。（最有可能的是，调用可以抛出SecurityException的任何方法，将抛出。）

我理解SecurityException意味着它将在另一个可能与我们开始时没有相同特权的线程中运行，但我想我认为框架会为我们处理这个问题。

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

Answer 1

并行流执行将使用Fork / Join框架，更具体地说，它将使用Fork / Join公共池。这是一个实现细节，但在这种情况下观察到这些细节可能会以意想不到的方式泄露出来。

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

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

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

java.lang.SecurityException：无法创建临时文件或目录

有两种潜在的解决方法。根据安全管理员使用的原因，每次解决可能会增加不安全的风险。

第一个更通用的解决方法是通过系统属性注册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中的doPrivileged方法提供生成的上下文对象Consumer，您正在重新建立上下文，换句话说，PrivilegedAction将具有与您的相同的权限单线程场景。

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

2 个答案: