代码之家  ›  专栏  ›  技术社区  ›  tsolakp

Java流映射中可重用的单实例包装器/对象

java-stream java-8 java
  •  -1
  • tsolakp  · 技术社区  · 7 年前

    不管怎样,我想知道社区是怎么想的 Stream.map 像这样的用例? 

    Wrapper wrapper = new Wrapper();
list.stream()
    .map( s -> {
        wrapper.setSource(s);
        return wrapper;
    } )
    .forEach( w -> processWrapper(w) );
    
public static class Source {
    private final String name;
        
    public Source(String name) {
        this.name = name;
    }
        
    public String getName() {
        return name;
    }
}
    
public static class Wrapper {
    private Source source = null;
        
    public void setSource(Source source) {
        this.source = source;
    }
        
    public String getName() {
        return source.getName();
    }
}

public void processWrapper(Wrapper wrapper) {
}

    我不太喜欢这种用法 map 但在处理大型流时,它可能有助于提高性能,并避免产生不必要的错误 Wrapper Source .

    这肯定有它的局限性,比如对于并行流和终端操作几乎没有用处 collect .

    更新- forEach 元素。

    基准测试结果

    可重复使用包装的折叠改进-

    BenchmarkTest.noReuse 10000000平均5 870.253 ± 122.495毫秒/次

    BenchmarkTest.withReuse 10000000平均5 ± 2.528毫秒/次

    基准代码- 

    import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
@Fork(value = 2, jvmArgs = {"-Xms2G", "-Xmx2G"})
public class BenchmarkTest {

    @Param({"10000000"})
    private int N;

