Thread.Join Metod

Definition

Namnområde:: System.Threading

Sammansättningar:: netstandard.dll, System.Threading.Thread.dll

Sammansättning:: System.Threading.Thread.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Blockerar den anropande tråden tills tråden som representeras av den här instansen avslutas.

Överlagringar

Name	Description
Join()	Blockerar den anropande tråden tills tråden som representeras av den här instansen avslutas, samtidigt som standard-COM och `SendMessage` pumpning fortsätter.
Join(Int32)	Blockerar den anropande tråden tills tråden som representeras av den här instansen avslutas eller den angivna tiden förflutit, samtidigt som com- och SendMessage-standardpumpning fortsätter.
Join(TimeSpan)	Blockerar den anropande tråden tills tråden som representeras av den här instansen avslutas eller den angivna tiden förflutit, samtidigt som com- och SendMessage-standardpumpning fortsätter.

Join()

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Blockerar den anropande tråden tills tråden som representeras av den här instansen avslutas, samtidigt som standard-COM och SendMessage pumpning fortsätter.

public:
 void Join();

public void Join();

member this.Join : unit -> unit

Public Sub Join ()

Undantag

ThreadStateException

Anroparen försökte ansluta till en tråd som är i tillståndet Unstarted .

ThreadInterruptedException

Tråden avbryts i väntan.

Kommentarer

Join är en synkroniseringsmetod som blockerar den anropande tråden (dvs. den tråd som anropar metoden) tills den tråd vars Join metod heter har slutförts. Använd den här metoden för att säkerställa att en tråd har avslutats. Anroparen blockeras på obestämd tid om tråden inte avslutas. I följande exempel anropar tråden Thread1Join() metoden Thread2, vilket gör Thread1 att blockera tills Thread2 den har slutförts.

using System;
using System.Threading;

public class Example
{
   static Thread thread1, thread2;
   
   public static void Main()
   {
      thread1 = new Thread(ThreadProc);
      thread1.Name = "Thread1";
      thread1.Start();
      
      thread2 = new Thread(ThreadProc);
      thread2.Name = "Thread2";
      thread2.Start();   
   }

   private static void ThreadProc()
   {
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      if (Thread.CurrentThread.Name == "Thread1" && 
          thread2.ThreadState != ThreadState.Unstarted)
         thread2.Join();
      
      Thread.Sleep(4000);
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      Console.WriteLine("Thread1: {0}", thread1.ThreadState);
      Console.WriteLine("Thread2: {0}\n", thread2.ThreadState);
   }
}
// The example displays output like the following:
//       Current thread: Thread1
//       
//       Current thread: Thread2
//       
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//       
//       
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

open System.Threading

let mutable thread1, thread2 =
    Unchecked.defaultof<Thread>, Unchecked.defaultof<Thread>

let threadProc () =
    printfn $"\nCurrent thread: {Thread.CurrentThread.Name}"

    if
        Thread.CurrentThread.Name = "Thread1"
        && thread2.ThreadState <> ThreadState.Unstarted
    then
        thread2.Join()

    Thread.Sleep 4000
    printfn $"\nCurrent thread: {Thread.CurrentThread.Name}"
    printfn $"Thread1: {thread1.ThreadState}"
    printfn $"Thread2: {thread2.ThreadState}\n"

thread1 <- Thread threadProc
thread1.Name <- "Thread1"
thread1.Start()

thread2 <- Thread threadProc
thread2.Name <- "Thread2"
thread2.Start()

// The example displays output like the following:
//       Current thread: Thread1
//
//       Current thread: Thread2
//
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//
//
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

Imports System.Threading

Module Example
   Dim thread1, thread2 As Thread

   Public Sub Main()
      thread1 = new Thread(AddressOf ThreadProc)
      thread1.Name = "Thread1"
      thread1.Start()
      
      thread2 = New Thread(AddressOf ThreadProc)
      thread2.Name = "Thread2"
      thread2.Start()   
   End Sub

   Private Sub ThreadProc()
      Console.WriteLine()
      Console.WriteLine("Current thread: {0}", Thread.CurrentThread.Name)
      If (Thread.CurrentThread.Name = "Thread1" And 
          thread2.ThreadState <> ThreadState.Unstarted)
         thread2.Join()
      End If
      Thread.Sleep(4000)
      Console.WriteLine()
      Console.WriteLine("Current thread: {0}", Thread.CurrentThread.Name)
      Console.WriteLine("Thread1: {0}", thread1.ThreadState)
      Console.WriteLine("Thread2: {0}", thread2.ThreadState)
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following :
'       Current thread: Thread1
'       
'       Current thread: Thread2
'       
'       Current thread: Thread2
'       Thread1: WaitSleepJoin
'       Thread2: Running
'       
'       
'       Current thread: Thread1
'       Thread1: Running
'       Thread2: Stopped

