Comment puis-je gérer efficacement les blocages dans les applications C# multithread accédant à SQL Server ?

Applications C# multithread avec appels de base de données SQL Server

Le code fourni présente une application C# multithread qui effectue des opérations de base de données SQL Server. Cependant, l’approche utilisée peut entraîner des problèmes de performances et des blocages. Cet article explore une implémentation plus efficace et plus robuste qui exploite la bibliothèque parallèle de tâches (TPL) et inclut la gestion des blocages.

Gestion des blocages

Lorsque vous travaillez avec des applications multithread impliquant des interactions avec des bases de données, les blocages sont inévitable. Il est essentiel de les anticiper et de développer des mécanismes pour les gérer efficacement.

Raisons des blocages

• Threads excessifs : limiter le nombre de threads peut éviter les conflits pour les ressources et réduire les occurrences de blocages.
• Indexation inadéquate : Des index insuffisants peuvent conduire à des requêtes non sélectives, entraînant des verrouillages de plage étendue qui augmentent les risques de blocage.
• Indexation excessive : trop d'index ont également un impact sur les performances en raison de la surcharge liée à leur maintenance, ce qui augmente le risque de blocages.
• Niveau d'isolation des transactions élevé : le niveau d'isolement « sérialisable » par défaut dans .NET restreint la concurrence et peut conduire à davantage de blocages. Des niveaux d'isolement plus faibles, tels que « Lecture validée », peuvent atténuer ce problème.

Approche multithread améliorée

Envisagez l'approche suivante :

1. Utilisation de TPL : Le TPL simplifie la programmation parallèle grâce à sa syntaxe intuitive et sa prise en charge intégrée du traitement parallèle. Il simplifie la gestion des threads et optimise la répartition de la charge de travail.
2. Réessais de blocage : L'intégration d'un mécanisme de nouvelle tentative de blocage garantit la persistance des opérations malgré des blocages occasionnels. La classe DeadlockRetryHelper le démontre en réessayant d'effectuer des opérations dans une limite spécifiée.
3. Stratégie de partitionnement : Si possible, envisagez de partitionner les tables en plusieurs ensembles de données distincts. Cela permet à plusieurs threads de fonctionner indépendamment sur différentes partitions, minimisant ainsi les blocages. Les capacités de partitionnement de SQL Server peuvent faciliter cela efficacement.
4. Optimisation du niveau d'isolement : Ajustez le niveau d'isolement des transactions pour minimiser les blocages. Par exemple, si les modifications de données ne sont pas critiques, le niveau d'isolement « Lecture validée » permet une meilleure concurrence.

Exemple de code

Le code suivant illustre l'approche recommandée :

using System.Threading.Tasks;
using System.Transactions;
using System.Linq;
using Microsoft.Data.SqlClient;

public class MultiThreadingImproved
{
    public static void Main(string[] args)
    {
        var ids = new int[] { 1, 2, 3, 4, 5 };
        var errors = new List<ErrorType>();

        Parallel.ForEach(ids, id =>
        {
            try
            {
                CalculateDetails(id);
            }
            catch (Exception ex)
            {
                errors.Add(new ErrorType(id, ex));
            }
        });
    }

    public static void CalculateDetails(int id)
    {
        using (var db = new SqlConnection("connection string"))
        {
            db.Open();

            using (var txScope = new TransactionScope(
                TransactionScopeOption.Required,
                new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }))
            {
                // Query and update operations

                db.SubmitChanges();
                txScope.Complete();
            }
        }
    }

    public class ErrorType
    {
        public int Id { get; set; }
        public Exception Exception { get; set; }

        public ErrorType(int id, Exception ex)
        {
            Id = id;
            Exception = ex;
        }
    }
}

Conclusion

En résolvant les blocages potentiels, en utilisant le TPL et en explorant des stratégies alternatives, vous pouvez améliorer les performances et la fiabilité de vos applications C# multithread interagissant avec les bases de données SQL Server.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!