Többszálú alkalmazások hibakeresésének első lépései (C#, Visual Basic, C++)

A Visual Studio számos eszközt és felhasználói felületi elemet biztosít a többszálú alkalmazások hibakereséséhez. Ez az oktatóanyag bemutatja, hogyan használhatók a száljelölők, a Párhuzamos veremek ablak, a Párhuzamos figyelő ablak, a feltételes töréspontok és a szűrő töréspontok. Az oktatóanyag elvégzése során megismerkedhet a Visual Studio funkcióival a többszálú alkalmazások hibakereséséhez.

A forgatókönyv-alapú oktatóanyagokért tekintse meg az alábbi cikkeket.

• Holtpont hibakeresése Szálnézettel.

• Aszinkron alkalmazás (.NET) hibakeresése.

Az első lépés egy többszálú alkalmazásprojekt létrehozása.

Többszálú alkalmazásprojekt létrehozása

1. Nyissa meg a Visual Studiót, és hozzon létre egy új projektet.

   Ha a kezdőablak nincs megnyitva, válassza Fájl>Ablak indításalehetőséget.

   A kezdési ablakban válassza az Új projekt létrehozásalehetőséget.

   Az Új projekt létrehozása ablakban írja be vagy írja be a keresőmezőbe a konzolt . Ezután válassza a C#, a C++ vagy a Visual Basic elemet a Nyelv listából, majd válassza a Windowst a Platform listából.

   A nyelvi és platformszűrők alkalmazása után válassza a .NET- vagy C++- konzolalkalmazás-sablont , majd válassza a Tovább gombot.

   Megjegyzés:

   Ha nem látja a megfelelő sablont, lépjen az Eszközök>lekérése eszközök és szolgáltatások lapra, amely megnyitja a Visual Studio Installert. Válassza ki a .NET asztali fejlesztést vagy a C++ számítási feladattal rendelkező asztali fejlesztést , majd válassza a Módosítás lehetőséget.

   Az új projekt konfigurálása ablakban írja be vagy írja be a MyThreadWalkthroughApp kifejezést a Projekt neve mezőbe. Ezután válassza a Tovább vagy a Létrehozás lehetőséget, amelyik elérhető.

   .NET Core- vagy .NET 5+ projekt esetén válassza ki az ajánlott cél keretrendszert vagy a .NET 10-et, majd válassza a Létrehozás lehetőséget.

   Megjelenik egy új konzolprojekt. A projekt létrehozása után megjelenik egy forrásfájl. A választott nyelvtől függően a forrásfájl neve lehet Program.cs, MyThreadWalkthroughApp.cpp vagy Module1.vb.

2. Törölje a forrásfájlban megjelenő kódot, és cserélje le a következő frissített kódra. Válassza ki a kódkonfigurációhoz megfelelő kódrészletet.

   C#

   using System;
   using System.Threading;
   
   public class ServerClass
   {
   
       static int count = 0;
       // The method that will be called when the thread is started.
       public void InstanceMethod()
       {
           Console.WriteLine(
               "ServerClass.InstanceMethod is running on another thread.");
   
           int data = count++;
           // Pause for a moment to provide a delay to make
           // threads more apparent.
           Thread.Sleep(3000);
           Console.WriteLine(
               "The instance method called by the worker thread has ended. " + data);
       }
   }
   
   public class Simple
   {
       public static void Main()
       {
           for (int i = 0; i < 10; i++)
           {
               CreateThreads();
           }
       }
       public static void CreateThreads()
       {
           ServerClass serverObject = new ServerClass();
   
           Thread InstanceCaller = new Thread(new ThreadStart(serverObject.InstanceMethod));
           // Start the thread.
           InstanceCaller.Start();
   
           Console.WriteLine("The Main() thread calls this after "
               + "starting the new InstanceCaller thread.");
   
       }
   }
   

   VB

   Imports System.Threading
   
   Public Class ServerClass
       ' The method that will be called when the thread is started.
       Public count = 0
       Public Sub InstanceMethod()
           Console.WriteLine(
                   "ServerClass.InstanceMethod is running on another thread.")
   
           Dim data = count + 1
           ' Pause for a moment to provide a delay to make
           ' threads more apparent.
           Thread.Sleep(3000)
           Console.WriteLine(
                   "The instance method called by the worker thread has ended. " + data)
       End Sub
   
   End Class
   
   Public Class Simple
   
       Public Shared Sub Main()
   
           Dim ts As New ThreadStarter
           For index = 1 To 10
               ts.CreateThreads()
           Next
   
       End Sub
   
   End Class
   Public Class ThreadStarter
       Public Sub CreateThreads()
           Dim serverObject As New ServerClass()
   
           ' Create the thread object, passing in the
           ' serverObject.InstanceMethod method using a
           ' ThreadStart delegate.
           Dim InstanceCaller As New Thread(AddressOf serverObject.InstanceMethod)
   
           ' Start the thread.
           InstanceCaller.Start()
   
           Console.WriteLine("The Main() thread calls this after " _
                       + "starting the new InstanceCaller thread.")
   
       End Sub
   End Class
   

   C++

   // #include "pch.h" // Use with pre-compiled header
   #include <thread>
   #include <iostream>
   #include <vector>
   #include <string>
   
   int count = 0;
   
   void doSomeWork() {
   
       std::cout << "The doSomeWork function is running on another thread." << std::endl;
       int data = count++;
       // Pause for a moment to provide a delay to make
       // threads more apparent.
       std::this_thread::sleep_for(std::chrono::seconds(3));
       std::string str = std::to_string(data);
       std::cout << "The function called by the worker thread has ended. " + str<< std::endl;
   }
   
   int main() {
       std::vector<std::thread> threads;
   
       for (int i = 0; i < 10; ++i) {
   
           threads.push_back(std::thread(doSomeWork));
           std::cout << "The Main() thread calls this after starting the new thread" << std::endl;
   }
   
   for (auto& thread : threads) {
       thread.join();
   }
   
   return 0;
   }
   

3. A Fájl menüben válassza Az összes mentéselehetőséget.

4. (csak Visual Basic) A Megoldáskezelőben (jobb oldali ablaktáblán) kattintson a jobb gombbal a projektcsomópontra, és válassza a Tulajdonságok parancsot. Az Alkalmazás lapon módosítsa az Indítás objektumotEgyszerűre.

A többszálas alkalmazás hibakeresése

1. A forráskódszerkesztőben keresse meg a következő kódrészletet:

   C#

   Thread.Sleep(3000);
   Console.WriteLine();
   

   VB

   Thread.Sleep(3000)
   Console.WriteLine()
   

   C++

   std::this_thread::sleep_for(std::chrono::seconds(3));
   std::cout << "The function called by the worker thread has ended." << std::endl;
   

2. Kattintson a bal oldali sávban a Thread.Sleep, vagy C++ esetén a std::this_thread::sleep_for utasításnál a bal gombbal egy új töréspont beszúrásához.

   Az ereszcsatornában a piros kör azt jelzi, hogy ezen a helyen van beállítva töréspont.

3. A Hibakeresés menüben válassza a Hibakeresés indítása (F5) lehetőséget.

   A Visual Studio létrehozza a megoldást, az alkalmazás a csatolt hibakeresővel kezd futni, majd az alkalmazás leáll a töréspontnál.

4. A forráskódszerkesztőben keresse meg a töréspontot tartalmazó sort.

A száljelölő felfedezése

1. A Hibakeresési eszköztáron válassza a Szálak megjelenítése a forrásban gombot .

2. Nyomja le kétszer az F11 billentyűt a hibakereső előléptetéséhez.

3. Nézd meg az ereszt az ablak bal oldalán. Ezen a vonalon látható egy száljelölő ikon , amely két egymásba csavart szálra hasonlít. A száljelölő azt jelzi, hogy egy szál le van állítva ezen a helyen.

   A száljelölőket részben rejtheti el egy töréspont.

4. Vigye az egérmutatót a száljelölő fölé. Megjelenik egy adatleírás, amely közli az egyes leállított szálak nevét és szálazonosítóját. Ebben az esetben a név valószínűleg <noname>.

   

5. Válassza ki a száljelölőt a helyi menüben elérhető lehetőségek megtekintéséhez.

A szál helyének megtekintése

A Párhuzamos halmok ablakban válthat a Szálak nézet és a (tevékenységalapú programozási) Feladatok nézet között, és megtekintheti az egyes szálak hívási veremadatait. Ebben az alkalmazásban használhatjuk a Szálak nézetet.

1. Nyissa meg a Párhuzamos halmok ablakot a Hibakeresés>Windows>Párhuzamos halmok választásával. Az alábbiakhoz hasonlót kell látnia. A pontos információk az egyes szálak aktuális helyétől, a hardvertől és a programozási nyelvtől függően eltérhetnek.

   

   Ebben a példában balról jobbra a felügyelt kódra vonatkozó információk láthatók:

   • Az aktuális szál (sárga nyíl) be van írva ServerClass.InstanceMethod. A szál azonosítóját és veremkeretét megnézheti, ha az egérmutatót a ServerClass.InstanceMethod fölé helyezi.
   • A 31724 számú szál egy 20272-es számú szál tulajdonában lévő záron vár.
   • A főszál (bal oldali) leállt a [Külső kód] területen, amelyet a Külső kód megjelenítése lehetőség választása esetén tekinthet meg részletesen.

   Megjegyzés:

   További információ a Szálak nézet használatáról: Holtpont hibakeresése a Szálak nézetben.

2. Ha listanézetben szeretné megtekinteni a szálakat, válassza aWindows-szálak>> lehetőséget.

   

   Ebben a nézetben könnyen láthatja, hogy a szál 20272 a fő szál, és jelenleg külső kódban található, különösen System.Console.dll.

3. Kattintson a jobb gombbal a Párhuzamos halmok vagy a Szálak ablakban található bejegyzésekre, hogy megtekinthesse a helyi menüben elérhető lehetőségeket.

   A jobb gombbal kattintva elérhető menükben különféle műveleteket hajthat végre. Ebben az oktatóanyagban további részleteket is megismerhet a Párhuzamos figyelő ablakban (a következő szakaszokban).

Változó figyelése

1. Nyissa meg a Párhuzamos figyelő ablakot a Hibakeresés>, Windows>, Parallel Watch>Parallel Watch 1 kiválasztásával.

2. Jelölje ki azt a cellát, amelyben megjelenik a <Add Watch> szöveg (vagy a negyedik oszlopban az üres fejléccella), és írja be a következőt data:

   Az egyes szálak adatváltozóinak értékei megjelennek az ablakban.

3. Jelölje ki azt a cellát, amelyben a <Add Watch> szöveget látja (vagy az ötödik oszlop üres fejléccelláját), és írja be a következőt count:

   Az egyes szálak változóinak count értékei megjelennek az ablakban. Ha még nem látja ezt a sok információt, próbálja meg néhányszor lenyomni az F11 billentyűt a hibakeresőben lévő szálak végrehajtásának előmozdításához.

   

4. Kattintson a jobb gombbal az ablak egyik sorára a rendelkezésre álló lehetőségek megtekintéséhez.

Szálak megjelölése és törlése

A szálak megjelölésével nyomon követheti a fontos szálakat, és figyelmen kívül hagyhatja a többi szálat.

1. A Párhuzamos figyelő ablakban tartsa lenyomva a Shift billentyűt, és jelöljön ki több sort.

2. Kattintson a jobb gombbal, és válassza a Jelölés lehetőséget.

   Az összes kijelölt szál meg van jelölve. Most szűrhet, hogy csak a megjelölt szálak jelenjenek meg.

3. A Párhuzamos figyelő ablakban válassza a Csak megjelölt szálak megjelenítése gombot elemnél.

   Csak a megjelölt szálak jelennek meg a listában.

   Jótanács

   Miután megjelölt néhány szálat, kattintson a jobb gombbal egy kódsorra a kódszerkesztőben, és válassza a Megjelölt szálak futtatása a kurzorhoz parancsot. Ügyeljen arra, hogy olyan kódot válasszon, amelyet az összes megjelölt szál el fog érni. A Visual Studio szünetelteti a szálakat a kijelölt kódsoron, így egyszerűbbé válik a végrehajtási sorrend szabályozása a szálak fagyasztásával és felolvaszásával.

4. Válassza ismét a Csak megjelölt szálak megjelenítése gombot, és váltson vissza az Összes szál megjelenítése módra.

5. A szálak törléséhez kattintson a jobb gombbal egy vagy több megjelölt szálra a Párhuzamos figyelő ablakban, és válassza a Feloldás lehetőséget.

Szálvégrehajtás rögzítése és felolvasztása

Jótanács

A szálak rögzítése és felolvasztása (felfüggesztése és folytatása) szabályozhatja, hogy a szálak milyen sorrendben végeznek munkát. Ez segíthet az egyidejűségi problémák, például a holtpontok és a versenyfeltételek megoldásában.

1. A Párhuzamos figyelő ablakban az összes sor ki van jelölve, kattintson a jobb gombbal, és válassza a Rögzítés lehetőséget.

   A második oszlopban minden sorhoz megjelenik egy szüneteltetés ikon. A szüneteltetés ikon azt jelzi, hogy a szál le van fagyasztva.

2. Az összes többi sor kijelölésének megszüntetése csak egy sor kiválasztásával.

3. Kattintson a jobb gombbal egy sorra, és válassza a Thaw lehetőséget.

   A szüneteltetés ikon eltűnik ezen a sorban, ami azt jelzi, hogy a szál már nem fagyott meg.

4. Váltson a kódszerkesztőre, és nyomja le az F11 billentyűt. Csak a kiolvasztott szál fut.

   Előfordulhat, hogy az alkalmazás új szálakat is létrehoz. Az új szálak nincsenek felfújva, és nincsenek lefagyasztva.

Egyetlen szál követése feltételes töréspontokkal

Hasznos lehet követni egy szál végrehajtását a hibakeresőben. Ennek egyik módja az, hogy lefagyasztani a szálakat, amelyek nem érdekelnek. Bizonyos esetekben előfordulhat, hogy egyetlen szálat kell követni, anélkül, hogy más szálak lefagynának, például egy adott hiba reprodukálásához. Ha más szálak lefagyása nélkül szeretne követni egy szálat, el kell kerülnie a kód feltörését, kivéve az önt érdeklő szálat. Ezt a feladatot feltételes töréspont beállításával teheti meg.

A töréspontokat különböző feltételekhez, például a szál nevéhez vagy a szálazonosítóhoz állíthatja be. Hasznos lehet az egyes szálakhoz egyedi adatokra vonatkozó feltétel beállítása. Ez a módszer gyakori a hibakeresés során, ha jobban érdekli egy adott adatérték, mint bármely adott szál.

1. Kattintson a jobb gombbal a korábban létrehozott töréspontra, és válassza a Feltételek lehetőséget.

2. A Töréspont beállításai ablakban adja meg data == 5 a feltételes kifejezést.

   

   Jótanács

   Ha jobban érdekli egy adott szál, használja a feltétel szálnevét vagy szálazonosítóját. Ehhez a Töréspont beállításai ablakban válassza a Feltételes kifejezés helyett a Szűrés lehetőséget, és kövesse a szűrőtippeket. Előfordulhat, hogy el szeretné nevezni a szálakat az alkalmazás kódjában, mivel a szálak azonosítói megváltoznak a hibakereső újraindításakor.

3. Zárja be a Töréspont beállításai ablakot.

4. A hibakeresési munkamenet újraindításához kattintson az gombra.

   A kódrészlet végrehajtása ott történik, ahol az adatváltozó értéke 5. A Párhuzamos figyelő ablakban keresse meg az aktuális hibakereső környezetet jelző sárga nyilat.

5. Most átléphet a kódon (F10) és a kódba (F11), és követheti az egyetlen szál végrehajtását.

   Mindaddig, amíg a töréspont-feltétel egyedi a szálon, és a hibakereső nem talál el más töréspontokat más szálakon (előfordulhat, hogy le kell tiltania őket), átléphet a kódon, és anélkül léphet a kódba, hogy más szálakra váltana.

   Megjegyzés:

   Amikor továbblépsz a hibakeresővel, az összes szál futni fog. A hibakereső azonban nem lép be a kódba más szálakon, hacsak valamelyik másik szál el nem ér egy töréspontot.

Kapcsolódó tartalom

• Többszálú alkalmazások hibakeresése
• Útmutató: Váltás másik szálra hibakeresés közben
• Útmutató: Párhuzamos verem ablakának használata
• Útmutató: A Párhuzamos figyelő ablak használata