C # Méthode multithread pour empêcher le brouillage

Les façons suivantes d'éviter le multithreading "coincé" en C #: éviter d'effectuer des opérations longues sur les threads d'interface utilisateur. Utilisez la tâche et async / Await pour effectuer des opérations longues de manière asynchrone. Mettez à jour l'interface utilisateur sur le thread d'interface utilisateur via application.current.dispatcher.invoke. Utilisez l'annulation de l'annulation pour contrôler l'annulation des tâches. Faites un usage rationnel des pools de threads pour éviter une création excessive de fils. Faites attention à la lisibilité et à la maintenabilité du code, ce qui facilite le débogage. Les journaux sont enregistrés dans chaque fil pour un débogage facile.

C # Multithreading: L'art d'élégancement évitant "dur"

Vous devez avoir eu cette expérience: le programme cesse soudainement de déménagement, le pointeur de la souris devient un sablier, et le monde semble encore ... la capacité de concurrence apportée par la programmation multi-threading est tentante, mais si vous ne faites pas attention, cela peut devenir un cauchemar pour votre programme, vous faisant tomber dans l'abîme de la "stagnation". Dans cet article, parlons de comment éviter de manière élégamment gênée en C #, afin que votre programme multithread puisse galoper comme un cheval sauvage sans perdre le contrôle.

Tout d'abord, vous devez comprendre que le soi-disant "coincé" n'est généralement pas un problème avec le fil lui-même, mais le fil d'interface utilisateur est bloqué. Votre programme peut avoir plusieurs threads qui travaillent dur, mais s'ils attendent tous que le thread d'interface utilisateur traite les résultats, une fois le thread d'interface utilisateur bloqué, l'ensemble du programme sera dans un état de silence. Par conséquent, la clé consiste à supprimer le fardeau sur les fils d'interface utilisateur.

Prenons d'abord les bases. C # fournit une classe Thread et une classe Task pour la programmation multi-thread. Task est basée sur ThreadPool , qui est plus pratique à gérer et a une utilisation plus élevée des ressources, nous l'utilisons donc principalement. De plus, les mots clés async et await sont des outils puissants pour la programmation asynchrone. Ils rendent le code asynchrone aussi simple que le code synchrone et sont la clé pour éviter de bloquer les threads d'interface utilisateur.

Maintenant, plongeons-nous dans le cœur: comment éviter le blocage des fils d'interface utilisateur. La solution la plus courante consiste à utiliser BackgroundWorker , mais elle est un peu dépassée, et il est désormais plus recommandé d'utiliser Task en combinaison avec async/await . Jetez un œil à cet exemple:

 <code class="csharp">private async void Button_Click(object sender, RoutedEventArgs e) { // 禁用按钮，防止重复点击button1.IsEnabled = false; try { await Task.Run(() => { // 模拟耗时操作Thread.Sleep(5000); // 更新UI需要使用Dispatcher Application.Current.Dispatcher.Invoke(() => { label1.Content = "耗时操作完成!"; }); }); } catch (Exception ex) { // 处理异常Application.Current.Dispatcher.Invoke(() => { label1.Content = $"错误: {ex.Message}"; }); } finally { // 启用按钮button1.IsEnabled = true; } }</code>

Dans ce code, les opérations longues sont placées dans Task.Run et exécutées de manière asynchrone. La clé réside dans Application.Current.Dispatcher.Invoke , qui garantit que les opérations de mise à jour de l'interface utilisateur sont exécutées sur le fil d'interface utilisateur, en évitant les conflits. try-catch-finally assure la robustesse du programme et peut être géré gracieusement même si une exception se produit et ne provoquera pas le plan du programme.

Pour être plus avancé, vous pouvez utiliser CancellationToken pour contrôler l'annulation des tâches pour éviter les déchets de ressources inutiles. Par exemple, si l'utilisateur clique sur le bouton "Annuler", vous pouvez annuler la tâche d'exécution via CancellationTokenSource .

N'oubliez pas, n'effectuez pas d'opérations longues sur les threads d'interface utilisateur! Il s'agit de la règle d'or de la programmation multithread. Toutes les opérations pouvant bloquer les threads d'interface utilisateur doivent être exécutées dans un thread séparé puis mise à jour avec Dispatcher ou un mécanisme similaire.

Enfin, en ce qui concerne l'optimisation des performances, essayez d'éviter la surutilisation des verrous, car les serrures réduiront les performances simultanées. Utilisez raisonnablement les pools de threads pour éviter de créer trop de threads. La lisibilité et la maintenabilité du code sont également très importantes. Le code clair est plus facile à déboguer et à maintenir, en réduisant la possibilité de «stagnation». Une bonne habitude est de se connecter à chaque fil afin que les problèmes puissent être rapidement situés pendant le débogage. N'oubliez pas que la programmation multi-lancement élégante vous oblige à avoir une compréhension approfondie des concepts tels que la concurrence, l'asynchrone, la sécurité des fils, etc. Cela nécessite une accumulation d'expérience et d'apprentissage et de pratique continu.

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!