1

In my Action Bean I load Entities from a database, use data from those Entities to create new EntityObjects using Java 8 ParallelStream, and store those EntityObjects in a List for later use on a web page.

I use the following to create these Objects using the Hibernate mapped Entities:

List<Entity> entities = dao.getEntities();
List<Object> entityObjects = new ArrayList<>();
entityObjects.addAll(
        entities.parallelStream()
                .map(EntityObject::new)
                .collect(Collectors.toList())
);

with a EntityObject constructor looking like:

public EntityObject(Entity entity) {...}

When Trying to load the page using the Action Bean I get Hibernate Exceptions. They are different every time I try to load the page, but all have to do with Shared References, such as:

... ERROR: Found shared references to a collection

and

... ERROR: A collection with cascade="all-delete-orphan" was no longer referenced by the owning entity instance

What am I doing wrong?

EDIT: Fixed the code.

darksmurf
  • 3,747
  • 6
  • 22
  • 38
  • 2
    Why are you using `entityObjects.addAll` instead of using the result of the stream operation directly, i.e. `List entityObjects = entities.stream().map(entityObjects::new) .collect(Collectors.toList());`? – Holger May 10 '16 at 15:45
  • 1
    @darksmurf first listen to what Holger said, then look again at your code, that **map** part is wrong, it should be **map(EntityObject::new)** probably – Eugene May 10 '16 at 21:01
  • 2
    @darksmurf Your issue probably hides in the EntityObject constrcutor judging by the logs that you have provided, could you show EXACTLY that also? – Eugene May 10 '16 at 21:08
  • @Eugene My mistake with the **map** part, changed it. The constructor is quote complex and could be the problem, but not in my case. I've already answered my question below, and the purpose of this thread is to inform people that using ParallelStream with Hibernate can be a bad idea. Please tell me if I'm doing it wrong: this is my first Q&A thread. – darksmurf May 11 '16 at 08:30
  • 2
    @darksmurf the idea is that this is probably not because of the parallelStream per-se, it could be something funny doing in the constructor and as a side-affect, since parallel is involved could brake your code. You should understand the exceptions first, clearly. Welcome to SO btw ;) – Eugene May 11 '16 at 08:44

3 Answers3

1

parallelStream() will execute the code on multiple threads (good for performance). However, the Hibernate Session object is not thread-safe and using it in a threaded fashion is likely to fail in mysterious ways. The other answer from Bryan Pugh regarding transactions is similar: in most cases the transaction is held in a ThreadLocal variable. Executing parallelStream() means some code runs on a different (unrelated) thread. This can be easily shown using this code:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class TestParallel {
    public static void main(String[] args) {
        // Keep a set of thread-ids that were used. Make sure this is thread-safe.
        Set<String> threadId = Collections.synchronizedSet(new HashSet<String>());

        // Create a long enough list such that spliterator will indeed use multiple threads.
        // If the collection is very small (1 or 2 entries) no multithreading will be done.
        Collection<Integer> numbers = new ArrayList<>();
        for(int i=0; i<10000; i++) {
            numbers.add(i);
        }

        // Now for each number in the list, see which thread is handling it by dumping the thread-name.
        numbers.parallelStream().forEach(n -> threadId.add(Thread.currentThread().toString()));

        // And give a summary of the total number of threads that were used in the parallelStream()
        System.out.println("Used threads: " + threadId.size());
    }
}

When using a small list (change 10000 to 2) one thread will be used. With the given constant on my machine 12 threads are used. Depending on the number of entries in your database and the performance and JDK version you used, the numbers will vary but in general: avoid parallelStream() unless you know what it does.

Marcel
  • 11
  • 2
0

I also don't have a definitive answer, but I have noticed that this seems to stem from the fact that you sometimes/always loose your transaction when you parallelize. It seems that different threads can't/don't have access the transaction of its parent.

Consider: Spring transaction manager and multithreading

https://dzone.com/articles/spring-transaction-management-over-multiple-thread-1

I believe this is why.

Bryan Pugh
  • 113
  • 1
  • 7
-1

Use

stream()

instead of

parallelStream()

.

I'm not quite sure how it works, but when using parallelStream() you operate on several objects at once. This can cause you to have different references to the same collection at one moment in time, and this is under specific circumstances not allowed by Hibernate, causing the exception.

darksmurf
  • 3,747
  • 6
  • 22
  • 38