Om tråden redan har avslutats när Join anropas returnerar metoden omedelbart.

Varning

Du bör aldrig anropa metoden för Join objektet Thread som representerar den aktuella tråden från den aktuella tråden. Detta gör att appen inte svarar eftersom den aktuella tråden väntar på sig själv på obestämd tid.

Den här metoden ändrar tillståndet för den anropande tråden så att den inkluderar ThreadState.WaitSleepJoin. Du kan inte anropa Join på en tråd som är i tillståndet ThreadState.Unstarted .

Se även

ThreadState

Gäller för

Join(Int32)

Källa:: Thread.CoreCLR.cs

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Blockerar den anropande tråden tills tråden som representeras av den här instansen avslutas eller den angivna tiden förflutit, samtidigt som com- och SendMessage-standardpumpning fortsätter.

public:
 bool Join(int millisecondsTimeout);

public bool Join(int millisecondsTimeout);

member this.Join : int -> bool

Public Function Join (millisecondsTimeout As Integer) As Boolean

Parametrar

millisecondsTimeout: Int32

Antalet millisekunder som ska vänta tills tråden avslutas.

Returer

Boolean

true om tråden har avslutats; false om tråden inte har avslutats efter att den tid som anges av parametern millisecondsTimeout har förflutit.

Undantag

ArgumentOutOfRangeException

Värdet millisecondsTimeout för är negativt och är inte lika med Infinite i millisekunder.

ThreadStateException

Tråden har inte startats.

ArgumentException

millisecondsTimeout är mindre än -1 (Timeout.Infinite).

ThreadInterruptedException

Tråden avbröts i väntan.

Kommentarer

Join(Int32) är en synkroniseringsmetod som blockerar den anropande tråden (dvs. den tråd som anropar metoden) tills antingen tråden vars metod anropas Join har slutförts eller tidsgränsintervallet har förflutit. I följande exempel anropar tråden Thread1Join() metoden Thread2, vilket gör Thread1 att blockera antingen tills Thread2 har slutförts eller 2 sekunder har förflutit.

using System;
using System.Threading;

public class Example
{
   static Thread thread1, thread2;
   
   public static void Main()
   {
      thread1 = new Thread(ThreadProc);
      thread1.Name = "Thread1";
      thread1.Start();
      
      thread2 = new Thread(ThreadProc);
      thread2.Name = "Thread2";
      thread2.Start();   
   }

   private static void ThreadProc()
   {
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      if (Thread.CurrentThread.Name == "Thread1" && 
          thread2.ThreadState != ThreadState.Unstarted)
         if (thread2.Join(2000))
            Console.WriteLine("Thread2 has termminated.");
         else
            Console.WriteLine("The timeout has elapsed and Thread1 will resume.");   
      
      Thread.Sleep(4000);
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      Console.WriteLine("Thread1: {0}", thread1.ThreadState);
      Console.WriteLine("Thread2: {0}\n", thread2.ThreadState);
   }
}
// The example displays the following output:
//       Current thread: Thread1
//       
//       Current thread: Thread2
//       The timeout has elapsed and Thread1 will resume.
//       
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//       
//       
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

open System.Threading

let mutable thread1, thread2 =
    Unchecked.defaultof<Thread>, Unchecked.defaultof<Thread>

let threadProc () =
    printfn $"\nCurrent thread: {Thread.CurrentThread.Name}"

    if
        Thread.CurrentThread.Name = "Thread1"
        && thread2.ThreadState <> ThreadState.Unstarted
    then
        if thread2.Join 2000 then
            printfn "Thread2 has termminated."
        else
            printfn "The timeout has elapsed and Thread1 will resume."

    Thread.Sleep 4000
    printfn $"\nCurrent thread: {Thread.CurrentThread.Name}"
    printfn $"Thread1: {thread1.ThreadState}"
    printfn $"Thread2: {thread2.ThreadState}\n"

thread1 <- Thread threadProc
thread1.Name <- "Thread1"
thread1.Start()

thread2 <- Thread threadProc
thread2.Name <- "Thread2"
thread2.Start()

