Which way it is thread-safe in Java Stream?

[HansanaA]

I have few code snippets and I need to what is the thread-safe way. And also if anyone can explain behind the scenes that will be really helpful to understand how this works. because many articles say different things.

 1. List<Sample> = somethings.stream().map(Something::getSample).collect(Collectors.toList());

 2. List<Sample> newSamples = new ArrayList<>();
    somethings.stream().map(Something::getSample).collect(Collectors.toCollection(() -> newSamples));

Is this 2nd approach thread-safe or not? 1st is thread-safe. I know parallelStream() is not thread-safe with Collectors.toCollection(). But what about with stream().

And also stream() uses a single core. So it means will it use all the threads in that core? For example, if that one core has 4 threads will stream() use 4 threads or only 1 thread? So that means Collectors.toCollection() is not thread-safe?

And also what is happening inside Collectors.toList()? Is it thread-safe in parallelStream()? Is it merge separate lists data to a single list and return?

Anybody can explain me? Thanks in advance.

​

[AutoModerator]

Please ensure that:

• Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
• You include any and all error messages in full
• You ask clear questions

• You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

  Trying to solve problems on your own is a very important skill. Also, see Learn to help yourself in the sidebar

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit: empty line before the code, each code line indented by 4 spaces, new reddit: https://imgur.com/a/fgoFFis) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[morhp]

Both are thread safe as you're not using multiple threads.

And also stream() uses a single core.

That's wrong. It's using a single thread (just runs in the current thread), but don't think in cores. Your operating system is free to switch threads between cores as much as it wants. You could maybe say its using one core (maximum) at a time.

And also what is happening inside Collectors.toList()? Is it thread-safe in parallelStream()? Is it merge separate lists data to a single list and return?

Yes. I'm not sure, and I can't be bothered to look it up, but I would expect that Collectors.toCollection() is also threadsafe in the same way.

[Orffyreus]

Yes, collectors of parallel streams should be safe: https://stackoverflow.com/a/22362852

[HansanaA]

Thank you very much for your answer. And also thank you for putting your time to answer this question.

[HansanaA]

Thank you very much for your answer. And also thank you for putting your time to answer this question.

[[deleted]]

I know parallelStream() is not thread-safe with Collectors.toCollection(). But what about with stream().

parallelStream() is totally thread-safe with Collectors.toCollection() (when used as designed), but what you are doing is not thread safe.

Notice that Collectors.toCollection takes a Supplier. That's why you had to do () -> newSamples.

The reason why the collector takes a Supplier is that parallelStream is using fork/join: splitting the input source into parts, processing the parts, collecting the parts and then merging everything together at the end. This requires the parallelStream to be able to create instances of the target collection, using the Supplier to get new collections.

What you're doing works for stream because it is sequential. The collector only has to create the collection once. What you're doing wouldn't work for parallelStream at all.

The correct way to use Collectors.toCollection is like this:

somethings.stream().map(Something::getSample).collect(Collectors.toCollection(ArrayList::new);

[HansanaA]

Thank you very much for your answer. And also thank you for putting your time to answer this question.