Kom igång med felsökning av flertrådade program (C#, Visual Basic, C++)

2025-08-07

Visual Studio innehåller flera verktyg och användargränssnittselement som hjälper dig att felsöka flertrådade program. Den här självstudien visar hur du använder trådmarkörer, fönstret Parallel Stacks , Parallel Watch-fönstret , villkorsstyrda brytpunkter och filterbrytpunkter. När du slutför den här självstudien bekantar du dig med Visual Studio-funktioner för felsökning av flertrådade program.

Mer scenariofokuserade självstudier finns i följande artiklar.

Det första steget är att skapa ett flertrådat programprojekt.

Skapa ett flertrådat appprojekt

Öppna Visual Studio och skapa ett nytt projekt.

Om startfönstret inte är öppet väljer du Fil>Startfönster.

I startfönstret väljer du Skapa ett nytt projekt.

I fönstret Skapa ett nytt projekt anger eller skriver du konsolen i sökrutan. Välj sedan C#, C++eller Visual Basic i listan Språk och välj sedan Windows i listan Plattform.

När du har tillämpat språk- och plattformsfiltren väljer du mallen Konsolapp för .NET eller C++ och väljer sedan Nästa.

Anmärkning

Om du inte ser rätt mall går du till Verktyg>Hämta verktyg och funktioner... som öppnar Installationsprogrammet för Visual Studio. Välj .NET-skrivbordsutveckling eller Skrivbordsutveckling med C++ -arbetsbelastning och välj sedan Ändra.

I fönstret Konfigurera det nya projektet skriver eller anger du MyThreadWalkthroughApp i rutan Projektnamn . Välj sedan antingen Nästa eller Skapa, beroende på vilket alternativ som är tillgängligt.

För ett .NET Core- eller .NET 5+-projekt väljer du antingen det rekommenderade målramverket eller .NET 8 och väljer sedan Skapa.

Ett nytt konsolprojekt visas. När projektet har skapats visas en källfil. Beroende på vilket språk du har valt kan källfilen heta Program.cs, MyThreadWalkthroughApp.cpp eller Module1.vb.

Ta bort koden som visas i källfilen och ersätt den med följande uppdaterade kod. Välj lämpligt kodfragment för kodkonfigurationen.

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.");

    }
}

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

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

På menyn Arkiv väljer du Spara alla.
(Endast Visual Basic) I Solution Explorer (höger ruta) högerklickar du på projektnoden och väljer Egenskaper. Under fliken Program ändrar du Start-objektet till Enkelt.

Felsöka den flertrådade appen

Leta efter följande kodfragment i källkodsredigeraren:

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

Thread.Sleep(3000)
Console.WriteLine()

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

Vänsterklicka i den vänstra rännstenen i or-satsen Thread.Sleep , för C++, std::this_thread::sleep_for för att infoga en ny brytpunkt.

I rännan anger en röd cirkel att en brytpunkt har angetts på den här platsen.
På felsökningsmenyn väljer du Starta felsökning (F5).

Visual Studio skapar lösningen, appen börjar köras med felsökningsprogrammet kopplat och sedan stoppas appen vid brytpunkten.
Leta upp den rad som innehåller brytpunkten i källkodsredigeraren.

Upptäck trådmarkören

I verktygsfältet Felsökning väljer du knappen Visa trådar i källan.
Tryck på F11 två gånger för att gå vidare i felsökningsprogrammet.
Titta på rännstenen till vänster i fönstret. På den här raden lägger du märke till en trådmarkörikon som liknar två tvinnade trådar. Trådmarkören anger att en tråd stoppas på den här platsen.

En trådmarkör kan delvis döljas av en brytpunkt.
Hovra pekaren över trådmarkören. En DataTip visas med namnet och tråd-ID-numret för varje stoppad tråd. I det här fallet är namnet förmodligen <noname>.
Välj trådmarkören för att se de tillgängliga alternativen på snabbmenyn.

Visa trådarnas platser

I fönstret Parallel Stacks kan du växla mellan en trådvy och (för uppgiftsbaserad programmering) uppgiftsvy, och du kan visa information om anropsstacken för varje tråd. I den här appen kan vi använda trådvyn.

Öppna fönstret Parallella stackar genom att välja Felsök>Windows>parallella stackar. Du bör se något som liknar följande. Den exakta informationen kan variera beroende på den aktuella platsen för varje tråd, din hårdvara och ditt programmeringsspråk.
I det här exemplet visas den här informationen för hanterad kod från vänster till höger:
- Den aktuella tråden (gul pil) har gått in ServerClass.InstanceMethod. Du kan visa tråd-ID och stackram för en tråd genom att hålla muspekaren över ServerClass.InstanceMethod.
- Tråd 31724 väntar på ett lås som ägs av tråd 20272.
- Huvudtråden (vänster sida) har stannat vid [Extern kod], som du kan visa i detalj om du väljer Visa extern kod.
I det här exemplet visas den här informationen för hanterad kod från vänster till höger:
- Huvudtråden (vänster sida) har stannat på Thread.Start, där stopppunkten identifieras av trådmarkörikonen .
- Två trådar har kommit in i ServerClass.InstanceMethod, varav den ena är den aktuella tråden (gul pil), medan den andra tråden har stannat i Thread.Sleep.
- En ny tråd (till höger) startar också men stoppas den ThreadHelper.ThreadStart.
Anmärkning

Mer information om hur du använder vyn Trådar finns i Felsöka ett dödläge med hjälp av vyn Trådar.
Om du vill visa trådarna i en listvy väljer du Felsök>Windows-trådar>.

