小编Lav*_*ari的帖子

我正在尝试Java中的并行流,为此,我有以下代码来计算以前的素数n.

基本上我有两种方法

• calNumberOfPrimes(long n) - 4种不同的变种
• isPrime(long n) - 2种不同的变种

实际上我有上述每种方法的两种不同变体,一种是使用并行流的变体,另一种是不使用并行流的变体.

    // itself uses parallel stream and calls parallel variant isPrime
    private static long calNumberOfPrimesPP(long n) {
        return LongStream
                .rangeClosed(2, n)
                .parallel()
                .filter(i -> isPrimeParallel(i))
                .count();
    }

    // itself uses parallel stream and calls non-parallel variant isPrime
    private static long calNumberOfPrimesPNP(long n) {
        return LongStream
                .rangeClosed(2, n)
                .parallel()
                .filter(i -> isPrimeNonParallel(i))
                .count();
    }

    // itself uses non-parallel stream and calls parallel variant isPrime
    private static long calNumberOfPrimesNPP(long n) …

我是 JCStress 的新手，我正在尝试为 JCStress 运行“hello world”，但面临一些问题。我认为我缺少一些明显的东西。

我正在按照此链接进行学习。我正在尝试的示例在这里。

我从以下公共 Maven 原型创建的模板项目开始：

mvn archetype:generate "-DinteractiveMode=false" "-DarchetypeGroupId=org.openjdk.jcstress" "-DarchetypeArtifactId=jcstress-java-test-archetype" "-DarchetypeVersion=0.4" "-DgroupId=org.sample" "-DartifactId=test" "-Dversion=1.0"

我做了一个mvn clean install并得到了.\target\jcstress.jar. 我添加了MyConcurrencyTest包中包含以下代码org.sample

package org.sample;

import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.I_Result;


@JCStressTest
@Outcome(id = "1", expect = Expect.ACCEPTABLE_INTERESTING, desc = "One update lost: atomicity failure.")
@Outcome(id = "2", expect = Expect.ACCEPTABLE, desc = "Actors updated independently.")
@State
public class MyConcurrencyTest {

    int v;

    @Actor
    public void actor1() {
        v++;
    }

    @Actor …

我正在阅读这篇文章,我无法真正理解最终化对象(覆盖该finalize方法的对象)在回收之前至少需要2个GC周期.

在可回收可完成对象之前,它至少需要两次垃圾收集周期(在最好的情况下).

有人还可以详细解释一个可终结的对象如何可以采用多个GC循环进行回收？

我的逻辑论点是,当我们覆盖finalize方法时,运行时必须使用垃圾收集器注册此对象(以便GC可以调用finalize此对象,这使我认为GC将引用所有可终结的对象).为此,GC必须对可终结对象保持强有力的参考.如果是这种情况,那么该对象如何成为GC首先进行回收的候选对象？我通过这个理论达成了矛盾.

PS:我知道覆盖finalize不是推荐的方法,并且自Java 9以来不推荐使用此方法.

从这里开始，JGraphT 的Pair类是Serializable。但该类包含的实例成员（first和second）不是强制的Serializable。

当前的实现如下所示：

public class Pair<A, B>
    implements
    Serializable

我认为应该是这样的：

public class Pair<A extends Serializable, B extends Serializable>
    implements
    Serializable

我错过了什么吗？如果不是，那么为什么 JGraphT 不这样做呢？

我想将转换List<String>为IntStream。假设我的清单是["abc", "de", "fghi"]。然后IntStream，我要像1,1,1,2,2,3,3,3,3。（一些出现的次数i在IntStream取决于长度i个串中的给定的列表）

为此，我编写了以下方法（它将不会编译）：

private static IntStream getSingleIntStream(List<String> list) {
    final AtomicInteger atomicInteger = new AtomicInteger();
    return list.stream()
            .map(str -> {
                        atomicInteger.incrementAndGet();
                        return IntStream.range(0, str.length())
                                .map(i -> atomicInteger.get());
                    }); // Now I don't understand how can I convert this Stream<IntStream> to a single IntStream 

}

但是我不明白如何将a转换Stream<IntStream>为单个IntStream。（我的猜测是我们可以flatMap以某种方式使用，但我不完全了解如何使用它。）

我使用IntStream而不是Stream<Integer>避免自动装箱，并使我的整个系统更高效。