Multi-thread et lazy loading

Salut à tous,
J'ai un petit problème dans l'utilisation de jpa dans un contexte multi-thread.

C'est la première fois que je me lance dans ce genre de chose donc peut-être que je n'ai pas réellement compris le principe de fonctionnement, ce qui expliquerait mes erreurs!

Voila, j'aimerais lancer un traitement en parallèle dans plusieurs threads : je précise que ces traitements font uniquement de la lecture en bdd et génère des fichiers à partir de ces données (le problème de synchronized sur les lectures/écritures en bdd ne se posent à priori pas pour le moment).

Voici mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
List<LivrableVO> fichiers;
private void genererFichiers() {
    try {
        fichiers = gestionFichiersService.recupererFichiersByEtat(Etat.EXTRAIT);
        if ((fichiers != null) && (fichiers.size() > 0)) {
            int nbFichiers = fichiers.size();
            // Calcul du nombre de thread à lancer
            int nbThreads = nbLivrables / 2;
            if (nbThreads > NB_THREAD_MAX) {
                nbThreads = NB_THREAD_MAX;
            }
 
            LOG.debug("Lancement de " + nbThreads + " threads...");
            threads = new Thread[nbThreads];
            int nb = 0;
            for (nb = 0; nb < nbThreads; nb++) {
                LOG.debug("Lancement thread n°" + (nb + 1));
                threads[nb] = new Thread(new ThreadRelookingFacture());
                threads[nb].start();
            }
 
            // On attend que chaque thread ait finit
            for (nb = 0; nb < nbThreads; nb++) {
                threads[nb].join();
            }
        }
    } catch (InterruptedException ex) {
        LOG.error(ex);
    }
    LOG.debug("Fin génération des fichiers");
}
 
private synchronized LivrableVO getFacture() {
    if ((fichiers != null) && (fichiers.size() > 0)) {
        LivrableVO livrableVO = fichiers.get(0);
        fichiers.remove(0);
        return livrableVO;
    }
    return null;
}
 
public class ThreadRelookingFacture extends Thread {
 
    public void run() {
         LivrableVO livrableVO = getFichier();
         if (livrableVO != null) {
             while (livrableVO != null) {
                 try {
                      relookingApp.genererFichier(livrableVO, false);
                 } catch (FunctionnalException ex) {
                      LOG.error(ex);
                 } catch (TechnicalException ex) {
                     LOG.error(ex);
                 }
 
                 livrableVO = getFacture();
            }
        }
    }
}

Quand je rentre dans relookingApp.genererFichier, ma fonction va faire une requête en base pour récupérer des infos, le problème est que je me retrouve avec une LazyLoading Exception.
A noter que si je fais le même traitement sans créer de thread (et donc exécution de tout le traitement dans le thread courant), tout marche parfaitement.

Que faut-il faire pour gérer correctement le contexte de persistence dans mes threads ?
C'est la première fois que je fais ce genre de chose et je n'ai pas trouvé grand chose pour le moment.
Je suis preneur de toute remarque/idée si vous voyez un problème de conception!

Merci d'avance.