Est la synchronisation au sein d'une HttpSession faisable?

J'ai trouvé cette belle explication dans spring-mvc JavaDoc pour WebUtils.getSessionMutex():

Dans de nombreux cas, la HttpSession de référence lui-même est sûr mutex ainsi, puisqu'il sera toujours la même référence de l'objet de la même logique actif session. Cependant, ce n'est pas garanti à travers les différents conteneurs de servlet; le seul 100% de manière sûre est une session de mutex.

Cette méthode est utilisée en tant que verrou lorsque synchronizeOnSession indicateur est défini:

Object mutex = WebUtils.getSessionMutex(session);
synchronized (mutex) {
    return handleRequestInternal(request, response);
}

Si vous regardez à la mise en œuvre de getSessionMutex(), il utilise certains de session personnalisé attribut s'il est présent (sous org.springframework.web.util.WebUtils.MUTEX clé) ou HttpSession instance si ce n':

Object mutex = session.getAttribute(SESSION_MUTEX_ATTRIBUTE);
if (mutex == null) {
    mutex = session;
}
return mutex;

Ordinaire, servlet spec - être 100% sûr d'utiliser des attributs de session plutôt que de HttpSession objet lui-même.

Voir aussi

• http://www.theserverside.com/discussions/thread.tss?thread_id=42912

De synchronisation se produit lorsqu'un verrou est placé sur un objet de référence, de sorte que les fils qui font référence au même objet à traiter toute synchronisation sur cet objet partagé comme une barrière de péage.

Donc, ce que votre question soulève un point intéressant: l'objet HttpSession séparée en deux appels web à partir de la même session, fin comme de la même référence d'objet dans le conteneur web, ou sont-ils deux objets qui venez d'arriver à avoir des données similaires dans leur? J'ai trouvé cette discussion intéressante sur la dynamique des applications web qui discute HttpSession un peu. Aussi, il est cette discussion à CodeRanch sur la sécurité des threads en HttpSession.

À partir de ces discussions, il semble que le HttpSession est en effet le même objet. Un moyen simple serait d'écrire une servlet simple, regardez la HttpServletRequest.getSession(), et voir si elle fait référence à la même session sur l'objet d'appels multiples. Si c'est le cas, je pense que ta théorie est bonne, et vous pouvez l'utiliser pour la synchronisation entre l'utilisateur appels.

Les réponses sont correctes. Si vous voulez éviter le même utilisateur exécute 2 différents (ou le même) demandes en même temps, vous pouvez synchroniser sur le HttpSession. Le mieux à faire, c'est d'utiliser un Filtre.

Notes:

• si vos ressources (images, scripts, et non de fichiers dynamiques) vient également par le biais de la servlet, vous pouvez créer un goulot d'étranglement. Alors bien sûr, la synchronisation ne s'effectue que sur des pages dynamiques.
• Essayez d'éviter les getSession directement, il est préférable de tester si la session existe déjà parce qu'une session n'est pas automatiquement créé pour les clients (que rien ne doit être stocké dans la session). Alors, si vous appelez getSession(), la session sera créé et la mémoire seront perdues. Ensuite, utilisez getSession(false) et d'essayer de traiter avec le null résultat si aucune session n'existe déjà (dans ce cas, ne pas synchroniser).

Personnellement, je mettre en œuvre à la session de verrouillage à l'aide d'un HttpSessionListener*:

package com.example;

@WebListener
public final class SessionMutex implements HttpSessionListener {
    /**
     * HttpSession attribute name for the session mutex object.  The target for 
     * this attribute in an HttpSession should never be altered after creation!
     */
    private static final String SESSION_MUTEX = "com.example.SessionMutex.SESSION_MUTEX";

    public static Object getMutex(HttpSession session) {
        //NOTE:  We cannot create the mutex object if it is absent from  
        //the session in this method without locking on a global 
        //constant, as two concurrent calls to this method may then 
        //return two different objects!  
        //
        //To avoid having to lock on a global even just once, the mutex 
        //object is instead created when the session is created in the 
        //sessionCreated method, below.

        Object mutex = session.getAttribute(SESSION_MUTEX);

        //A paranoia check here to ensure we never return a non-null 
        //value.  Theoretically, SESSION_MUTEX should always be set, 
        //but some evil external code might unset it:
        if (mutex == null) {
            //sync on a constant to protect against concurrent calls to 
            //this method
            synchronized (SESSION_MUTEX) { 
                //mutex might have since been set in another thread 
                //whilst this one was waiting for sync on SESSION_MUTEX
                //so double-check it is still null:
                mutex = session.getAttribute(SESSION_MUTEX);
                if (mutex == null) {
                    mutex = new Object();
                    session.setAttribute(SESSION_MUTEX, mutex);
                }
            }
        }
        return mutex; 
    }

    @Override
    public void sessionCreated(HttpSessionEvent hse) {
        hse.getSession().setAttribute(SESSION_MUTEX, new Object());
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent hse) {
        //no-op
    }
}

Quand j'ai besoin d'une séance de mutex, je peux utiliser:

synchronized (SessionMutex.getMutex(request.getSession())) {
    //...
}

__

*FWIW, j'aime vraiment la solution proposée dans la question elle-même, car il fournit pour la session nommée serrures ainsi que les demandes de ressources indépendantes n'ont pas besoin de partager la même session de verrouillage. Mais si une seule session de verrouillage est ce que vous voulez, alors cette réponse peut-être raison de votre rue.

À l'aide de

private static final Object LOCK = new Object();

vous utilisez la même serrure pour toutes les séances et c'était la raison essentielle de l'impasse j'ai fait face.
Donc, à chaque session de la mise en œuvre a la même condition de course, ce qui est mauvais.

Il a besoin de changement.

D'autres propositions de réponse:

Object mutex = session.getAttribute(SESSION_MUTEX_ATTRIBUTE);
if (mutex == null) {
    mutex = session;
}
return mutex;

semble beaucoup mieux.