Procedura dettagliata: debug di un'applicazione parallela in Visual Studio (C#, Visual Basic, C++)

In questa procedura dettagliata viene illustrato come usare le finestre Attività in parallelo e Stack in parallelo per eseguire il debug di un'applicazione parallela. Queste finestre consentono di comprendere e verificare il comportamento di runtime del codice che usa la libreria TPL (Task Parallel Library) o il runtime di concorrenza. Nella procedura dettagliata viene fornito un esempio di codice con punti di interruzione incorporati. Una volta interrotta l'esecuzione del codice, viene illustrato come esaminarlo usando le finestre Attività in parallelo e Stack in parallelo.

Nella procedura dettagliata vengono spiegate le seguenti attività:

• Come visualizzare gli stack di chiamate di tutti i thread in un'unica visualizzazione.

• Come visualizzare l'elenco delle istanze di System.Threading.Tasks.Task create nell'applicazione.

• Come visualizzare gli stack di chiamate reali delle attività anziché dei thread.

• Come passare al codice dalle finestre Attività in parallelo e Stack in parallelo.

• Come le finestre affrontano il ridimensionamento tramite il raggruppamento, lo zoom e altre funzionalità correlate.

Prerequisiti

Questa procedura dettagliata presuppone che Just My Code sia abilitato (è abilitato per impostazione predefinita nelle versioni più recenti di Visual Studio). Nel menu Strumenti selezionare Opzioni, espandere il nodo Debug, selezionare Generale e quindi selezionare Abilita Just My Code (solo gestito) . Se non si imposta questa funzionalità, è comunque possibile usare questa procedura dettagliata, ma i risultati potrebbero differire dalle illustrazioni.

Esempio in C#

Se si utilizza l'esempio in C#, la procedura dettagliata presuppone inoltre che il codice esterno sia nascosto. Per attivare o disattivare la visualizzazione del codice esterno, fare clic con il pulsante destro del mouse sull'intestazione della tabella Nome nella finestra Stack di chiamate, quindi selezionare o deselezionare Mostra codice esterno. Se non si imposta questa funzionalità, è comunque possibile usare questa procedura dettagliata, ma i risultati potrebbero differire dalle illustrazioni.

Esempio di C++

Se si usa l'esempio C++, è possibile ignorare i riferimenti al codice esterno in questo articolo. Il codice esterno si applica solo all'esempio in C#.

Illustrazioni

Le illustrazioni in questo articolo vengono registrate in un computer quad core che esegue l'esempio C#. Sebbene sia possibile usare altre configurazioni per completare questa procedura dettagliata, le illustrazioni potrebbero differire da quelle visualizzate nel computer.

Creare il progetto di esempio

L'esempio di codice riportato in questa procedura dettagliata è relativo a un'applicazione che non esegue alcuna operazione. Lo scopo dell'esercizio è comprendere come usare le finestre degli strumenti per eseguire il debug di un'applicazione parallela.

1. Aprire Visual Studio e creare un nuovo progetto.

   Se la finestra iniziale non è aperta, scegliere Finestra di avvio file>.

   Nella finestra iniziale scegliere Nuovo progetto.

   Nella finestra Crea un nuovo progetto immettere o digitare console nella casella di ricerca. Scegliere quindi C#, C++o Visual Basic dall'elenco Linguaggio e quindi scegliere Windows dall'elenco Piattaforma.

   Dopo aver applicato i filtri del linguaggio e della piattaforma, scegliere l'app console per .NET Core o C++, quindi scegliere Avanti.

   Nota

   Se il modello corretto non è visualizzato, passare a Strumenti Ottieni strumenti>e funzionalità, che apre il Programma di installazione di Visual Studio. Scegliere il carico di lavoro Sviluppo per desktop .NET o Sviluppo di applicazioni desktop con C++, quindi scegliere Modifica.

   Nella finestra Configura il nuovo progetto digitare un nome o usare il nome predefinito nella casella Nome progetto. Scegliere quindi Avanti o Crea, a qualsiasi opzione disponibile.

   Per .NET Core scegliere il framework di destinazione consigliato o .NET 8 e quindi scegliere Crea.

   Verrà visualizzato un nuovo progetto console. Dopo aver creato il progetto, viene visualizzato un file di origine.