I den här vyn kan du enkelt se att tråd 20272 är huvudtråden och för närvarande finns i extern kod, särskilt System.Console.dll.
Högerklicka på posterna i fönstret Parallella staplar eller Trådar för att se de tillgängliga alternativen på snabbmenyn.

Du kan vidta olika åtgärder från dessa högerklicksmenyer. I den här självstudien utforskar du mer av den här informationen i fönstret Parallel Watch (nästa avsnitt).

Ställ in en klocka på en variabel

Öppna fönstret Parallel Watch genom att välja Felsök>Windows>Parallel Watch>Parallel Watch 1.
Markera cellen där du ser <Add Watch> texten (eller den tomma rubrikcellen i den fjärde kolumnen) och ange data.

Värdena för datavariabeln för varje tråd visas i fönstret.
Markera cellen där du ser <Add Watch> texten (eller den tomma rubrikcellen i den femte kolumnen) och ange count.

Värdena för variabeln count för varje tråd visas i fönstret. Om du inte ser så här mycket information ännu kan du prova att trycka på F11 några gånger för att gå vidare med körningen av trådarna i felsökningsprogrammet.
Högerklicka på en av raderna i fönstret för att se de tillgängliga alternativen.

Flagga och ta bort trådar

Du kan flagga trådar för att hålla reda på viktiga trådar och ignorera de andra trådarna.

I fönstret Parallel Watch håller du ned Skift-tangenten och väljer flera rader.
Högerklicka och välj Flagga.

Alla markerade trådar flaggas. Nu kan du filtrera för att endast visa flaggade trådar.
I fönstret Parallel Watch väljer du knappen Visa endast flaggade trådar.

Endast de flaggade trådarna visas i listan.

Tips/Råd

När du har flaggat några trådar kan du högerklicka på en kodrad i kodredigeraren och välja Kör flaggade trådar till markören. Se till att välja kod som alla flaggade trådar ska nå. Visual Studio pausar trådar på den valda kodraden, vilket gör det enklare att styra körningsordningen genom att låsa och tina upp trådar.
Välj knappen Visa endast flaggade trådar igen för att växla tillbaka till läget Visa alla trådar .
Om du vill avflagga trådar högerklickar du på en eller flera flaggade trådar i fönstret Parallel Watch och väljer Avflagga.

Körning av frysning och upptining av tråd

Tips/Råd

Du kan låsa och tina (pausa och återuppta) trådar för att styra i vilken ordning trådarna utför arbete. Detta kan hjälpa dig att lösa samtidighetsproblem, till exempel dödlägen och konkurrensförhållanden.

I fönstret Parallel Watch, med alla rader markerade, högerklickar du och väljer Frys.

I den andra kolumnen visas en pausikon för varje rad. Pausikonen indikerar att tråden är frusen.
Avmarkera alla andra rader genom att bara markera en rad.
Högerklicka på en rad och välj Tina upp.

Pausikonen försvinner på den här raden, vilket indikerar att tråden inte längre är låst.
Växla till kodredigeraren och tryck på F11. Endast den ofrusta tråden går.

Appen kan också instansiera vissa nya trådar. Alla nya trådar är oflaggade och är inte låsta.

Följa en enskild tråd med villkorsstyrda brytpunkter

Det kan vara bra att följa körningen av en enskild tråd i felsökningsprogrammet. Ett sätt att göra det är att frysa trådar som du inte är intresserad av. I vissa fall kan du behöva följa en enda tråd utan att låsa andra trådar, till exempel för att återskapa en viss bugg. Om du vill följa en tråd utan att frysa andra trådar måste du undvika att bryta in i kod förutom i den tråd som du är intresserad av. Du kan utföra den här uppgiften genom att ange en villkorsstyrd brytpunkt.

Du kan ange brytpunkter för olika villkor, till exempel trådnamnet eller tråd-ID:t. Det kan vara bra att ange villkoret för data som du vet är unika för varje tråd. Den här metoden är vanlig under felsökning när du är mer intresserad av ett visst datavärde än av en viss tråd.

Högerklicka på den brytpunkt som du skapade tidigare och välj Villkor.
I fönstret Brytpunktsinställningar anger du data == 5 för villkorsuttrycket.

Tips/Råd

Om du är mer intresserad av en specifik tråd använder du ett trådnamn eller ett tråd-ID för villkoret. Det gör du genom att välja Filter i stället för Villkorsuttryck i fönstret Brytpunktsinställningar och följa filtertipsen. Du kanske vill namnge dina trådar i appkoden, eftersom tråd-ID:t ändras när du startar om felsökningsprogrammet.
Stäng fönstret Brytpunktsinställningar .
Välj knappen Starta för att starta om felsökningssessionen.

Du bryter in i kod i tråden där datavariabelns värde är 5. I fönstret Parallel Watch letar du efter den gula pilen som anger den aktuella felsökningskontexten.
Nu kan du stega över kod (F10) och gå in i kod (F11) och följa körningen av den enskilda tråden.

Så länge brytpunktsvillkoret är unikt för tråden och felsökaren inte träffar några andra brytpunkter i andra trådar (du kan behöva inaktivera dem) kan du stega över kod och stega in i kod utan att växla till andra trådar.

Anmärkning

När du avancerar felsökningsprogrammet körs alla trådar. Felsökaren bryter dock inte in i kod på andra trådar om inte någon av de andra trådarna når en brytpunkt.

Feedback

Var den här sidan till hjälp?