Huge stream of questions on the use of: java8 about new features

Mainly concerned about the situation it faces today.

About this parallel (not actually parallel concurrent fishes) stream.

I think this Kankan stream function will not change soon after concurrent

Then wrote the following simple code:

public class StremStudy {
    public static List<Integer> list1 = new ArrayList<>();
    public static List<Integer> list2 = new ArrayList<>();
    public static List<Integer> list3 = new ArrayList<>();
    public static List<Integer> list4 = new ArrayList<>();

    public static void main(String[] args) {
        long start1 = System.currentTimeMillis();
        IntStream.range(0,10000000).parallel().forEach(list1::add);
        System.out.println("list1时间:"+(System.currentTimeMillis()-start1)+"\n");
        System.out.println("list1:"+list1.size()+"\n");

        long start2 = System.currentTimeMillis();
        IntStream.range(0,10000000).forEach(list2::add);
        System.out.println("list2时间:"+(System.currentTimeMillis()-start2)+"\n");
        System.out.println("list2:"+list2.size()+"\n");

        long start3 = System.currentTimeMillis();
        IntStream.range(0,10000000).parallel().forEach(i->{
            synchronized (list3){
                list3.add(i);
            }
        });
        System.out.println("list3时间:"+(System.currentTimeMillis()-start3)+"\n");
        System.out.println("list3:"+list3.size()+"\n");

        long start4 = System.currentTimeMillis();
        IntStream.range(0,10000000).parallel().forEach(list4::add);
        System.out.println("list4时间:"+(System.currentTimeMillis()-start4)+"\n");
        System.out.println("list4:"+list4.size()+"\n");

    }
}

 

Check parallel stream, the normal stream, the parallel lock execution result stream and execution time.

Find the usual three conditions are like this

Or similar results following: performing long parallel streams, fast serial stream. (A small amount of data)

ps: list1 is used to sacrifice, like direct care. It is mainly to basic thread creation.

Time list1: 115 

list1: 66508 

List2 Time:. 6 

List2: 100000 

list3 Time: 14 

list3: 100000 

list4 Time: 11

list4: 74546

Process finished with exit code 0

Either this (when large volumes of data): [to the data is too large, the first direct gc. shocked】

Later tune a bit small. Then get a result like this.

Then you can clearly see the result. Really fast parallel streams.

list1 time: 1209

list1:4781548

 

list2 time: 2936

list2:10000000

 

list3 time: 3816

list3: 10000000

 

list4 time: 510

list4: 3282445

 

 

Then is the third case, a direct error: Tell me the line-flow operation in question

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 823
    at java.util.ArrayList.add(ArrayList.java:459)
    at java.util.stream.ForEachOps$ForEachOp$OfInt.accept(ForEachOps.java:205)
    at java.util.stream.Streams$RangeIntSpliterator.forEachRemaining(Streams.java:110)
    at java.util.Spliterator$OfInt.forEachRemaining(Spliterator.java:693)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.ForEachOps$ForEachTask.compute(ForEachOps.java:291)
    at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:731)
    at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
    at java.util.concurrent.ForkJoinTask.doInvoke(ForkJoinTask.java:401)
    at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:734)
    at java.util.stream.ForEachOps$ForEachOp.evaluateParallel(ForEachOps.java:160)
    at java.util.stream.ForEachOps$ForEachOp$OfInt.evaluateParallel(ForEachOps.java:189)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:233)
    at java.util.stream.IntPipeline.forEach(IntPipeline.java:404)
    at java.util.stream.IntPipeline$Head.forEach(IntPipeline.java:560)
    at rushTime.StremStudy.main(StremStudy.java:14)

Then we get the conclusion

parallelStream concurrent flow computation thread safe.

Use it with caution.