2. Aprire il file di codice con estensione CPP, CS o VB nel progetto. Eliminarne il contenuto per creare un file di codice vuoto.

3. Incollare il seguente codice per il linguaggio selezionato nel file di codice vuoto.

   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;
   }
   

---

Dopo aver aggiornato il file di codice, salvare le modifiche e compilare la soluzione.

1. Scegliere Save All (Salva tutto) dal menu File.

2. Scegliere Ricompila soluzione dal menu Compila.

Si noti che sono presenti quattro chiamate a Debugger.Break (DebugBreak nell'esempio C++). Pertanto, non è necessario inserire punti di interruzione. L'esecuzione dell'applicazione comporta l'interruzione del debugger fino a quattro volte.

Usare la finestra Stack paralleli: visualizzazione Thread

Per iniziare, scegliere Avvia debug dal menu Debug. Attendere che venga raggiunto il primo punto di interruzione.

Visualizzare lo stack di chiamate di un singolo thread

1. Scegliere Windows dal menu Debug e quindi thread. Ancorare la finestra Thread nella parte inferiore di Visual Studio.

2. Scegliere Windows dal menu Debug e quindi selezionare Stack di chiamate. Ancorare la finestra Stack di chiamate nella parte inferiore di Visual Studio.

3. Fare doppio clic su un thread nella finestra Thread per far sì che diventi il thread corrente. I thread correnti presentano una freccia gialla. Quando si modifica il thread corrente, il relativo stack di chiamate viene visualizzato nella finestra Stack di chiamate.

Esaminare la finestra Stack paralleli

Scegliere Windows dal menu Debug e quindi stack paralleli. Assicurarsi che Thread sia selezionata nella casella nell'angolo superiore sinistro.

Usando la finestra Stack paralleli , è possibile visualizzare più stack di chiamate contemporaneamente in un'unica visualizzazione. La figura seguente mostra la finestra Stack paralleli sopra la finestra Stack di chiamate.

Lo stack di chiamate del thread principale viene visualizzato in una casella, mentre gli stack di chiamate degli altri quattro thread sono raggruppati in un'altra casella. I quattro thread vengono raggruppati insieme in quanto i rispettivi stack frame condividono gli stessi contesti del metodo, vale a dire si trovano negli stessi metodi: A, B e C. Per visualizzare gli ID thread e i nomi dei thread che condividono la stessa casella, passare il puntatore del mouse sulla casella con l'intestazione ([#] Thread). Il thread corrente viene visualizzato in grassetto.

La freccia gialla indica lo stack frame attivo del thread corrente.

È possibile impostare i dettagli da visualizzare per gli stack frame (Nomi moduli, Tipi di parametro, Nomi parametri, Valori di parametro, Numeri di riga e Offset dei byte) facendo clic con il pulsante destro del mouse nella finestra Stack di chiamate.

Un'evidenziazione blu attorno a una casella indica che il thread corrente è parte di quella casella. Il thread corrente è inoltre indicato dallo stack frame in grassetto nella descrizione comandi. Se si fa doppio clic sul thread principale nella finestra Thread, è possibile osservare che la freccia di evidenziazione nella finestra Stack paralleli si sposta di conseguenza.

Riprendere l'esecuzione fino al secondo punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il secondo punto di interruzione, scegliere Continua dal menu Debug. Nell'illustrazione seguente viene mostrata la struttura ad albero del thread in corrispondenza del secondo punto di interruzione.

In corrispondenza del primo punto di interruzione, i quattro thread erano passati tutti dal metodo S.A a S.B e a S.C. Le informazioni sono ancora visibili nella finestra Stack in parallelo, ma i quattro thread sono avanzati. Uno di loro continuò a S.D e poi S.E. Un altro continuò a S.F, S.G e S.H. Altri due continuarono a S.I e S.J, e da lì uno di loro andò a S.K e l'altro continuò a nonuser External Code.

Passando invece il mouse sugli stack frame, verranno visualizzati gli ID dei thread e altri dettagli sui frame. L'evidenziazione blu indica il thread corrente, mentre la freccia gialla indica lo stack frame attivo del thread corrente.

L'icona dei thread di stoffa (linee interweaved) indica gli stack frame attivi dei thread non simultanei. Fare doppio clic su S.B nella finestra Stack di chiamate per passare da un frame all'altro. La finestra Stack paralleli indica lo stack frame corrente del thread corrente usando un'icona a forma di freccia curva.

Nota

Per una descrizione di tutte le icone nella finestra Stack paralleli, vedere Uso della finestra Stack paralleli.

Passare da un thread all'altro nella finestra Thread e osservare che la visualizzazione nella finestra Stack in parallelo viene aggiornata.

Per passare a un altro thread, o a un altro frame di un altro thread, è possibile usare il menu di scelta rapida nella finestra Stack in parallelo. Ad esempio, fare clic con il pulsante destro del mouse su S.J, scegliere Passa a frame e quindi selezionare un comando.

Fare clic con il pulsante destro del mouse su S.C e scegliere Passa a frame. Uno dei comandi presenta un segno di spunta che indica lo stack frame del thread corrente. È possibile passare a quel fotogramma dello stesso thread (solo le mosse della freccia curva) oppure passare all'altro thread (anche l'evidenziazione blu si sposta). Nell'illustrazione seguente viene mostrato il sottomenu.

Per le applicazioni di grandi dimensioni con molti thread, è possibile concentrarsi solo su un subset di thread. Nella finestra Stack in parallelo è possibile visualizzare gli stack di chiamate per i soli thread con contrassegno. Per contrassegnare i thread, utilizzare il menu di scelta rapida o la prima cella di un thread.

Sulla barra degli strumenti selezionare il pulsante Mostra solo contrassegnato accanto alla casella di riepilogo.

Ora, nella finestra Stack paralleli vengono visualizzati solo i thread contrassegnati .

Riprendere l'esecuzione fino al terzo punto di interruzione

1. Per riprendere l'esecuzione fino a quando non viene raggiunto il terzo punto di interruzione, scegliere Continua dal menu Debug.

   Quando più thread si trovano nello stesso metodo, ma il metodo non era all'inizio dello stack di chiamate, il metodo viene visualizzato in caselle diverse. Un esempio in corrispondenza del punto di interruzione corrente è S.L, il quale contiene tre thread e viene visualizzato in tre caselle. Fare doppio clic su S.L.

   

   Si noti che S.L appare in grassetto nelle altre due caselle, così da poter vedere in quali altri punti viene visualizzato. Per visualizzare i fotogrammi che chiamano in S.L e quali fotogrammi chiamano, selezionare il pulsante Attiva/Disattiva visualizzazione metodo sulla barra degli strumenti. La figura seguente mostra la visualizzazione del metodo della finestra Stack paralleli .

   

   Si noti come il diagramma sia imperniato sul metodo selezionato e lo abbia posizionato nella propria casella al centro della visualizzazione. I chiamanti e i chiamanti vengono visualizzati rispettivamente nella parte superiore e inferiore. Selezionare di nuovo il pulsante Attiva/Disattiva visualizzazione metodo per lasciare questa modalità.

   Il menu di scelta rapida della finestra Stack in parallelo presenta inoltre le voci descritte di seguito.

   • Visualizzazione esadecimale consente di scegliere tra il formato decimale e il formato esadecimale dei numeri nelle descrizioni comandi.

   • Simbolo Impostazioni aprire le rispettive finestre di dialogo.

   • Mostra thread in Origine attiva/disattiva la visualizzazione dei marcatori di thread nel codice sorgente, che mostra la posizione dei thread nel codice sorgente.

   • Mostra codice esterno visualizza tutti i fotogrammi anche se non sono nel codice utente. Provare a visualizzare il diagramma che si espande per contenere gli altri fotogrammi (che potrebbero essere disattivati perché non sono presenti simboli per loro).

2. Nella finestra Stack in parallelo assicurarsi che il pulsante Scorrimento automatico a stack frame corrente nella barra degli strumenti sia attivato.

   Quando si dispone di diagrammi di grandi dimensioni e si passa al punto di interruzione successivo, è possibile che la visualizzazione scori automaticamente fino al frame dello stack attivo del thread corrente; ovvero il thread che ha raggiunto prima il punto di interruzione.

3. Prima di continuare, nella finestra Stack in parallelo scorrere fino in fondo verso sinistra e verso il basso.

Riprendere l'esecuzione fino al quarto punto di interruzione

1. Per riprendere l'esecuzione fino a quando non viene raggiunto il quarto punto di interruzione, scegliere Continua dal menu Debug.

   Si noti come la visualizzazione sia scorsa automaticamente fino al punto in questione. Passare da un thread all'altro nella finestra Thread o da uno stack frame all'altro nella finestra Stack di chiamate e notare come la visualizzazione scorra sempre automaticamente al frame corretto. Disattivare l'opzione Scorrimento automatico a stack frame corrente e osservare la differenza.

   La Visualizzazione panoramica risulta utile anche con diagrammi di grandi dimensioni nella finestra Stack in parallelo. Per impostazione predefinita, la visualizzazione occhio dell'uccello è attiva. È tuttavia possibile attivarlo facendo clic sul pulsante tra le barre di scorrimento nell'angolo inferiore destro della finestra, come illustrato nella figura seguente.

   

   Nella visualizzazione degli occhi degli uccelli, è possibile spostare il rettangolo per eseguire rapidamente una panoramica intorno al diagramma.

   Un altro modo per spostare il diagramma in qualsiasi direzione consiste nel selezionare un'area vuota del diagramma e trascinarla nel punto desiderato.

   Per lo zoom avanti e indietro del diagramma, tenere premuto CTRL mentre si muove la rotella del mouse. In alternativa, selezionare il pulsante Zoom sulla barra degli strumenti e quindi usare lo strumento Zoom.

2. Prima di continuare, scegliere Arresta debug dal menu Debug per terminare l'esecuzione.

Usare la finestra Attività parallele e la visualizzazione Attività della finestra Stack paralleli

Prima di proseguire, si consiglia di completare le procedure precedenti.

Riavviare l'applicazione fino a quando non viene raggiunto il primo punto di interruzione:

1. Nel menu Debug selezionare Avvia debug e attendere che venga raggiunto il primo punto di interruzione.

2. Scegliere Windows dal menu Debug e quindi thread. Ancorare la finestra Thread nella parte inferiore di Visual Studio.

3. Scegliere Windows dal menu Debug e selezionare Stack di chiamate. Ancorare la finestra Stack di chiamate nella parte inferiore di Visual Studio.

4. Fare doppio clic su un thread nella finestra Thread per far sì che diventi il thread corrente. I thread correnti presentano la freccia gialla. Quando si modifica il thread corrente, le altre finestre vengono aggiornate. Verranno quindi esaminate le attività.

5. Scegliere Windows dal menu Debug e quindi selezionare Attività. La figura seguente mostra la finestra Attività .

   

   Per ogni attività in esecuzione è possibile visualizzare il relativo ID, restituito dalla proprietà omonima, l'ID e il nome del thread che la esegue e il relativo percorso (passando il mouse sul percorso viene visualizzata una descrizione comandi con l'intero stack di chiamate). Inoltre, nella colonna Attività è possibile visualizzare il metodo passato nell'attività, in altre parole il punto iniziale.

   Le colonne possono essere ordinate. Si noti il glifo di ordinamento che indica la colonna e la direzione di ordinamento. È anche possibile riordinare le colonne trascinandole a sinistra o a destra.

   La freccia gialla indica l'attività corrente. Per passare da un'attività all'altra, fare doppio clic su un'attività o utilizzare il menu di scelta rapida. Quando si passa da un'attività all'altra, il thread sottostante diventa quello corrente e le altre finestre vengono aggiornate.

   Quando si passa manualmente da un'attività a un'altra, la struttura freccia indica il contesto del debugger corrente per un'attività non simultanea.

Riprendere l'esecuzione fino al secondo punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il secondo punto di interruzione, scegliere Continua dal menu Debug.

In precedenza, la colonna Stato mostrava tutte le attività come Attivo, ma ora due delle attività sono Bloccate. Le attività possono essere bloccate per molti motivi diversi. Nella colonna Stato passare il puntatore del mouse su un'attività in attesa per scoprire perché è bloccato. Nell'illustrazione seguente, ad esempio, l'attività 11 è in attesa dell'attività 12.

È possibile contrassegnare un'attività facendo clic sul flag nella prima colonna della finestra Attività .

È possibile usare i contrassegni per tenere traccia delle attività tra i vari punti di interruzione nella stessa sessione di debug o per filtrare le attività i cui stack di chiamate vengono visualizzati nella finestra Stack in parallelo.

Quando in precedenza è stata usata la finestra Stack in parallelo, sono stati visualizzati i thread dell'applicazione. Visualizzando nuovamente la finestra Stack in parallelo, questa volta si vedranno le attività dell'applicazione. A tale scopo, selezionare Attività nella casella in alto a sinistra. Nell'illustrazione che segue viene mostrata la visualizzazione Attività.

I thread che attualmente non eseguono attività non vengono visualizzati nella visualizzazione Attività della finestra Stack paralleli . Inoltre, per i thread che eseguono attività, alcuni stack frame che non sono rilevanti per le attività vengono filtrati dalla parte superiore e inferiore dello stack.

Visualizzare di nuovo la finestra Attività . Fare clic con il pulsante destro del mouse su un'intestazione di colonna qualsiasi per visualizzare un menu di scelta rapida per la colonna.

Il menu di scelta rapida può essere utilizzato per aggiungere o rimuovere colonne. Ad esempio, la colonna AppDomain non è selezionata; pertanto, non viene visualizzato nell'elenco. Selezionare Padre. Verrà visualizzata la colonna Padre senza valori per le quattro attività.

Riprendere l'esecuzione fino al terzo punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il terzo punto di interruzione, scegliere Continua dal menu Debug.

In questo esempio si noti che l'attività 11 e l'attività 12 sono in esecuzione nello stesso thread (mostra la colonna Assegnazione thread se è nascosta). Queste informazioni non vengono visualizzate nella finestra Thread . Di seguito è riportato un altro vantaggio della finestra Attività . Per conferma, visualizzare la finestra Stack in parallelo. Assicurarsi di visualizzare Attività. È possibile individuare le attività 11 e 12 analizzando le descrizioni comando nella finestra Stack paralleli .

Riprendere l'esecuzione fino al quarto punto di interruzione

Per riprendere l'esecuzione fino a quando non viene raggiunto il terzo punto di interruzione, scegliere Continua dal menu Debug. Selezionare l'intestazione di colonna ID per ordinare in base all'ID. Si dovrebbe vedere l'illustrazione seguente.

L'attività 10 e l'attività 11 sono ora in attesa l'una sull'altra e sono bloccate. Sono inoltre disponibili diverse nuove attività che sono ora pianificate. Le attività pianificate sono attività avviate nel codice ma non ancora eseguite. Di conseguenza, le colonne Location e Thread Assignment mostrano i messaggi predefiniti o sono vuoti.

È possibile raggruppare le attività in base alle colonne. Nella finestra Attività fare clic con il pulsante destro del mouse sull'intestazione di colonna Stato e quindi scegliere Raggruppa per stato. La figura seguente mostra la finestra Attività raggruppata per stato.

È anche possibile raggruppare in base alle altre colonne. Raggruppando le attività, è possibile concentrarsi su un subset di attività. Ogni gruppo comprimibile presenta un conteggio degli elementi raggruppati insieme.

L'ultima funzionalità della finestra Attività da esaminare è il menu di scelta rapida visualizzato quando si fa clic con il pulsante destro del mouse su un'attività.

Il menu di scelta rapida visualizza comandi diversi a seconda dello stato dell'attività. I comandi possono includere Copia, Seleziona tutto, Visualizzazione esadecimale, Passa all'attività, Blocca thread assegnato, Blocca tutti i thread, ma questo e Thaw Assigned Thread e Flag.

È possibile bloccare il thread sottostante di un'attività o di più attività oppure bloccare tutti i thread a eccezione di quello assegnato. Un thread bloccato viene rappresentato nella finestra Attività, così come si trova nella finestra Thread, da un'icona di pausa blu.

Riepilogo

In questa procedura dettagliata sono state illustrate le finestre del debugger Attività in parallelo e Stack in parallelo. Utilizzare queste finestre con progetti reali che a loro volta utilizzano codice multithreading. È possibile esaminare codice parallelo scritto in C++, C# o Visual Basic.

Contenuto correlato

• Debug di applicazioni multithreading
• Presentazione del debugger
• Debug di codice gestito
• Programmazione parallela
• Runtime di concorrenza
• Uso della finestra Stack in parallelo
• Uso della finestra Attività