how to use java parallel stream instead of executorThreadsPool?

问题

I want to write a test that execute many parallel calls to my API.

ExecutorService executor = Executors.newCachedThreadPool();
        final int numOfUsers = 10;
        for (int i = 0; i < numOfUsers; i++) {
            executor.execute(() -> {
                final Device device1 = getFirstDevice();
                final ResponseDto responseDto = devicesServiceLocal.acquireDevice(device1.uuid, 4738);
                if (responseDto.status == Status.SUCCESS)
                {
                    successCount.incrementAndGet();
                }
            });
        }

I know I can do it using executorThreadsPool, like this:

devicesList.parallelStream()
           .map(device -> do something)

I could have created it with java8 parallel stream:

How can i do it on one device?

meaning I want few calls to acquire the same device.

something like this:

{{device}}.parallelStream().execute(myAction).times(10)

回答1:

Yes it can, but...

You would think

Stream.generate(() -> device)
      .limit(10)
      .parallel()
      .forEach(device -> device.execute());

should do the job. But NO, because reason (I really do not know why, no clue). If I let device.execute() wait a second and then let it print something. The stream prints 10 times every second something. So it isn't at all parallel, not what you want.

Google is my friend and I found a lot of articles that warn against parallelStream. But my eye fell on http://blog.jooq.org/2014/06/13/java-8-friday-10-subtle-mistakes-when-using-the-streams-api/ number 8 and 9. 8 was saying if it is backed by a collection you'll have to sort it and it will magically work so:

Stream.generate(() -> device)
      .limit(10)
      .sorted((a,b)->0) // Sort it (kind of), what??
      .parallel()
      .forEach(device -> device.execute());

And now it prints after one second 8 times and after an other second 2 times something. I have 8 cores so that is what we (kind of) expect.

I used .forEach() in my stream, but at first I was (like your example) using .map(). .map() didn't print a thing: the stream was never consumed (see 9 in the linked article).

So, beware working with streams and especially parallel ones. You have to be sure you're stream is consumed, it is finite (.limit()), it is working parallel, etc. Streams are weird, I suggest keeping your working solution.

Note: if device.execute() is a blocking operation (IO, networking...) you will never have more than your number of cores (in my case 8) tasks that will be executed at the same time.

Update (thanks to Holger):

Holger gave an elegant alternative:

IntStream.range(0,10)
      .parallel()
      .mapToObject(i -> getDevice())
      .forEach(device -> device.execute());

// Or shorter:
IntStream.range(0,10)
      .parallel()
      .forEach(i -> getDevice().execute());

which is just like a parallel for-loop (and it works).

来源：https://stackoverflow.com/questions/36402481/how-to-use-java-parallel-stream-instead-of-executorthreadspool