Thread.Join Método

Definición

Espacio de nombres:: System.Threading

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Bloquea el subproceso que realiza la llamada hasta que finaliza el subproceso representado por esta instancia.

Sobrecargas

Nombre	Description
Join()	Bloquea el subproceso que realiza la llamada hasta que finaliza el subproceso representado por esta instancia, al tiempo que continúa realizando com estándar y `SendMessage` bombeo.
Join(Int32)	Bloquea el subproceso que realiza la llamada hasta que el subproceso representado por esta instancia finaliza o transcurre el tiempo especificado, mientras continúa realizando la bomba COM y SendMessage estándar.
Join(TimeSpan)	Bloquea el subproceso que realiza la llamada hasta que el subproceso representado por esta instancia finaliza o transcurre el tiempo especificado, mientras continúa realizando la bomba COM y SendMessage estándar.

Join()

Bloquea el subproceso que realiza la llamada hasta que finaliza el subproceso representado por esta instancia, al tiempo que continúa realizando com estándar y SendMessage bombeo.

public:
 void Join();

public void Join();

member this.Join : unit -> unit

Public Sub Join ()

Excepciones

ThreadStateException

El autor de la llamada intentó unir un subproceso que está en el Unstarted estado .

ThreadInterruptedException

El subproceso se interrumpe mientras espera.

Comentarios

Join es un método de sincronización que bloquea el subproceso que realiza la llamada (es decir, el subproceso que llama al método) hasta que se haya completado el subproceso al que Join se llama. Use este método para asegurarse de que se ha terminado un subproceso. El autor de la llamada se bloqueará indefinidamente si el subproceso no finaliza. En el ejemplo siguiente, el Thread1 subproceso llama al Join() método de Thread2, lo que hace Thread1 que se bloquee hasta Thread2 que se haya completado.

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

Si el subproceso ya ha finalizado cuando Join se llama a , el método devuelve inmediatamente.

Advertencia

Nunca debe llamar al Join método del Thread objeto que representa el subproceso actual del subproceso actual. Esto hace que la aplicación deje de responder porque el subproceso actual espera indefinidamente,

Este método cambia el estado del subproceso que realiza la llamada para incluir ThreadState.WaitSleepJoin. No se puede invocar en un subproceso Join que esté en el ThreadState.Unstarted estado .

Consulte también

ThreadState

Se aplica a

Join(Int32)

Bloquea el subproceso que realiza la llamada hasta que el subproceso representado por esta instancia finaliza o transcurre el tiempo especificado, mientras continúa realizando la bomba COM y SendMessage estándar.

public:
 bool Join(int millisecondsTimeout);

public bool Join(int millisecondsTimeout);

member this.Join : int -> bool

Public Function Join (millisecondsTimeout As Integer) As Boolean

Parámetros

millisecondsTimeout: Int32

Número de milisegundos que se van a esperar a que finalice el subproceso.

Devoluciones

Boolean

true si el subproceso ha finalizado; false si el subproceso no ha finalizado después de que haya transcurrido la cantidad de tiempo especificado por el millisecondsTimeout parámetro.

Excepciones

ArgumentOutOfRangeException

El valor de millisecondsTimeout es negativo y no es igual a Infinite en milisegundos.

ThreadStateException

No se ha iniciado el subproceso.

ArgumentException

millisecondsTimeout es menor que -1 (Timeout.Infinite).

ThreadInterruptedException

El subproceso se interrumpió mientras se esperaba.

Comentarios

Join(Int32) es un método de sincronización que bloquea el subproceso de llamada (es decir, el subproceso que llama al método) hasta que el subproceso al Join que se llama ha completado o el intervalo de tiempo de espera ha transcurrido. En el ejemplo siguiente, el Thread1 subproceso llama al Join() método de Thread2, lo que hace Thread1 que se bloquee hasta que Thread2 haya finalizado o transcurrido 2 segundos.

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

Si Timeout.Infinite se especifica para el millisecondsTimeout parámetro , este método se comporta de forma idéntica a la sobrecarga del Join() método, excepto para el valor devuelto.

Si el subproceso ya ha finalizado cuando Join se llama a , el método devuelve inmediatamente.

Este método cambia el estado del subproceso que realiza la llamada para incluir ThreadState.WaitSleepJoin. No se puede invocar en un subproceso Join que esté en el ThreadState.Unstarted estado .

Consulte también

ThreadState

Se aplica a

Join(TimeSpan)

public:
 bool Join(TimeSpan timeout);

public bool Join(TimeSpan timeout);

member this.Join : TimeSpan -> bool

Public Function Join (timeout As TimeSpan) As Boolean

Parámetros

timeout: TimeSpan

Un TimeSpan valor establecido en la cantidad de tiempo que se va a esperar a que finalice el subproceso.

Devoluciones

Boolean

true si el subproceso finalizó; false si el subproceso no ha finalizado después de que haya transcurrido la cantidad de tiempo especificado por el timeout parámetro.

Excepciones

ArgumentOutOfRangeException

El valor de timeout es negativo y no es igual a Infinite en milisegundos, o es mayor que Int32.MaxValue milisegundos.

ThreadStateException

El autor de la llamada intentó unir un subproceso que está en el Unstarted estado .

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar un TimeSpan valor con el Join método .

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.

Comentarios

Join(TimeSpan) es un método de sincronización que bloquea el subproceso de llamada (es decir, el subproceso que llama al método) hasta que el subproceso al Join que se llama ha completado o el intervalo de tiempo de espera ha transcurrido. En el ejemplo siguiente, el Thread1 subproceso llama al Join() método de Thread2, lo que hace Thread1 que se bloquee hasta que Thread2 haya finalizado o transcurrido 2 segundos.

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

Si Timeout.Infinite se especifica para timeout, este método se comporta de forma idéntica a la sobrecarga del Join() método, excepto para el valor devuelto.

Si el subproceso ya ha finalizado cuando Join se llama a , el método devuelve inmediatamente.

Este método cambia el estado del subproceso actual para incluir WaitSleepJoin. No se puede invocar en un subproceso Join que esté en el ThreadState.Unstarted estado .

Consulte también

ThreadState

Se aplica a

Comentarios

Resultoulle útil esta páxina?