Exemplarische Vorgehensweise: Debuggen einer parallelen Anwendung in Visual Studio (C#, Visual Basic, C++)

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie die Fenster "Parallele Aufgaben " und "Parallele Stapel" verwenden, um eine parallele Anwendung zu debuggen. Diese Fenster helfen Ihnen, das Laufzeitverhalten von Code zu verstehen und zu überprüfen, der die Parallelbibliothek (Task Parallel Library, TPL) oder die Parallelitätslaufzeit verwendet. Diese Anleitung enthält Beispielcode mit integrierten Haltepunkten. Nachdem der Code unterbrochen wurde, zeigt die exemplarische Vorgehensweise, wie Sie die Fenster Parallelaufgaben und Parallelstapel verwenden, um den Code zu untersuchen.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben erläutert:

• So zeigen Sie die Aufrufstapel aller Threads in einer Ansicht an.

• So zeigen Sie die Liste der System.Threading.Tasks.Task Instanzen an, die in Ihrer Anwendung erstellt werden.

• So zeigen Sie die tatsächlichen Aufrufstapel von Aufgaben anstelle von Threads an.

• So navigieren Sie zum Code aus den Fenstern "Parallele Aufgaben" und "Parallele Stapel".

• Wie die Fenster mit der Skalierung durch Gruppierung, Zoomen und andere verwandte Funktionen umgehen.

Voraussetzungen

Bei dieser exemplarischen Vorgehensweise wird davon ausgegangen, dass "Nur Mein Code " aktiviert ist (standardmäßig in neueren Versionen von Visual Studio aktiviert). Wählen Sie im Menü "Extras" die Option "Optionen" aus, erweitern Sie den Knoten "Debuggen", wählen Sie "Allgemein" und dann "Nur mein Code aktivieren" (nur verwaltet) aus. Wenn Sie dieses Feature nicht festlegen, können Sie diese exemplarische Vorgehensweise weiterhin verwenden, aber Ihre Ergebnisse unterscheiden sich möglicherweise von den Abbildungen.

C#-Beispiel

Wenn Sie das C#-Beispiel verwenden, wird in dieser exemplarischen Vorgehensweise auch davon ausgegangen, dass externer Code ausgeblendet ist. Wenn Sie umschalten möchten, ob externer Code angezeigt wird, klicken Sie mit der rechten Maustaste auf die Kopfzeile der Namenstabelle des Fensters "Aufrufliste ", und aktivieren oder deaktivieren Sie dann " Externer Code anzeigen". Wenn Sie dieses Feature nicht festlegen, können Sie diese exemplarische Vorgehensweise weiterhin verwenden, aber Ihre Ergebnisse unterscheiden sich möglicherweise von den Abbildungen.

C++-Beispiel

Wenn Sie das C++-Beispiel verwenden, können Sie Verweise auf externen Code in diesem Artikel ignorieren. Externer Code gilt nur für das C#-Beispiel.

Abbildungen

Die Abbildungen in diesem Artikel werden auf einem Computer mit vier Kernen aufgezeichnet, auf dem das C#-Beispiel ausgeführt wird. Obwohl Sie andere Konfigurationen verwenden können, um diese exemplarische Vorgehensweise abzuschließen, unterscheiden sich die Illustrationen möglicherweise von dem, was auf Ihrem Computer angezeigt wird.

Erstellen des Beispielprojekts

Der Beispielcode in dieser exemplarischen Vorgehensweise ist für eine Anwendung vorgesehen, die nichts tut. Der Zweck der Übung besteht darin, zu verstehen, wie sie die Toolfenster zum Debuggen einer parallelen Anwendung verwenden.

1. Öffnen Sie Visual Studio, und erstellen Sie ein neues Projekt.

   Wenn das Startfenster nicht geöffnet ist, wählen Sie Datei>Startfensteraus.

   Wählen Sie im Startfenster " Neues Projekt" aus.

   Geben Sie im Fenster Neues Projekt erstellen im Suchfeld Konsole ein. Wählen Sie als Nächstes C#, C++ oder Visual Basic aus der Liste "Sprache" aus, und wählen Sie dann Windows aus der Liste "Plattform" aus.

   Nachdem Sie die Sprach- und Plattformfilter angewendet haben, wählen Sie die Konsolen-App für .NET Core oder C++ und dann "Weiter" aus.

   Hinweis

   Wenn die richtige Vorlage nicht angezeigt wird, wechseln Sie zu Tools>»Tools und Features abrufen«, wodurch das Visual Studio-Installationsprogramm geöffnet wird. Wählen Sie die .NET-Desktopentwicklung oder Desktopentwicklung mit C++ -Workload aus, und wählen Sie dann "Ändern" aus.

   Geben Sie im Fenster " Neues Projekt konfigurieren " einen Namen ein, oder verwenden Sie den Standardnamen im Feld "Projektname ". Wählen Sie dann "Weiter" oder " Erstellen" aus, je nachdem, welche Option verfügbar ist.

   Wählen Sie für .NET Core entweder das empfohlene Zielframework oder .NET 8 aus, und wählen Sie dann Erstellen aus.

   Ein neues Konsolenprojekt wird angezeigt. Nachdem das Projekt erstellt wurde, wird eine Quelldatei angezeigt.

2. Öffnen Sie die Codedatei .cpp, .cs oder .vb im Projekt. Löschen Sie den Inhalt, um eine leere Codedatei zu erstellen.

3. Fügen Sie den folgenden Code für die ausgewählte Sprache in die leere Codedatei ein.

   C#

   using System;
   using System.Threading;
   using System.Threading.Tasks;
   using System.Diagnostics;
   
   class S
   {
     static void Main()
     {
       pcount = Environment.ProcessorCount;
       Console.WriteLine("Proc count = " + pcount);
       ThreadPool.SetMinThreads(4, -1);
       ThreadPool.SetMaxThreads(4, -1);
   
       t1 = new Task(A, 1);
       t2 = new Task(A, 2);
       t3 = new Task(A, 3);
       t4 = new Task(A, 4);
       Console.WriteLine("Starting t1 " + t1.Id.ToString());
       t1.Start();
       Console.WriteLine("Starting t2 " + t2.Id.ToString());
       t2.Start();
       Console.WriteLine("Starting t3 " + t3.Id.ToString());
       t3.Start();
       Console.WriteLine("Starting t4 " + t4.Id.ToString());
       t4.Start();
   
       Console.ReadLine();
     }
   
     static void A(object o)
     {
       B(o);
     }
     static void B(object o)
     {
       C(o);
     }
     static void C(object o)
     {
       int temp = (int)o;
   
       Interlocked.Increment(ref aa);
       while (aa < 4)
       {
         ;
       }
   
       if (temp == 1)
       {
         // BP1 - all tasks in C
         Debugger.Break();
         waitFor1 = false;
       }
       else
       {
         while (waitFor1)
         {
           ;
         }
       }
       switch (temp)
       {
         case 1:
           D(o);
           break;
         case 2:
           F(o);
           break;
         case 3:
         case 4:
           I(o);
           break;
         default:
           Debug.Assert(false, "fool");
           break;
       }
     }
     static void D(object o)
     {
       E(o);
     }
     static void E(object o)
     {
       // break here at the same time as H and K
       while (bb < 2)
       {
         ;
       }
       //BP2 - 1 in E, 2 in H, 3 in J, 4 in K
       Debugger.Break();
       Interlocked.Increment(ref bb);
   
       //after
       L(o);
     }
     static void F(object o)
     {
       G(o);
     }
     static void G(object o)
     {
       H(o);
     }
     static void H(object o)
     {
       // break here at the same time as E and K
       Interlocked.Increment(ref bb);
       Monitor.Enter(mylock);
       while (bb < 3)
       {
         ;
       }
       Monitor.Exit(mylock);
   
   
       //after
       L(o);
     }
     static void I(object o)
     {
       J(o);
     }
     static void J(object o)
     {
       int temp2 = (int)o;
   
       switch (temp2)
       {
         case 3:
           t4.Wait();
           break;
         case 4:
           K(o);
           break;
         default:
           Debug.Assert(false, "fool2");
           break;
       }
     }
     static void K(object o)
     {
       // break here at the same time as E and H
       Interlocked.Increment(ref bb);
       Monitor.Enter(mylock);
       while (bb < 3)
       {
         ;
       }
       Monitor.Exit(mylock);
   
   
       //after
       L(o);
     }
     static void L(object oo)
     {
       int temp3 = (int)oo;
   
       switch (temp3)
       {
         case 1:
           M(oo);
           break;
         case 2:
           N(oo);
           break;
         case 4:
           O(oo);
           break;
         default:
           Debug.Assert(false, "fool3");
           break;
       }
     }
     static void M(object o)
     {
       // breaks here at the same time as N and Q
       Interlocked.Increment(ref cc);
       while (cc < 3)
       {
         ;
       }
       //BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
       Debugger.Break();
       Interlocked.Increment(ref cc);
       while (true)
         Thread.Sleep(500); // for ever
     }
     static void N(object o)
     {
       // breaks here at the same time as M and Q
       Interlocked.Increment(ref cc);
       while (cc < 4)
       {
         ;
       }
       R(o);
     }
     static void O(object o)
     {
       Task t5 = Task.Factory.StartNew(P, TaskCreationOptions.AttachedToParent);
       t5.Wait();
       R(o);
     }
     static void P()
     {
       Console.WriteLine("t5 runs " + Task.CurrentId.ToString());
       Q();
     }
     static void Q()
     {
       // breaks here at the same time as N and M
       Interlocked.Increment(ref cc);
       while (cc < 4)
       {
         ;
       }
       // task 5 dies here freeing task 4 (its parent)
       Console.WriteLine("t5 dies " + Task.CurrentId.ToString());
       waitFor5 = false;
     }
     static void R(object o)
     {
       if ((int)o == 2)
       {
         //wait for task5 to die
         while (waitFor5) { ;}
   
   
         int i;
         //spin up all procs
         for (i = 0; i < pcount - 4; i++)
         {
           Task t = Task.Factory.StartNew(() => { while (true);});
           Console.WriteLine("Started task " + t.Id.ToString());
         }
   
         Task.Factory.StartNew(T, i + 1 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, i + 2 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, i + 3 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, i + 4 + 5, TaskCreationOptions.AttachedToParent); //scheduled
         Task.Factory.StartNew(T, (i + 5 + 5).ToString(), TaskCreationOptions.AttachedToParent); //scheduled
   
         //BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died
         Debugger.Break();
       }
       else
       {
         Debug.Assert((int)o == 4);
         t3.Wait();
       }
     }
     static void T(object o)
     {
       Console.WriteLine("Scheduled run " + Task.CurrentId.ToString());
     }
     static Task t1, t2, t3, t4;
     static int aa = 0;
     static int bb = 0;
     static int cc = 0;
     static bool waitFor1 = true;
     static bool waitFor5 = true;
     static int pcount;
     static S mylock = new S();
   }
   

   VB

   Imports System
   Imports System.Threading
   Imports System.Threading.Tasks
   Imports System.Diagnostics
   
   Module S
   
     Sub Main()
   
       pcount = Environment.ProcessorCount
       Console.WriteLine("Proc count = " + pcount.ToString())
       ThreadPool.SetMinThreads(4, -1)
       ThreadPool.SetMaxThreads(4, -1)
   
       t1 = New Task(AddressOf A, 1)
       t2 = New Task(AddressOf A, 2)
       t3 = New Task(AddressOf A, 3)
       t4 = New Task(AddressOf A, 4)
       Console.WriteLine("Starting t1 " + t1.Id.ToString())
       t1.Start()
       Console.WriteLine("Starting t2 " + t2.Id.ToString())
       t2.Start()
       Console.WriteLine("Starting t3 " + t3.Id.ToString())
       t3.Start()
       Console.WriteLine("Starting t4 " + t4.Id.ToString())
       t4.Start()
   
       Console.ReadLine()
     End Sub
     Sub A(ByVal o As Object)
       B(o)
     End Sub
     Sub B(ByVal o As Object)
       C(o)
     End Sub
     Sub C(ByVal o As Object)
   
       Dim temp As Integer = o
   
       Interlocked.Increment(aa)
       While (aa < 4)
       End While
   
       If (temp = 1) Then
         ' BP1 - all tasks in C
         Debugger.Break()
         waitFor1 = False
       Else
         While (waitFor1)
         End While
       End If
       Select Case temp
         Case 1
           D(o)
         Case 2
           F(o)
         Case 3, 4
           I(o)
         Case Else
           Debug.Assert(False, "fool")
       End Select
     End Sub
     Sub D(ByVal o As Object)
       E(o)
     End Sub
     Sub E(ByVal o As Object)
       ' break here at the same time as H and K
       While (bb < 2)
       End While
       'BP2 - 1 in E, 2 in H, 3 in J, 4 in K
       Debugger.Break()
       Interlocked.Increment(bb)
   
       'after
       L(o)
     End Sub
     Sub F(ByVal o As Object)
       G(o)
     End Sub
     Sub G(ByVal o As Object)
       H(o)
     End Sub
     Sub H(ByVal o As Object)
       ' break here at the same time as E and K
       Interlocked.Increment(bb)
       Monitor.Enter(mylock)
       While (bb < 3)
       End While
       Monitor.Exit(mylock)
   
       'after
       L(o)
     End Sub
     Sub I(ByVal o As Object)
       J(o)
     End Sub
     Sub J(ByVal o As Object)
   
       Dim temp2 As Integer = o
   
       Select Case temp2
         Case 3
           t4.Wait()
         Case 4
           K(o)
         Case Else
           Debug.Assert(False, "fool2")
       End Select
     End Sub
     Sub K(ByVal o As Object)
       ' break here at the same time as E and H
       Interlocked.Increment(bb)
       Monitor.Enter(mylock)
       While (bb < 3)
       End While
       Monitor.Exit(mylock)
   
       'after
       L(o)
     End Sub
     Sub L(ByVal oo As Object)
       Dim temp3 As Integer = oo
   
       Select Case temp3
         Case 1
           M(oo)
         Case 2
           N(oo)
         Case 4
           O(oo)
         Case Else
           Debug.Assert(False, "fool3")
       End Select
     End Sub
     Sub M(ByVal o As Object)
       ' breaks here at the same time as N and Q
       Interlocked.Increment(cc)
       While (cc < 3)
       End While
   
       'BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
       Debugger.Break()
       Interlocked.Increment(cc)
       While (True)
         Thread.Sleep(500) '  for ever
       End While
     End Sub
     Sub N(ByVal o As Object)
       ' breaks here at the same time as M and Q
       Interlocked.Increment(cc)
       While (cc < 4)
       End While
       R(o)
     End Sub
     Sub O(ByVal o As Object)
       Dim t5 As Task = Task.Factory.StartNew(AddressOf P, TaskCreationOptions.AttachedToParent)
       t5.Wait()
       R(o)
     End Sub
     Sub P()
       Console.WriteLine("t5 runs " + Task.CurrentId.ToString())
       Q()
     End Sub
     Sub Q()
       ' breaks here at the same time as N and M
       Interlocked.Increment(cc)
       While (cc < 4)
       End While
       ' task 5 dies here freeing task 4 (its parent)
       Console.WriteLine("t5 dies " + Task.CurrentId.ToString())
       waitFor5 = False
     End Sub
     Sub R(ByVal o As Object)
       If (o = 2) Then
         ' wait for task5 to die
         While waitFor5
         End While
   
         '//spin up all procs
         Dim i As Integer
         For i = 0 To pcount - 4 - 1
   
           Dim t As Task = Task.Factory.StartNew(Sub()
                                                   While True
   
                                                   End While
                                                 End Sub)
           Console.WriteLine("Started task " + t.Id.ToString())
         Next
   
         Task.Factory.StartNew(AddressOf T, i + 1 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, i + 2 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, i + 3 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, i + 4 + 5, TaskCreationOptions.AttachedToParent) ' //scheduled
         Task.Factory.StartNew(AddressOf T, (i + 5 + 5).ToString(), TaskCreationOptions.AttachedToParent) ' //scheduled
   
         '//BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died
         Debugger.Break()
   
       Else
         Debug.Assert(o = 4)
         t3.Wait()
       End If
     End Sub
     Sub T(ByVal o As Object)
       Console.WriteLine("Scheduled run " + Task.CurrentId.ToString())
     End Sub
     Private t1, t2, t3, t4 As Task
     Private aa As Integer = 0
     Private bb As Integer = 0
     Private cc As Integer = 0
     Private waitFor1 As Boolean = True
     Private waitFor5 As Boolean = True
     Private pcount As Integer
     Private mylock As New S2()
   End Module
   
   Public Class S2
   
   End Class
   

   C++

   #include "stdafx.h"
   #include <windows.h>
   #include <iostream>
   #include <ppl.h>
   #include <agents.h>
   #include <stdio.h>
   #include <concrtrm.h>
   #include <vector>
   
   CRITICAL_SECTION cs;
   
   using namespace ::std;
   using namespace ::std::tr1;
   using namespace ::Concurrency;
   task_group task4;
   task_group task3;
   task_group task2;
   
   volatile long aa = 0;
   volatile long bb = 0;
   volatile long cc = 0;
   static bool waitFor1 = true;
   static bool waitFor5 = true;
   
   #pragma optimize("", off)
   void Spin()
   {
      for(int i=0;i<50*50000;++i);
   }
   #pragma optimize("",on)
   
   template<class Func>
   class RunFunc
   {
      Func& m_Func;
      int m_o;
   public:
      RunFunc(Func func,int o):m_Func(func),m_o(o){
   
      };
      void operator()()const{
         m_Func(m_o);
      };
   };
   
   void T(int o)
   {
      cout << "Scheduled run \n";
   
   };
   
   void R(int o)
   {
      if (o == 2)
      {
         while (waitFor5) { ;}
         Spin();
   
         //use up all processors but 4 by scheduling 4 non-terminating tasks.
         int numProcsToBurn = GetProcessorCount() - 4;
         int i;
         vector<call<int>*> tasks;
         for (i = 0; i <  numProcsToBurn; i++)
         {
            tasks.push_back(new call<int>([](int i){while(true)Spin();}));
            asend(tasks[i],1);
            cout << "Started task  \n";
         }
   
         task_handle<RunFunc<decltype(T)>> t6(RunFunc<decltype(T)>(T,i + 1 + 5));
         task_handle<RunFunc<decltype(T)>> t7(RunFunc<decltype(T)>(T,i + 2 + 5));
         task_handle<RunFunc<decltype(T)>> t8(RunFunc<decltype(T)>(T,i + 3 + 5));
         task_handle<RunFunc<decltype(T)>> t9(RunFunc<decltype(T)>(T,i + 4 + 5));
         task_handle<RunFunc<decltype(T)>> t10(RunFunc<decltype(T)>(T,i + 5 + 5));
         task2.run(t6);
         task2.run(t7);
         task2.run(t8);
         task2.run(t9);
         task2.run(t10);
      
         //BP4 - 1 in M, 2 in R, 3 in J, 4 in R, 5 died   
         DebugBreak();
      }
      else
      {
         if (o!=4)
            throw;
   
         task3.wait();      
      }
   };
   
   void Q()
   {
      // breaks here at the same time as N and M
      InterlockedIncrement(& cc);
      while (cc < 4)
      {
         ;
      }
      // task 5 dies here freeing task 4 (its parent)
      cout << "t5 dies\n";
      waitFor5 = false;
   };
   
   void P()
   {
      cout << "t5 runs\n";
      Q();
   };
   
   void O(int o)
   {   
      task_group t5;
      t5.run(&P);
      t5.wait();
      R(o);
   };
   
   void N(int o)
   {
      // breaks here at the same time as M and Q
      InterlockedIncrement(&cc);
      while (cc < 4)
      {
         ;
      }
      R(o);
   };
   
   void M(int o)
   {
      // breaks here at the same time as N and Q
      InterlockedIncrement(&cc);
      while (cc < 3)
      {
         ;
      }
      //BP3 - 1 in M, 2 in N, 3 still in J, 4 in O, 5 in Q
      DebugBreak();
      InterlockedIncrement(&cc);
      while (true)
         Sleep(500); // for ever
   };
   
   void L(int oo)
   {
      int temp3 = oo;
   
      switch (temp3)
      {
      case 1:
         M(oo);
         break;
      case 2:
         N(oo);
         break;
      case 4:
         O(oo);
         break;
      default:
         throw; //fool3
         break;
      }
   }
   void K(int o)
   {
      // break here at the same time as E and H
      InterlockedIncrement(&bb);
      EnterCriticalSection(&cs);
      while (bb < 3)
      {
         ;
      }
      LeaveCriticalSection(&cs);
      Spin();
   
      //after
      L(o);
   }
   void J(int o)
   {
      int temp2 = o;
   
      switch (temp2)
      {
      case 3:
         task4.wait();
         break;
      case 4:
         K(o);
         break;
      default:
         throw; //fool2
         break;
      }
   }
   static void I(int o)
   {
      J(o);
   }
   static void H(int o)
   {
      // break here at the same time as E and K
      InterlockedIncrement(&bb);
      EnterCriticalSection(&cs);
      while (bb < 3)
      {
         ;
      }
      LeaveCriticalSection(&cs);
      Spin();
   
      //after
      L(o);
   }
   static void G(int o)
   {
      H(o);
   }
   static void F(int o)
   {
      G(o);
   }
   
   static void E(int o)
   {
      // break here at the same time as H and K
      while (bb < 2)
      {
         ;
      }
      //BP2 - 1 in E, 2 in H, 3 in J, 4 in K   
      Spin(); // for native case only
      DebugBreak();
      InterlockedIncrement(&bb);
   
      //after
      L(o);
   
   }
   
   static void D(int o)
   {
      E(o);
   }
   
   static void C(int o)
   {
      int temp = o;
   
      InterlockedIncrement(&aa);
      while (aa < 4)
      {
         ;
      }
   
      if (temp == 1)
      {
         // BP1 - all tasks in C   
         DebugBreak();
         waitFor1 = false;
      }
      else
      {
         while (waitFor1)
         {
            ;
         }
      }
      switch (temp)
      {
      case 1:
         D(o);
         break;
      case 2:
         F(o);
         break;
      case 3:
      case 4:
         I(o);
         break;
      default:
         throw; //fool
         break;
      }
   }
   static void B(int o)
   {
      C(o);
   }
   
   void A(int o)
   {
      B(o);
   }
   int main()
   {
      InitializeCriticalSection(&cs);
   
      task_group tasks;
      task_handle<RunFunc<decltype(A)>> t1(RunFunc<decltype(A)>(A,1));
      tasks.run(t1);
      task_handle<RunFunc<decltype(A)>> t2(RunFunc<decltype(A)>(A,2));
      task2.run(t2);
      task_handle<RunFunc<decltype(A)>> t3(RunFunc<decltype(A)>(A,3));
      task3.run(t3);
      task_handle<RunFunc<decltype(A)>> t4(RunFunc<decltype(A)>(A,4));
      task4.run(t4);
      
      getchar();
      return 1;
   }
   

---

Nachdem Sie die Codedatei aktualisiert haben, speichern Sie Die Änderungen, und erstellen Sie die Lösung.

1. Wählen Sie im Menü "Datei " die Option "Alle speichern" aus.

2. Wählen Sie im Menü Erstellen die Option Lösung neu erstellen aus.

Beachten Sie, dass es vier Aufrufe gibt Debugger.Break (DebugBreak im C++-Beispiel). Daher müssen Sie keine Haltepunkte einfügen. Wenn Sie die Anwendung gerade ausführen, wird sie im Debugger bis zu vier Mal abgebrochen.

"Verwenden Sie die Ansicht im Fenster 'Parallele Stapel: Threads'"

Wählen Sie zunächst im Menü " Debuggen " die Option "Debuggen starten" aus. Warten Sie, bis der erste Haltepunkt erreicht ist.

Anzeigen des Aufrufstapels eines einzelnen Threads

1. Zeigen Sie im Menü "Debuggen" auf "Windows" und wählen Sie dann "Threads" aus. Docken Sie das Threads-Fenster am unteren Rand von Visual Studio an.

2. Zeigen Sie im Menü Debuggen auf Windows und wählen Sie dann Aufrufliste aus. Andocken Sie das Fenster "Anrufstapel " am unteren Rand von Visual Studio.

3. Doppelklicken Sie im Threads-Fenster auf einen Thread, um ihn aktuell zu machen. Aktuelle Threads weisen einen gelben Pfeil auf. Wenn Sie den aktuellen Thread ändern, wird dessen Aufrufstapel im Fenster "Anrufstapel " angezeigt.

Untersuchen Sie das Fenster "Parallele Stapel"

Zeigen Sie im Menü "Debuggen " auf Windows , und wählen Sie dann "Parallele Stapel" aus. Stellen Sie sicher, dass Threads im Feld in der oberen linken Ecke ausgewählt sind.

Mithilfe des Fensters "Parallele Stapel" können Sie mehrere Aufrufstapel gleichzeitig in einer Ansicht anzeigen. Die folgende Abbildung zeigt das Fenster "Parallele Stapel" oberhalb des Fensters "Aufrufstapel ".

Der Aufrufstapel des Hauptthreads wird in einem Feld angezeigt, und die Aufrufstapel für die anderen vier Threads werden in einem anderen Feld gruppiert. Vier Threads werden gruppiert, da ihre Stapelframes dieselben Methodenkontexte aufweisen; das heißt, sie befinden sich in den gleichen Methoden: A, , Bund C. Um die Thread-IDs und Namen der Threads anzuzeigen, die dasselbe Feld gemeinsam verwenden, zeigen Sie mit der Maus auf das Feld mit der Kopfzeile ([#] Threads). Der aktuelle Thread wird fett formatiert angezeigt.

Der gelbe Pfeil gibt den aktiven Stapelrahmen des aktuellen Threads an.

Sie können festlegen, wie viele Details für die Stapelframes (Modulnamen, Parametertypen, Parameternamen, Parameterwerte, Zeilennummern und Byte-Offsets) angezeigt werden sollen, indem Sie im Fenster "Aufrufstapel " mit der rechten Maustaste klicken.

Eine blaue Hervorhebung um ein Feld zeigt an, dass der aktuelle Thread Teil dieses Felds ist. Der aktuelle Thread wird auch durch den fett formatierten Stackframe im Tooltip angegeben. Wenn Sie im Threads-Fenster auf den Hauptthread doppelklicken, können Sie beobachten, dass der Hervorhebungspfeil im Fenster "Parallele Stapel" entsprechend verschoben wird.

Fortsetzen der Ausführung bis zum zweiten Haltepunkt

Um die Ausführung fortzusetzen, bis der zweite Haltepunkt erreicht ist, wählen Sie im Menü "Debuggen" die Option "Weiter" aus. Die folgende Abbildung zeigt die Threadbaumstruktur am zweiten Haltepunkt.

Am ersten Haltepunkt gingen alle vier Threads von der Methode S.A zur Methode S.B und anschließend zur Methode S.C. Diese Informationen sind weiterhin im Fenster "Parallele Stapel" sichtbar, aber die vier Threads sind weiter vorangekommen. Einer von ihnen fuhr nach S.D und dann S.E. Eine weitere weiter nach S.F, S.G und S.H. Zwei andere fuhren nach S.I und S.J, und von dort ging einer von ihnen nach S.K und die andere weiter zu Nichtbenutzer-externem Code.

Sie können mit dem Mauszeiger auf Stapelframes zeigen, um Thread-IDs sowie weitere Framedetails anzuzeigen. Die blaue Hervorhebung gibt den aktuellen Thread an, und der gelbe Pfeil gibt den aktiven Stapelrahmen des aktuellen Threads an.

Das Symbol für "Gewebefäden" (verflochtene Linien) zeigt die aktiven Stapelrahmen der nicht aktuellen Threads an. Doppelklicken Sie im Fenster "Anrufstapel " auf S.B, um Frames zu wechseln. Das Fenster "Parallele Stapel" gibt den aktuellen Stapelrahmen des aktuellen Threads mithilfe eines gekrümmten Pfeilsymbols an.

Hinweis

Eine Beschreibung aller Symbole im Fenster "Parallele Stapel" finden Sie unter Verwenden des Fensters "Parallele Stapel".

Wechseln Sie im Fenster "Threads " zwischen Threads, und beobachten Sie, dass die Ansicht im Fenster "Parallele Stapel" aktualisiert wird.

Sie können zu einem anderen Thread oder zu einem anderen Frame eines anderen Threads wechseln, indem Sie das Kontextmenü im Fenster "Parallele Stapel" verwenden. Klicken Sie z. B. mit der rechten Maustaste auf S.J, zeigen Sie auf "Zu Frame wechseln", und wählen Sie dann einen Befehl aus.

Klicken Sie mit der rechten Maustaste auf S.C und wählen Sie "Zu Frame wechseln" aus. Einer der Befehle weist ein Häkchen auf, das den Stapelrahmen des aktuellen Threads angibt. Sie können zu diesem Rahmen desselben Threads wechseln (nur der gekrümmte Pfeil bewegt), oder Sie können zum anderen Thread wechseln (die blaue Hervorhebung wird ebenfalls verschoben). Die folgende Abbildung zeigt das Untermenü.

Bei großen Anwendungen mit vielen Threads sollten Sie sich möglicherweise nur auf eine Teilmenge von Threads konzentrieren. Das Fenster "Parallele Stapel" kann Aufrufstapel nur für gekennzeichnete Threads anzeigen. Verwenden Sie zum Kennzeichnen von Threads das Kontextmenü oder die erste Zelle eines Threads.

Wählen Sie auf der Symbolleiste die Schaltfläche " Nur gekennzeichnet anzeigen " neben dem Listenfeld aus.

Jetzt werden nur gekennzeichnete Threads im Fenster "Parallele Stapel" angezeigt.

Ausführung fortsetzen bis zum dritten Haltepunkt

1. Um die Ausführung fortzusetzen, bis der dritte Haltepunkt erreicht ist, wählen Sie im Menü "Debuggen " die Option "Weiter" aus.

   Wenn sich mehrere Threads in derselben Methode befinden, die Methode aber nicht am Anfang des Aufrufstapels lag, wird die Methode in verschiedenen Feldern angezeigt. Ein Beispiel für den aktuellen Unterbrechungspunkt ist S.L., das drei Stränge enthält und in drei Feldern angezeigt wird. Doppelklicken Sie auf S.L.

   

   Beachten Sie, dass S.L in den anderen beiden Feldern fett formatiert ist, damit Sie sehen können, wo sie sonst angezeigt wird. Wenn Sie sehen möchten, welche Rahmen in S.L aufgerufen werden und welche Rahmen von S.L aufgerufen werden, wählen Sie auf der Symbolleiste die Schaltfläche "Ansicht auf Methoden umschalten" aus. Die folgende Abbildung zeigt die Methodenansicht des Fensters „Parallele Stapel“.

   

   Beachten Sie, wie das Diagramm auf die ausgewählte Methode pivotiert und in einem eigenen Feld in der Mitte der Ansicht positioniert wurde. Die Angerufenen und Anrufer werden oben bzw. unten angezeigt. Wählen Sie die Schaltfläche " Methodenansicht umschalten " erneut aus, um diesen Modus zu verlassen.

   Das Kontextmenü des Fensters "Parallele Stapel" enthält auch die folgenden anderen Elemente.

   • Hexadezimalanzeige schaltet die Zahlen in den Tooltips zwischen dezimal und hexadezimal um.

   • Symboleinstellungen öffnen die entsprechenden Dialogfelder.

   • Anzeigen von Threads in Der Quelle schaltet die Anzeige von Threadmarkierungen in Ihrem Quellcode um, wodurch die Position von Threads im Quellcode angezeigt wird.

   • "Externer Code anzeigen" zeigt alle Frames an, auch wenn sie sich nicht im Benutzercode befinden. Versuchen Sie es, um zu sehen, wie sich das Diagramm erweitert, um die anderen Frames aufzunehmen (die möglicherweise abgeblendet sind, weil Sie dafür keine Symbole haben).

2. Stellen Sie im Fenster "Parallele Stapel" sicher, dass sich die Schaltfläche " Automatischer Bildlauf zum aktuellen Stapelrahmen " auf der Symbolleiste befindet.

   Wenn Sie über große Diagramme verfügen und zum nächsten Haltepunkt wechseln, möchten Sie möglicherweise, dass die Ansicht automatisch zum aktiven Stapelframe des aktuellen Threads scrollen soll. d. h. der Thread, der zuerst auf den Haltepunkt trifft.

3. Bevor Sie fortfahren, scrollen Sie im Fenster "Parallele Stapel" ganz nach links und nach unten.

Fortsetzen der Ausführung bis zum vierten Haltepunkt

1. Um die Ausführung fortzusetzen, bis der vierte Haltepunkt erreicht ist, wählen Sie im Menü "Debuggen " die Option "Weiter" aus.

   Beachten Sie, wie die Ansicht automatisch in die Position eingerollt wurde. Wechseln Sie zwischen Threads im Threads-Fenster oder wechseln Sie zwischen Stack-Frames im Aufrufstapel-Fenster und beachten Sie, wie die Ansicht immer automatisch zu den richtigen Frames scrollt. Deaktivieren Sie die Option Automatischer Bildlauf zum aktuellen Werkzeugrahmen und zeigen Sie den Unterschied an.

   Die Vogelperspektive hilft auch bei großen Diagrammen im Fenster "Parallele Stapel" . Standardmäßig ist die Vogelperspektive aktiviert. Sie können die Einstellung jedoch umschalten, indem Sie auf die Schaltfläche zwischen den Bildlaufleisten in der unteren rechten Ecke des Fensters klicken, wie in der folgenden Abbildung dargestellt.

   

   In der Vogelperspektive können Sie das Rechteck verschieben, um schnell durch das Diagramm zu navigieren.

   Eine weitere Möglichkeit zum Verschieben des Diagramms in eine beliebige Richtung besteht darin, einen leeren Bereich des Diagramms auszuwählen und an die gewünschte Stelle zu ziehen.

   Wenn Sie das Diagramm vergrößern und verkleineren möchten, halten Sie STRG gedrückt, während Sie das Mausrad bewegen. Wählen Sie alternativ die Zoomschaltfläche auf der Symbolleiste aus, und verwenden Sie dann das Zoomtool.

2. Bevor Sie fortfahren, wählen Sie im Menü " Debuggen " die Option " Debuggen beenden " aus, um die Ausführung zu beenden.

Verwenden Sie das Fenster "Parallele Vorgänge" und die "Vorgangsansicht" des Fensters "Parallele Stapel"

Es wird empfohlen, die früheren Verfahren abzuschließen, bevor Sie fortfahren.

Starten Sie die Anwendung neu, bis der erste Haltepunkt erreicht ist:

1. Wählen Sie im Menü " Debuggen " die Option "Debuggen starten " aus, und warten Sie, bis der erste Haltepunkt erreicht wurde.

2. Zeigen Sie im Menü "Debuggen" auf "Windows" und wählen Sie dann "Threads" aus. Docken Sie das Threads-Fenster am unteren Rand von Visual Studio an.

3. Zeigen Sie im Menü "Debuggen" auf Windows, und wählen Sie "Aufrufstapel" aus. Docken Sie das Fenster "Anrufstapel " am unteren Rand von Visual Studio an.

4. Doppelklicken Sie im Threads-Fenster auf einen Thread, um ihn aktuell zu machen. Aktuelle Threads weisen den gelben Pfeil auf. Wenn Sie den aktuellen Thread ändern, werden die anderen Fenster aktualisiert. Als Nächstes untersuchen wir Aufgaben.

5. Zeigen Sie im Menü " Debuggen " auf Windows, und wählen Sie dann "Aufgaben" aus. Die folgende Abbildung zeigt das Fenster "Aufgaben ".

   

   Für jede laufende Aufgabe können Sie die ID ablesen, die von der gleichnamigen Eigenschaft zurückgegeben wird, sowie die ID und den Namen des Threads, der sie ausführt, und deren Position. Bewegen Sie den Mauszeiger darüber, um eine QuickInfo mit dem gesamten Aufrufstapel anzuzeigen. Außerdem können Sie in der Spalte " Aufgabe " die Methode sehen, die an den Vorgang übergeben wurde. Mit anderen Worten, der Ausgangspunkt.

   Sie können eine beliebige Spalte sortieren. Beachten Sie die Sortierglyphe, die die Sortierspalte und -richtung angibt. Sie können die Spalten auch neu anordnen, indem Sie sie nach links oder rechts ziehen.

   Der gelbe Pfeil gibt den aktuellen Vorgang an. Sie können Aufgaben wechseln, indem Sie auf eine Aufgabe doppelklicken oder das Kontextmenü verwenden. Wenn Sie Aufgaben wechseln, wird der zugrunde liegende Thread aktuell, und die anderen Fenster werden aktualisiert.

   Wenn Sie manuell von einer Aufgabe zu einer anderen wechseln, gibt die Pfeilgliederung den aktuellen Debuggerkontext für eine nicht aktuelle Aufgabe an.

Fortsetzen der Ausführung bis zum zweiten Haltepunkt

Um die Ausführung fortzusetzen, bis der zweite Haltepunkt erreicht ist, wählen Sie im Menü "Debuggen" die Option "Weiter" aus.

Zuvor hat die Spalte "Status " alle Vorgänge als "Aktiv" angezeigt, aber jetzt sind zwei der Aufgaben blockiert. Aufgaben können aus vielen verschiedenen Gründen blockiert werden. Zeigen Sie in der Spalte "Status " auf eine Warteaufgabe, um zu erfahren, warum sie blockiert ist. In der folgenden Abbildung wartet beispielsweise Aufgabe 11 auf Aufgabe 12.

Sie können eine Aufgabe kennzeichnen, indem Sie in der ersten Spalte des Fensters "Aufgaben " auf die Kennzeichnung klicken.

Sie können die Kennzeichnung verwenden, um Aufgaben zwischen verschiedenen Haltepunkten in derselben Debugsitzung nachzuverfolgen oder nach Aufgaben zu filtern, deren Aufrufstapel im Fenster "Parallele Stapel" angezeigt werden.

Wenn Sie zuvor das Fenster "Parallele Stapel" verwendet haben, haben Sie die Anwendungsthreads angezeigt. Zeigen Sie das Fenster "Parallele Stapel" erneut an, aber dieses Mal zeigen Sie die Anwendungsaufgaben an. Wählen Sie dazu "Aufgaben" im Feld oben links aus. Die folgende Abbildung zeigt die Aufgabenansicht.

Threads, die derzeit keine Aufgaben ausführen, werden nicht in der Aufgabenansicht des Fensters "Parallele Stapel" angezeigt. Außerdem werden für Threads, die Aufgaben ausführen, einige der Stapelframes, die für Aufgaben nicht relevant sind, vom oberen und unteren Rand des Stapels gefiltert.

Zeigen Sie das Fenster "Aufgaben " erneut an. Klicken Sie mit der rechten Maustaste auf eine beliebige Spaltenüberschrift, um ein Kontextmenü für die Spalte anzuzeigen.

Sie können das Kontextmenü verwenden, um Spalten hinzuzufügen oder zu entfernen. Die Spalte "AppDomain" ist beispielsweise nicht ausgewählt. daher wird sie nicht in der Liste angezeigt. Wählen Sie "Übergeordnetes Element" aus. Die übergeordnete Spalte erscheint ohne Werte für keinen der vier Aufgaben.

Ausführung fortsetzen bis zum dritten Haltepunkt

Um die Ausführung fortzusetzen, bis der dritte Haltepunkt erreicht ist, wählen Sie im Menü "Debuggen " die Option "Weiter" aus.

Beachten Sie in diesem Beispiel, dass Aufgabe 11 und Aufgabe 12 im selben Thread ausgeführt werden (die Spalte "Threadzuweisung " anzeigen, wenn sie ausgeblendet ist). Diese Informationen werden nicht im Threads-Fenster angezeigt. Hier sehen Sie einen weiteren Vorteil des Fensters "Aufgaben ". Um dies zu bestätigen, zeigen Sie das Fenster "Parallele Stapel" an. Stellen Sie sicher, dass Sie Aufgaben anzeigen. Sie können Aufgaben 11 und 12 lokalisieren, indem Sie die Tooltips im Fenster Parallel Stacks anzeigen.

Fortsetzen der Ausführung bis zum vierten Haltepunkt

Um die Ausführung fortzusetzen, bis der dritte Haltepunkt erreicht ist, wählen Sie im Menü "Debuggen " die Option "Weiter" aus. Wählen Sie die ID-Spaltenüberschrift aus, um nach ID zu sortieren. Sie sollten die folgende Abbildung sehen.

Aufgabe 10 und Vorgang 11 warten nun aufeinander und werden blockiert. Es gibt auch mehrere neue Vorgänge, die jetzt geplant sind. Geplante Aufgaben sind Aufgaben, die im Code gestartet wurden, aber noch nicht ausgeführt wurden. Daher zeigen die Spalten "Standort" und "Threadzuweisung " Standardmeldungen an oder sind leer.

Sie können die Aufgaben nach Spalte gruppieren. Klicken Sie im Fenster "Aufgaben " mit der rechten Maustaste auf die Spaltenüberschrift "Status ", und wählen Sie dann " Nach Status gruppieren" aus. Die folgende Abbildung zeigt das Fenster "Aufgaben " nach Status gruppiert.

Sie können auch nach jeder anderen Spalte gruppieren. Durch Gruppieren von Aufgaben können Sie sich auf eine Teilmenge von Aufgaben konzentrieren. Jede aufklappbare Gruppe weist die Anzahl der Elemente auf, die gruppiert sind.

Das letzte Zu untersuchende Feature des Fensters "Aufgaben " ist das Kontextmenü, das angezeigt wird, wenn Sie mit der rechten Maustaste auf eine Aufgabe klicken.

Im Kontextmenü werden je nach Status der Aufgabe unterschiedliche Befehle angezeigt. Die Befehle könnten Folgendes umfassen: „Kopieren“, „Alle auswählen“, „Hexadezimalanzeige“, „Zu Aufgabe wechseln“, „Zugewiesenen Thread fixieren“, „Alle Threads außer diesem fixieren“, „Zugewiesenen Thread freigeben“ sowie „Flag“.

Sie können den zugrunde liegenden Thread einer Aufgabe oder Aufgaben fixieren, oder Sie können alle Threads außer dem zugewiesenen fixieren. Ein fixierter Thread wird im Fenster "Aufgaben " wie im Fenster "Threads " durch ein blaues Pausensymbol dargestellt.

Zusammenfassung

In dieser exemplarischen Vorgehensweise wurden die Debuggerfenster Parallele Aufgaben und Parallel Stacks veranschaulicht. Verwenden Sie diese Fenster für echte Projekte, die Multithread-Code verwenden. Sie können parallelen Code untersuchen, der in C++, C# oder Visual Basic geschrieben wurde.

Verwandte Inhalte

• Debuggen von Multithread-Anwendungen
• Erster Einblick in den Debugger
• Debuggen von verwaltetem Code
• parallele Programmierung
• Parallelitätslaufzeit
• Das Fenster für parallele Stapel verwenden
• Verwenden des Aufgabenfensters