Question sur la meilleure pratique pour implémenter un fonctoin statique qui donne une valeur unique lors d'accès simultanés.

Question

Une fonction statique retUnique() me renvoie une valeur unique. Ma question est la suivante : s'il y a plusieurs utilisateurs qui utilisent la même fonction à un moment donné, que se passe-t-il ? Existe-t-il une meilleure pratique pour s'assurer que chaque utilisateur accédant simultanément à cette fonction statique obtienne une valeur unique et ne soit pas confronté à des problèmes de threading ?

Peut-on me donner un exemple ?

Answer 1

Les fonctions statiques n'ont rien de particulier qui les rende plus ou moins sûres à utiliser sur plusieurs threads. Au contraire, vous devez examiner les données auxquelles la fonction accède et qu'elle modifie, et vous assurer qu'elle respecte toujours l'intégrité de ces données lorsqu'elle est appelée simultanément.

Voici un exemple qui pourrait répondre à votre question :

private static int myUniqueID = 1;
public static int GetFreshUniqueID()
{
    lock(someObject)
    {
        return myUniqueID++;
    }
}

Dans ce cas, la clé pour assurer la sécurité des threads est de verrouiller la fonction dans un contexte de synchronisation afin d'éviter que deux threads obtiennent le même ID avant que l'un d'eux ne l'incrémente. Votre situation peut varier.

Answer 2

Ne s'agit-il pas d'un simple problème de synchronisation ?

Appliquer un verrou au début de la fonction et le relâcher à la fin.

Answer 3

En supposant que vous souhaitiez simplement renvoyer une valeur entière unique et incrémentée, l'approche sûre la plus simple consiste probablement à utiliser un compteur statique privé et un objet de verrouillage statique privé. Quelque chose comme :

private static int s_UniqueCounter; // starts at 0 by default
private static readonly object s_UniqueCounterLock = new object();

public static int GetUnique()
{
    lock (s_UniqueCounterLock)
    {
        s_UniqueCounter++;
        return s_UniqueCounter;
    }
}

C'est à vous de vous assurer que l'objet verrou particulier est utilisé pour protéger tout autre accès au membre compteur statique (c'est pourquoi ils sont déclarés privés, bien sûr, afin que la classe qui les possède contrôle tout accès). Il ne devrait probablement pas être accédé ailleurs, pour cette utilisation, mais vous pourriez avoir quelque chose à regarder la valeur actuelle pour voir combien de fois il a été appelé. Cela devrait probablement être protégé par le verrou également (pour s'assurer que le résultat est actuel) :

internal static int QueryUniqueCount() // or this could be private, or public
{
    lock (s_UniqueCounterLock)
    {
        return s_UniqueCounter;
    }
}