    private List<Source> data;

    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
            .include(BenchmarkTest.class.getSimpleName())
            .forks(1)
            .build();
        new Runner(opt).run();
    }

    @Setup
    public void setup() {
        data = createData();
    }

    @Benchmark
    public void noReuse(Blackhole bh) {
        data.stream()
            .map( s -> new Wrapper1( s.getName() ) )
            .forEach( t -> processTarget(bh, t) );
    }

    @Benchmark
    public void withReuse(Blackhole bh) {
        Wrapper2 wrapper = new Wrapper2();
        data.stream()
            .map( s -> { wrapper.setSource(s); return wrapper; } )
            .forEach( w -> processTarget(bh, w) );
    }
    
    public void processTarget(Blackhole bh, Wrapper t) {
        bh.consume(t);
    }
    
    private List<Source> createData() {
        List<Source> data = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            data.add( new Source("Number : " + i) );
        }
        return data;
    }
    
    public static class Source {
        private final String name;

        public Source(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    public interface Wrapper {
        public String getName();
    }
    
    public static class Wrapper1 implements Wrapper {
        private final String name;

        public Wrapper1(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }
    
    public static class Wrapper2 implements Wrapper {
        private Source source = null;

        public void setSource(Source source) {
            this.source = source;
        }

        public String getName() {
            return source.getName();
        }
    }
}

    完整基准报告- 

    # JMH version: 1.21
# VM version: JDK 1.8.0_191, Java HotSpot(TM) 64-Bit Server VM, 25.191-b12
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/jre/bin/java
# VM options: -Xms2G -Xmx2G
# Warmup: 5 iterations, 10 s each
# Measurement: 5 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: BenchmarkTest.noReuse
# Parameters: (N = 10000000)

# Run progress: 0.00% complete, ETA 00:03:20
# Fork: 1 of 1
# Warmup Iteration   1: 1083.656 ms/op
# Warmup Iteration   2: 846.485 ms/op
# Warmup Iteration   3: 901.164 ms/op
# Warmup Iteration   4: 849.659 ms/op
# Warmup Iteration   5: 903.805 ms/op
Iteration   1: 847.008 ms/op
Iteration   2: 895.800 ms/op
Iteration   3: 892.642 ms/op
Iteration   4: 825.901 ms/op
Iteration   5: 889.914 ms/op


Result "BenchmartTest.noReuse":
  870.253 ±(99.9%) 122.495 ms/op [Average]
  (min, avg, max) = (825.901, 870.253, 895.800), stdev = 31.812
  CI (99.9%): [747.758, 992.748] (assumes normal distribution)


# JMH version: 1.21
# VM version: JDK 1.8.0_191, Java HotSpot(TM) 64-Bit Server VM, 25.191-b12
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/jre/bin/java
# VM options: -Xms2G -Xmx2G
# Warmup: 5 iterations, 10 s each
# Measurement: 5 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: BenchmarkTest.withReuse
# Parameters: (N = 10000000)

# Run progress: 50.00% complete, ETA 00:01:58
# Fork: 1 of 1
# Warmup Iteration   1: 113.780 ms/op
# Warmup Iteration   2: 113.643 ms/op
# Warmup Iteration   3: 114.323 ms/op
# Warmup Iteration   4: 114.258 ms/op
# Warmup Iteration   5: 117.351 ms/op
Iteration   1: 114.526 ms/op
Iteration   2: 113.944 ms/op
Iteration   3: 113.943 ms/op
Iteration   4: 112.930 ms/op
Iteration   5: 113.124 ms/op


Result "BenchmarkTest.withReuse":
  113.694 ±(99.9%) 2.528 ms/op [Average]
  (min, avg, max) = (112.930, 113.694, 114.526), stdev = 0.657
  CI (99.9%): [111.165, 116.222] (assumes normal distribution)


# Run complete. Total time: 00:03:40

REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
experiments, perform baseline and negative tests that provide experimental control, make sure
the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
Do not assume the numbers tell you what you want them to tell.

Benchmark                     (N)  Mode  Cnt    Score     Error  Units
BenchmarkTest.noReuse    10000000  avgt    5  870.253 ± 122.495  ms/op
BenchmarkTest.withReuse  10000000  avgt    5  113.694 ±   2.528  ms/op
    0 回复  |  直到 6 年前
        1
  •  9
  •   Alexander Pavlov    7 年前

    你可以有一些方便的函数,也可以有线程安全的版本来并行工作。 

    Function<T,U> threadSafeReusableWrapper(Supplier<U> newWrapperInstanceFn, BiConsumer<U,T> wrapFn) {
   final ThreadLocal<T> wrapperStorage = ThreadLocal.withInitial(newWrapperInstanceFn);
   return item -> {
      T wrapper = wrapperStorage.get();
      wrapFn.consume(wrapper, item);
      return wrapper;
   }
}

Function<T,U> reusableWrapper(U wrapper, BiConsumer<U,T> wrapFn) {
   return item -> {
      wrapFn.consume(wrapper, item);
      return wrapper;
   };
}

list.stream()
    .map(reusableWrapper(new Wrapper(), Wrapper::setSource))
    .forEach( w -> processWrapper(w) );
list.stream()
    .map(threadSafeReusableWrapper(Wrapper::new, Wrapper::setSource))
     .parallel()
    .forEach( w -> processWrapper(w) );

    不过,我觉得不值得。这些包装纸寿命短,所以不太可能离开年轻一代,所以会很快被垃圾收集 . 不过,我认为这个想法值得商榷 micro-benchmark library JMH

        2
  •  11
  •   Naman    7 年前

    您的方法碰巧起作用,因为流管道只包含无状态操作。在这样的星座中,顺序流求值一次可以处理一个元素,因此对包装器实例的访问不会重叠,如 illustrated here

    它肯定不适用于像这样的有状态操作 sorted 和 distinct reduce , min max . 如果是 collect ,这取决于具体情况 Collector forEachOrdered 由于需要缓冲,因此无法处理并行流。

    TheadLocal

    map , filter forEach , findFirst/Any all/any/noneMatch Stream 也不要随意使用 收藏家

    换句话说,如果您想使用这种可变包装器,最好使用一个实现特定操作的循环。您已经有了这样一个手动实现的缺点,那么为什么不实现它来获得优点呢。

    要考虑的另一个方面是,重用这样一个可变的包装器会带来什么好处。它只适用于在应用转义分析之后临时对象可能会得到优化的类似循环的用法。在这种情况下,重用对象,延长其生命周期,实际上可能会降低性能。

    当然,对象规模化并不是一种可以保证的行为。可能有一些场景,比如长流管道超过JVMs内联限制,对象不会被省略。不过,临时物品并不一定昂贵。

    这一点已在中作了解释 this answer . 临时对象的分配很便宜。垃圾回收的主要成本是由仍然存在的对象造成的。在为新的分配腾出空间时,这些需要遍历,这些需要移动。临时对象的负面影响是它们可能会缩短垃圾回收轮之间的时间。但这是分配率和可用分配空间的函数,因此这确实是一个问题,可以通过向其添加更多RAM来解决。RAM越多意味着GC循环之间的时间越长 和 当GC发生时,会有更多的死对象,这使得GC的净成本更小。

    不过,避免过度分配临时对象是一个值得关注的问题。存在 IntStream , LongStream ,和 DoubleStream 说明了这一点。但是这些都是特殊的,因为使用原语类型是使用包装器对象的可行替代方法,而不存在重用可变包装器的缺点。它也不同,因为它适用于原语类型和包装器类型在语义上等价的问题。相反,您希望解决操作需要包装器类型的问题。因为原语流也适用,当您需要解决问题的对象时,没有办法绕过装箱,装箱将为不同的值创建不同的对象,而不是共享可变的对象。

    因此,如果同样存在这样一个问题,即语义上等价的包装器对象在没有实质性问题的情况下避免了替换,比如只使用 Comparator.comparingInt 而不是 Comparator.comparing 在可行的情况下,你还是会喜欢的。但只有那时。

    简言之,大多数情况下,这种对象重用的节省(如果有的话)并不能证明其缺点。在特殊的情况下,如果它是有益的和重要的,您最好使用一个循环或任何其他由您完全控制的构造,而不是使用 溪流

        3
  •  4
  •   SDJ k13i    7 年前

    尽管这是可能的,但引用流之外的对象会使代码在样式上不那么实用。通过一个helper函数就可以实现一个非常接近的等价物,该等价物封装得更好: 

    public class Context {

    private static final Wrapper WRAPPER = new Wrapper();

    private static void helper(Source source) {
        WRAPPER.setSource(source);
        processWrapper(WRAPPER);
    }

    public static void main(String[] args) {
        List<Source> list = Arrays.asList(new Source("Foo"), new Source("Baz"), new Source("Bar"));
        list.stream().forEach(Context::helper);
}
    推荐文章
    关于   移动版
    代码之家 - 一站式码农服务社区
    沪ICP备11025650号