// The example displays the following output:
//       Current thread: Thread1
//
//       Current thread: Thread2
//       The timeout has elapsed and Thread1 will resume.
//
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//
//
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

Imports System.Threading

Module Example
   Dim thread1, thread2 As Thread

   Public Sub Main()
      thread1 = new Thread(AddressOf ThreadProc)
      thread1.Name = "Thread1"
      thread1.Start()
      
      thread2 = New Thread(AddressOf ThreadProc)
      thread2.Name = "Thread2"
      thread2.Start()   
   End Sub

   Private Sub ThreadProc()
      Console.WriteLine()
      Console.WriteLine("Current thread: {0}", Thread.CurrentThread.Name)
      If (Thread.CurrentThread.Name = "Thread1" And 
          thread2.ThreadState <> ThreadState.Unstarted)
         If thread2.Join(TimeSpan.FromSeconds(2))
            Console.WriteLine("Thread2 has termminated.")
         Else
            Console.WriteLine("The timeout has elapsed and Thread1 will resume.")
         End If      
      End If
      Thread.Sleep(4000)
      Console.WriteLine()
      Console.WriteLine("Current thread: {0}", Thread.CurrentThread.Name)
      Console.WriteLine("Thread1: {0}", thread1.ThreadState)
      Console.WriteLine("Thread2: {0}", thread2.ThreadState)
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       Current thread: Thread1
'       
'       Current thread: Thread2
'       
'       Current thread: Thread2
'       Thread1: WaitSleepJoin
'       Thread2: Running
'       
'       
'       Current thread: Thread1
'       Thread1: Running
'       Thread2: Stopped

Om Timeout.Infinite anges för parametern fungerar den millisecondsTimeout här metoden identiskt Join() med metodens överlagring, förutom returvärdet.

Om tråden redan har avslutats när Join anropas returnerar metoden omedelbart.

Se även

ThreadState

Gäller för

Join(TimeSpan)

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Källa:: Thread.cs

Blockerar den anropande tråden tills tråden som representeras av den här instansen avslutas eller den angivna tiden förflutit, samtidigt som com- och SendMessage-standardpumpning fortsätter.

public:
 bool Join(TimeSpan timeout);

public bool Join(TimeSpan timeout);

member this.Join : TimeSpan -> bool

Public Function Join (timeout As TimeSpan) As Boolean

Parametrar

timeout: TimeSpan

En TimeSpan inställning till hur lång tid tråden ska avslutas.

Returer

Boolean

true om tråden avslutades; false om tråden inte har avslutats efter att den tid som anges av parametern timeout har förflutit.

Undantag

ArgumentOutOfRangeException

Värdet timeout för är negativt och är inte lika med Infinite i millisekunder eller är större än Int32.MaxValue millisekunder.

ThreadStateException

Anroparen försökte ansluta till en tråd som är i tillståndet Unstarted .

Exempel

I följande kodexempel visas hur du använder ett TimeSpan värde med Join metoden.

using System;
using System.Threading;

class Test
{
    static TimeSpan waitTime = new TimeSpan(0, 0, 1);

    public static void Main() 
    {
        Thread newThread = new Thread(Work);
        newThread.Start();

        if(newThread.Join(waitTime + waitTime)) {
            Console.WriteLine("New thread terminated.");
        }
        else {
            Console.WriteLine("Join timed out.");
        }
    }

    static void Work()
    {
        Thread.Sleep(waitTime);
    }
}
// The example displays the following output:
//        New thread terminated.

open System
open System.Threading

let waitTime = TimeSpan(0, 0, 1)

let work () =
    Thread.Sleep waitTime

let newThread = Thread work
newThread.Start()

if waitTime + waitTime |> newThread.Join then
    printfn "New thread terminated."
else
    printfn "Join timed out."

// The example displays the following output:
//        New thread terminated.

Imports System.Threading

Public Module Test
    Dim waitTime As New TimeSpan(0, 0, 1)

    Public Sub Main() 
        Dim newThread As New Thread(AddressOf Work)
        newThread.Start()

        If newThread.Join(waitTime + waitTime) Then
            Console.WriteLine("New thread terminated.")
        Else
            Console.WriteLine("Join timed out.")
        End If
    End Sub

    Private Sub Work()
        Thread.Sleep(waitTime)
    End Sub
End Module
' The example displays the following output:
'       New thread terminated.

Kommentarer

