Thread.Join Metoda

Definice

Obor názvů:
System.Threading
Sestavení:
netstandard.dll, System.Threading.Thread.dll
Sestavení:
System.Threading.Thread.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Blokuje volající vlákno, dokud se vlákno reprezentované touto instancí ukončí.

Přetížení

Name Description
Join()

Blokuje volající vlákno, dokud se vlákno reprezentované touto instancí ukončí, a zároveň pokračuje v provádění standardního modelu COM a SendMessage pumpování.
Join(Int32)

Blokuje volající vlákno, dokud vlákno reprezentované touto instancí neukončí nebo zadaný čas uplynou, zatímco pokračuje v provádění standardního modelu COM a SendMessage pumpování.
Join(TimeSpan)

Blokuje volající vlákno, dokud vlákno reprezentované touto instancí neukončí nebo zadaný čas uplynou, zatímco pokračuje v provádění standardního modelu COM a SendMessage pumpování.

Join()

Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs

Blokuje volající vlákno, dokud se vlákno reprezentované touto instancí ukončí, a zároveň pokračuje v provádění standardního modelu COM a SendMessage pumpování.

public:
 void Join();
public void Join();
member this.Join : unit -> unit
Public Sub Join ()

Výjimky

ThreadStateException

Volající se pokusil připojit vlákno, které je ve Unstarted stavu.

ThreadInterruptedException

Vlákno se přeruší při čekání.

Poznámky

Join je synchronizační metoda, která blokuje volající vlákno (to znamená vlákno, které volá metodu), dokud vlákno, jehož Join metoda je volána byla dokončena. Pomocí této metody se ujistěte, že vlákno bylo ukončeno. Volající bude trvale blokovat, pokud vlákno neukončí. V následujícím příkladu Thread1 vlákno volá metodu Join()Thread2, která způsobí Thread1 blokování, dokud Thread2 se nedokončí.

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

Pokud vlákno již ukončeno při Join zavolání, metoda vrátí okamžitě.

Warning

Nikdy byste neměli volat Join metodu objektu Thread , který představuje aktuální vlákno z aktuálního vlákna. To způsobí, že vaše aplikace přestane reagovat, protože aktuální vlákno čeká na sebe neomezeně dlouho,

Tato metoda změní stav volajícího vlákna tak, aby zahrnoval ThreadState.WaitSleepJoin. Nelze vyvolat Join vlákno, které je ve ThreadState.Unstarted stavu.

Viz také

Platí pro

Join(Int32)

Zdroj:
Thread.CoreCLR.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs

Blokuje volající vlákno, dokud vlákno reprezentované touto instancí neukončí nebo zadaný čas uplynou, zatímco pokračuje v provádění standardního modelu COM a SendMessage pumpování.

public:
 bool Join(int millisecondsTimeout);
public bool Join(int millisecondsTimeout);
member this.Join : int -> bool
Public Function Join (millisecondsTimeout As Integer) As Boolean

Parametry

millisecondsTimeout
Int32

Počet milisekund, které mají čekat na ukončení vlákna.

Návraty

Boolean

true je-li vlákno ukončeno; false pokud vlákno nebylo ukončeno po uplynutí doby určené parametrem millisecondsTimeout .

Výjimky

ArgumentOutOfRangeException

Hodnota millisecondsTimeout je záporná a nerovná se Infinite v milisekundách.

ThreadStateException

Vlákno nebylo spuštěno.

ArgumentException

millisecondsTimeout je menší než -1 (Timeout.Infinite).

ThreadInterruptedException

Vlákno bylo přerušeno při čekání.

Poznámky

Join(Int32) je synchronizační metoda, která blokuje volající vlákno (tj. vlákno, které volá metodu), dokud vlákno, jehož Join metoda je volána dokončena, nebo časový limit uplynul. V následujícím příkladu Thread1 vlákno volá metodu Join()Thread2, která způsobí Thread1 blokování buď do Thread2 dokončení, nebo 2 sekundy uplynula.

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

Pokud Timeout.Infinite je zadán pro millisecondsTimeout parametr, tato metoda se chová stejně jako Join() přetížení metody s výjimkou návratové hodnoty.

Pokud vlákno již ukončeno při Join zavolání, metoda vrátí okamžitě.

Tato metoda změní stav volajícího vlákna tak, aby zahrnoval ThreadState.WaitSleepJoin. Nelze vyvolat Join vlákno, které je ve ThreadState.Unstarted stavu.

Viz také

Platí pro

Join(TimeSpan)

Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs
Zdroj:
Thread.cs

Blokuje volající vlákno, dokud vlákno reprezentované touto instancí neukončí nebo zadaný čas uplynou, zatímco pokračuje v provádění standardního modelu COM a SendMessage pumpování.

public:
 bool Join(TimeSpan timeout);
public bool Join(TimeSpan timeout);
member this.Join : TimeSpan -> bool
Public Function Join (timeout As TimeSpan) As Boolean

Parametry

timeout
TimeSpan

Nastaví TimeSpan se doba čekání na ukončení vlákna.

Návraty

Boolean

true je-li vlákno ukončeno; false pokud vlákno nebylo ukončeno po uplynutí doby určené parametrem timeout .

Výjimky

ArgumentOutOfRangeException

Hodnota timeout je záporná a nerovná se Infinite v milisekundách nebo je větší než Int32.MaxValue milisekund.

ThreadStateException

Volající se pokusil připojit vlákno, které je ve Unstarted stavu.

Příklady

Následující příklad kódu ukazuje použití TimeSpan hodnoty s metodou Join .

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.

Poznámky

Join(TimeSpan) je synchronizační metoda, která blokuje volající vlákno (tj. vlákno, které volá metodu), dokud vlákno, jehož Join metoda je volána dokončena, nebo časový limit uplynul. V následujícím příkladu Thread1 vlákno volá metodu Join()Thread2, která způsobí Thread1 blokování buď do Thread2 dokončení, nebo 2 sekundy uplynula.

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

Pokud Timeout.Infinite je zadán pro timeout, tato metoda se chová stejně jako Join() přetížení metody, s výjimkou návratové hodnoty.

Pokud vlákno již ukončeno při Join zavolání, metoda vrátí okamžitě.

Tato metoda změní stav aktuálního vlákna tak, aby zahrnovala WaitSleepJoin. Nelze vyvolat Join vlákno, které je ve ThreadState.Unstarted stavu.

Viz také

Platí pro