小编Bas*_*ers的帖子

我有一个问题,我找到一个干净的解决方案的麻烦.我会尽量详细解释.

我有一个树状的结构:

NODE A
    NODE A.1
    NODE A.2
        NODE A.2.a
        NODE A.2.b
    NODE A.3
        NODE A.3.a
        NODE A.3.b
        NODE A.3.c
NODE B
    NODE B.1
    NODE B.2

我需要处理根节点:

 public void process(final Node node) { ... }

节点的过程涉及两件事:

- some database queries
- the process of all children of these nodes

换言之,一旦NODE.2.a与NODE.2.b被处理,NODE.2都可以加工.我以递归的方式处理节点,没什么了不起的.

到现在为止还挺好.现在我想声明一个具有固定线程数的全局执行程序服务.我想并行处理节点的子节点.所以,NODE.2.a并且NODE.2.b可以在自己的线程中进行处理.代码看起来像这样:

// global executor service, shared between all process(Node) calls
final ExecutorService service = Executors.newFixedThreadPool(4);

public void process(final Node node) …

我无法理解以下内容。我有一个字段和一些值：

Field<T> field = ...;
List<T> values = ...;

现在，我想field = ANY({... the values ....})在WHERE子句中表达过滤器。PostgreSQL 支持该ANY(array of values)运算符。我从https://blog.jooq.org/2017/03/30/sql-in-predicate-with-in-list-or-with-array-which-is-faster/得到这个想法。

我尝试了以下方法来创造条件：

field.equal(PostgresDSL.any(PostgresDSL.array(values)));

上面的方法不起作用。这编译：

field.equal((QuantifiedSelect) PostgresDSL.any(PostgresDSL.array(values)));

第一个问题：为什么需要额外的演员阵容？API 是否应该更改？我不确定泛型错误实际上是在哪一边（我的还是 jOOQ 的）。

但是，进行此更改后，查询本身无法正常工作。它给出了错误：

org.jooq.exception.SQLDialectNotSupportedException: Type class java.util.ArrayList is not supported in dialect DEFAULT

第二个问题：如何声明/创建值数组？上面的调用PostgresDSL.array(...)回落到DSL.array(...)，这可能是第二个问题的根源？

我可以通过提供代码片段来解释我的问题:

public static void main(final String[] a) {
    Stream.of(1, 2, 3, 4).map(i -> ForkJoinPool.commonPool().submit(new RecursiveAction() {
        @Override
        protected void compute() {
            System.out.println(Thread.currentThread());
        }
    })).forEach(ForkJoinTask::join);
}

在我的笔记本电脑上运行时,它有4个核心,这打印:

Thread[main,5,main]
Thread[ForkJoinPool.commonPool-worker-1,5,main]
Thread[main,5,main]
Thread[ForkJoinPool.commonPool-worker-1,5,main]

为什么某些任务在主线程中运行,主线程是公共fork连接线程池之外的线程？

创建自定义fork join线程池时,不会发生这种情况:

public static void main(final String[] a) {
    final ForkJoinPool p = new ForkJoinPool(4);

    Stream.of(1, 2, 3, 4).map(index -> p.submit(new RecursiveAction() {
        @Override
        protected void compute() {
            System.out.println(Thread.currentThread());
        }
    })).forEach(ForkJoinTask::join);
}

Thread[ForkJoinPool-1-worker-1,5,main]
Thread[ForkJoinPool-1-worker-1,5,main]
Thread[ForkJoinPool-1-worker-1,5,main]
Thread[ForkJoinPool-1-worker-1,5,main]

那么,换句话说,公共池有什么特别之处？提供这些知识,在公共池中执行长时间运行的任务是明智的还是不明智的想法？