Join(TimeSpan) är en synkroniseringsmetod som blockerar den anropande tråden (dvs. den tråd som anropar metoden) tills antingen tråden vars metod anropas Join har slutförts eller tidsgränsintervallet har förflutit. I följande exempel anropar tråden Thread1Join() metoden Thread2, vilket gör Thread1 att blockera antingen tills Thread2 har slutförts eller 2 sekunder har förflutit.

using System;
using System.Threading;

public class Example
{
   static Thread thread1, thread2;
   
   public static void Main()
   {
      thread1 = new Thread(ThreadProc);
      thread1.Name = "Thread1";
      thread1.Start();
      
      thread2 = new Thread(ThreadProc);
      thread2.Name = "Thread2";
      thread2.Start();   
   }

   private static void ThreadProc()
   {
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      if (Thread.CurrentThread.Name == "Thread1" && 
          thread2.ThreadState != ThreadState.Unstarted)
         if (thread2.Join(TimeSpan.FromSeconds(2)))
            Console.WriteLine("Thread2 has termminated.");
         else
            Console.WriteLine("The timeout has elapsed and Thread1 will resume.");   
      
      Thread.Sleep(4000);
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      Console.WriteLine("Thread1: {0}", thread1.ThreadState);
      Console.WriteLine("Thread2: {0}\n", thread2.ThreadState);
   }
}
// The example displays the following output:
//       Current thread: Thread1
//       
//       Current thread: Thread2
//       The timeout has elapsed and Thread1 will resume.
//       
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//       
//       
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

open System
open System.Threading

let mutable thread1, thread2 =
    Unchecked.defaultof<Thread>, Unchecked.defaultof<Thread>

let threadProc () =
    printfn $"\nCurrent thread: {Thread.CurrentThread.Name}"

    if
        Thread.CurrentThread.Name = "Thread1"
        && thread2.ThreadState <> ThreadState.Unstarted
    then
        if TimeSpan.FromSeconds 2 |> thread2.Join then
            printfn "Thread2 has termminated."
        else
            printfn "The timeout has elapsed and Thread1 will resume."

    Thread.Sleep 4000
    printfn $"\nCurrent thread: {Thread.CurrentThread.Name}"
    printfn $"Thread1: {thread1.ThreadState}"
    printfn $"Thread2: {thread2.ThreadState}\n"

thread1 <- Thread threadProc
thread1.Name <- "Thread1"
thread1.Start()

thread2 <- Thread threadProc
thread2.Name <- "Thread2"
thread2.Start()

// The example displays the following output:
//       Current thread: Thread1
//
//       Current thread: Thread2
//       The timeout has elapsed and Thread1 will resume.
//
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//
//
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

Imports System.Threading

Module Example
   Dim thread1, thread2 As Thread

   Public Sub Main()
      thread1 = new Thread(AddressOf ThreadProc)
      thread1.Name = "Thread1"
      thread1.Start()
      
      thread2 = New Thread(AddressOf ThreadProc)
      thread2.Name = "Thread2"
      thread2.Start()   
   End Sub

   Private Sub ThreadProc()
      Console.WriteLine()
      Console.WriteLine("Current thread: {0}", Thread.CurrentThread.Name)
      If (Thread.CurrentThread.Name = "Thread1" And 
          thread2.ThreadState <> ThreadState.Unstarted)
         If thread2.Join(2000)
            Console.WriteLine("Thread2 has termminated.")
         Else
            Console.WriteLine("The timeout has elapsed and Thread1 will resume.")
         End If      
      End If
      Thread.Sleep(4000)
      Console.WriteLine()
      Console.WriteLine("Current thread: {0}", Thread.CurrentThread.Name)
      Console.WriteLine("Thread1: {0}", thread1.ThreadState)
      Console.WriteLine("Thread2: {0}", thread2.ThreadState)
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       Current thread: Thread1
'       
'       Current thread: Thread2
'       
'       Current thread: Thread2
'       Thread1: WaitSleepJoin
'       Thread2: Running
'       
'       
'       Current thread: Thread1
'       Thread1: Running
'       Thread2: Stopped

Om Timeout.Infinite anges för timeoutbeter sig den här metoden identiskt med metodöverlagringen Join() , förutom returvärdet.

Om tråden redan har avslutats när Join anropas returnerar metoden omedelbart.

Den här metoden ändrar tillståndet för den aktuella tråden så att den innehåller WaitSleepJoin. Du kan inte anropa Join på en tråd som är i tillståndet ThreadState.Unstarted .

Se även

ThreadState

Gäller för

Feedback

Var den här sidan till hjälp?