Bagikan melalui

Thread.Join Metode

  • Referensi

Definisi

Ruang nama:
System.Threading
Rakitan:
System.Threading.Thread.dll
Rakitan:
mscorlib.dll
Rakitan:
netstandard.dll

Memblokir utas panggilan hingga utas yang diwakili oleh instans ini berakhir.

Overload

Join()

Memblokir utas panggilan hingga utas yang diwakili oleh instans ini berakhir, sambil terus melakukan COM standar dan SendMessage pemompaan.
Join(Int32)

Memblokir utas panggilan hingga utas yang diwakili oleh instans ini berakhir atau waktu yang ditentukan berlalu, sambil terus melakukan pemompaan COM dan SendMessage standar.
Join(TimeSpan)

Memblokir utas panggilan hingga utas yang diwakili oleh instans ini berakhir atau waktu yang ditentukan berlalu, sambil terus melakukan pemompaan COM dan SendMessage standar.

Join()

Sumber:
Thread.cs
Sumber:
Thread.cs
Sumber:
Thread.cs

Memblokir utas panggilan hingga utas yang diwakili oleh instans ini berakhir, sambil terus melakukan COM standar dan SendMessage pemompaan.

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

Pengecualian

ThreadStateException

Pemanggil mencoba menggabungkan utas yang berada dalam status Unstarted .

ThreadInterruptedException

Utas terganggu saat menunggu.

Keterangan

Join adalah metode sinkronisasi yang memblokir utas panggilan (yaitu, utas yang memanggil metode ) hingga utas yang metodenya Join disebut telah selesai. Gunakan metode ini untuk memastikan bahwa utas telah dihentikan. Pemanggil akan memblokir tanpa batas waktu jika utas tidak dihentikan. Dalam contoh berikut, Thread1 utas Join() memanggil metode , yang menyebabkan Thread1 pemblokiran Thread2hingga Thread2 selesai.

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

Jika utas telah dihentikan ketika Join dipanggil, metode akan segera kembali.

Peringatan

Anda tidak boleh memanggil Join metode Thread objek yang mewakili utas saat ini dari utas saat ini. Ini menyebabkan aplikasi Anda menjadi tidak responsif karena utas saat ini menunggu dengan sendirinya tanpa batas waktu,

Metode ini mengubah status utas panggilan untuk menyertakan ThreadState.WaitSleepJoin. Anda tidak dapat memanggil Join pada utas yang berada dalam status ThreadState.Unstarted .

Lihat juga

Berlaku untuk

Join(Int32)

Sumber:
Thread.cs
Sumber:
Thread.cs
Sumber:
Thread.cs

Memblokir utas panggilan hingga utas yang diwakili oleh instans ini berakhir atau waktu yang ditentukan berlalu, sambil terus melakukan pemompaan COM dan SendMessage standar.

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

Parameter

millisecondsTimeout
Int32

Jumlah milidetik untuk menunggu utas dihentikan.

Mengembalikan

Boolean

true jika utas telah dihentikan; false jika utas belum dihentikan setelah jumlah waktu yang ditentukan oleh millisecondsTimeout parameter telah berlalu.

Pengecualian

ArgumentOutOfRangeException

Nilai millisecondsTimeout negatif dan tidak sama dengan Infinite dalam milidetik.

ThreadStateException

Utas belum dimulai.

ArgumentException

millisecondsTimeout kurang dari -1 (Timeout.Infinite).

ThreadInterruptedException

Utas terganggu saat menunggu.

Keterangan

Join(Int32) adalah metode sinkronisasi yang memblokir utas panggilan (yaitu, utas yang memanggil metode ) hingga utas yang metodenya Join disebut telah selesai atau interval waktu habis telah berlalu. Dalam contoh berikut, Thread1 utas Join() memanggil metode , yang menyebabkan Thread1 pemblokiran Thread2hingga Thread2 selesai atau 2 detik telah berlalu.

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

Jika Timeout.Infinite ditentukan untuk millisecondsTimeout parameter, metode ini bersifat identik dengan Join() metode kelebihan beban, kecuali untuk nilai yang dikembalikan.

Jika utas telah dihentikan ketika Join dipanggil, metode akan segera kembali.

Metode ini mengubah status utas panggilan untuk menyertakan ThreadState.WaitSleepJoin. Anda tidak dapat memanggil Join pada utas yang berada dalam status ThreadState.Unstarted .

Lihat juga

Berlaku untuk

Join(TimeSpan)

Sumber:
Thread.cs
Sumber:
Thread.cs
Sumber:
Thread.cs

Memblokir utas panggilan hingga utas yang diwakili oleh instans ini berakhir atau waktu yang ditentukan berlalu, sambil terus melakukan pemompaan COM dan SendMessage standar.

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

Parameter

timeout
TimeSpan

Atur TimeSpan ke jumlah waktu untuk menunggu utas dihentikan.

Mengembalikan

Boolean

true jika utas dihentikan; false jika utas belum dihentikan setelah jumlah waktu yang ditentukan oleh timeout parameter telah berlalu.

Pengecualian

ArgumentOutOfRangeException

Nilai timeout negatif dan tidak sama dengan Infinite dalam milidetik, atau lebih besar dari Int32.MaxValue milidetik.

ThreadStateException

Pemanggil mencoba menggabungkan utas yang berada dalam status Unstarted .

Contoh

Contoh kode berikut menunjukkan cara menggunakan TimeSpan nilai dengan Join metode .

using namespace System;
using namespace System::Threading;

static TimeSpan waitTime = TimeSpan(0,0,1);

ref class Test
{
public:
   static void Work()
   {
      Thread::Sleep( waitTime );
   }

};

int main()
{
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( Test::Work ) );
   newThread->Start();
   if ( newThread->Join( waitTime + waitTime ) )
   {
      Console::WriteLine( "New thread terminated." );
   }
   else
   {
      Console::WriteLine( "Join timed out." );
   }
}
// The example displays the following output:
//        New thread terminated.

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.

Keterangan

Join(TimeSpan) adalah metode sinkronisasi yang memblokir utas panggilan (yaitu, utas yang memanggil metode ) hingga utas yang metodenya Join disebut telah selesai atau interval waktu habis telah berlalu. Dalam contoh berikut, Thread1 utas Join() memanggil metode , yang menyebabkan Thread1 pemblokiran Thread2hingga Thread2 selesai atau 2 detik telah berlalu.

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

Jika Timeout.Infinite ditentukan untuk timeout, metode ini bersifat identik dengan Join() metode kelebihan beban, kecuali untuk nilai yang dikembalikan.

Jika utas telah dihentikan ketika Join dipanggil, metode akan segera kembali.

Metode ini mengubah status utas saat ini untuk menyertakan WaitSleepJoin. Anda tidak dapat memanggil Join pada utas yang berada dalam status ThreadState.Unstarted .

Lihat juga

Berlaku untuk