Clase System.Threading.Thread
En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.
La Thread clase crea y controla un subproceso, establece su prioridad y obtiene su estado.
Cuando se inicia un proceso, Common Language Runtime crea automáticamente un único subproceso en primer plano para ejecutar código de aplicación. Junto con este subproceso principal en primer plano, un proceso puede crear uno o varios subprocesos para ejecutar una parte del código del programa asociado al proceso. Estos subprocesos se pueden ejecutar en primer plano o en segundo plano. Además, puede usar la ThreadPool clase para ejecutar código en subprocesos de trabajo administrados por Common Language Runtime.
Iniciar un subproceso
Para iniciar un subproceso, proporcione un delegado que represente el método que el subproceso va a ejecutar en su constructor de clases. A continuación, llame al Start método para comenzar la ejecución.
Los Thread constructores pueden tomar cualquiera de los dos tipos de delegado, en función de si puede pasar un argumento al método que se va a ejecutar:
Si el método no tiene argumentos, se pasa un ThreadStart delegado al constructor. Tiene la firma :
public delegate void ThreadStart()Public Delegate Sub ThreadStart()En el ejemplo siguiente se crea e inicia un subproceso que ejecuta el
ExecuteInForegroundmétodo . El método muestra información sobre algunas propiedades del subproceso y, a continuación, ejecuta un bucle en el que se pausa durante medio segundo y muestra el número transcurrido de segundos. Cuando el subproceso se ha ejecutado durante al menos cinco segundos, el bucle finaliza y el subproceso finaliza la ejecución.using System; using System.Diagnostics; using System.Threading; public class Example2 { public static void Main() { var th = new Thread(ExecuteInForeground); th.Start(); Thread.Sleep(1000); Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId); } private static void ExecuteInForeground() { var sw = Stopwatch.StartNew(); Console.WriteLine("Thread {0}: {1}, Priority {2}", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState, Thread.CurrentThread.Priority); do { Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", Thread.CurrentThread.ManagedThreadId, sw.ElapsedMilliseconds / 1000.0); Thread.Sleep(500); } while (sw.ElapsedMilliseconds <= 5000); sw.Stop(); } } // The example displays output like the following: // Thread 3: Running, Priority Normal // Thread 3: Elapsed 0.00 seconds // Thread 3: Elapsed 0.51 seconds // Main thread (1) exiting... // Thread 3: Elapsed 1.02 seconds // Thread 3: Elapsed 1.53 seconds // Thread 3: Elapsed 2.05 seconds // Thread 3: Elapsed 2.55 seconds // Thread 3: Elapsed 3.07 seconds // Thread 3: Elapsed 3.57 seconds // Thread 3: Elapsed 4.07 seconds // Thread 3: Elapsed 4.58 secondsopen System.Diagnostics open System.Threading let executeInForeground () = let sw = Stopwatch.StartNew() printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}" while sw.ElapsedMilliseconds <= 5000 do printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds" Thread.Sleep 500 sw.Stop() let th = Thread executeInForeground th.Start() Thread.Sleep 1000 printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..." // The example displays output like the following: // Thread 3: Running, Priority Normal // Thread 3: Elapsed 0.00 seconds // Thread 3: Elapsed 0.51 seconds // Main thread (1) exiting... // Thread 3: Elapsed 1.02 seconds // Thread 3: Elapsed 1.53 seconds // Thread 3: Elapsed 2.05 seconds // Thread 3: Elapsed 2.55 seconds // Thread 3: Elapsed 3.07 seconds // Thread 3: Elapsed 3.57 seconds // Thread 3: Elapsed 4.07 seconds // Thread 3: Elapsed 4.58 secondsImports System.Diagnostics Imports System.Threading Module Example3 Public Sub Main() Dim th As New Thread(AddressOf ExecuteInForeground) th.Start() Thread.Sleep(1000) Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) End Sub Private Sub ExecuteInForeground() Dim start As DateTime = DateTime.Now Dim sw As Stopwatch = Stopwatch.StartNew() Console.WriteLine("Thread {0}: {1}, Priority {2}", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState, Thread.CurrentThread.Priority) Do Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", Thread.CurrentThread.ManagedThreadId, sw.ElapsedMilliseconds / 1000) Thread.Sleep(500) Loop While sw.ElapsedMilliseconds <= 5000 sw.Stop() End Sub End Module ' The example displays output like the following: ' Thread 3: Running, Priority Normal ' Thread 3: Elapsed 0.00 seconds ' Thread 3: Elapsed 0.51 seconds ' Main thread (1) exiting... ' Thread 3: Elapsed 1.02 seconds ' Thread 3: Elapsed 1.53 seconds ' Thread 3: Elapsed 2.05 seconds ' Thread 3: Elapsed 2.55 seconds ' Thread 3: Elapsed 3.07 seconds ' Thread 3: Elapsed 3.57 seconds ' Thread 3: Elapsed 4.07 seconds ' Thread 3: Elapsed 4.58 secondsSi el método tiene un argumento, se pasa un ParameterizedThreadStart delegado al constructor. Tiene la firma :
public delegate void ParameterizedThreadStart(object obj)Public Delegate Sub ParameterizedThreadStart(obj As Object)El método ejecutado por el delegado puede convertir (en C#) o convertir (en Visual Basic) el parámetro al tipo adecuado.
El ejemplo siguiente es idéntico al anterior, salvo que llama al Thread(ParameterizedThreadStart) constructor . Esta versión del
ExecuteInForegroundmétodo tiene un único parámetro que representa el número aproximado de milisegundos que se va a ejecutar el bucle.using System; using System.Diagnostics; using System.Threading; public class Example3 { public static void Main() { var th = new Thread(ExecuteInForeground); th.Start(4500); Thread.Sleep(1000); Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId); } private static void ExecuteInForeground(Object obj) { int interval; try { interval = (int) obj; } catch (InvalidCastException) { interval = 5000; } var sw = Stopwatch.StartNew(); Console.WriteLine("Thread {0}: {1}, Priority {2}", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState, Thread.CurrentThread.Priority); do { Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", Thread.CurrentThread.ManagedThreadId, sw.ElapsedMilliseconds / 1000.0); Thread.Sleep(500); } while (sw.ElapsedMilliseconds <= interval); sw.Stop(); } } // The example displays output like the following: // Thread 3: Running, Priority Normal // Thread 3: Elapsed 0.00 seconds // Thread 3: Elapsed 0.52 seconds // Main thread (1) exiting... // Thread 3: Elapsed 1.03 seconds // Thread 3: Elapsed 1.55 seconds // Thread 3: Elapsed 2.06 seconds // Thread 3: Elapsed 2.58 seconds // Thread 3: Elapsed 3.09 seconds // Thread 3: Elapsed 3.61 seconds // Thread 3: Elapsed 4.12 secondsopen System open System.Diagnostics open System.Threading let executeInForeground obj = let interval = try unbox<int> obj with :? InvalidCastException -> 5000 let sw = Stopwatch.StartNew() printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}" while sw.ElapsedMilliseconds <= interval do printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds" Thread.Sleep 500 sw.Stop() let th = Thread(ParameterizedThreadStart executeInForeground) th.Start 4500 Thread.Sleep 1000 printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..." // The example displays output like the following: // Thread 3: Running, Priority Normal // Thread 3: Elapsed 0.00 seconds // Thread 3: Elapsed 0.52 seconds // Main thread (1) exiting... // Thread 3: Elapsed 1.03 seconds // Thread 3: Elapsed 1.55 seconds // Thread 3: Elapsed 2.06 seconds // Thread 3: Elapsed 2.58 seconds // Thread 3: Elapsed 3.09 seconds // Thread 3: Elapsed 3.61 seconds // Thread 3: Elapsed 4.12 secondsImports System.Diagnostics Imports System.Threading Module Example4 Public Sub Main() Dim th As New Thread(AddressOf ExecuteInForeground) th.Start(4500) Thread.Sleep(1000) Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId) End Sub Private Sub ExecuteInForeground(obj As Object) Dim interval As Integer If IsNumeric(obj) Then interval = CInt(obj) Else interval = 5000 End If Dim start As DateTime = DateTime.Now Dim sw As Stopwatch = Stopwatch.StartNew() Console.WriteLine("Thread {0}: {1}, Priority {2}", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState, Thread.CurrentThread.Priority) Do Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds", Thread.CurrentThread.ManagedThreadId, sw.ElapsedMilliseconds / 1000) Thread.Sleep(500) Loop While sw.ElapsedMilliseconds <= interval sw.Stop() End Sub End Module ' The example displays output like the following: ' Thread 3: Running, Priority Normal ' Thread 3: Elapsed 0.00 seconds ' Thread 3: Elapsed 0.52 seconds ' Main thread (1) exiting... ' Thread 3: Elapsed 1.03 seconds ' Thread 3: Elapsed 1.55 seconds ' Thread 3: Elapsed 2.06 seconds ' Thread 3: Elapsed 2.58 seconds ' Thread 3: Elapsed 3.09 seconds ' Thread 3: Elapsed 3.61 seconds ' Thread 3: Elapsed 4.12 seconds
No es necesario conservar una referencia a un Thread objeto una vez que haya iniciado el subproceso. El subproceso continúa ejecutándose hasta que se complete el procedimiento de subproceso.
Recuperar objetos de subproceso
Puede usar la propiedad estática (Shared en Visual Basic) CurrentThread para recuperar una referencia al subproceso que se está ejecutando actualmente desde el código que ejecuta el subproceso. En el ejemplo siguiente se usa la CurrentThread propiedad para mostrar información sobre el subproceso principal de la aplicación, otro subproceso en primer plano, un subproceso en segundo plano y un subproceso del grupo de subprocesos.
using System;
using System.Threading;
public class Example1
{
static Object obj = new Object();
public static void Main()
{
ThreadPool.QueueUserWorkItem(ShowThreadInformation);
var th1 = new Thread(ShowThreadInformation);
th1.Start();
var th2 = new Thread(ShowThreadInformation);
th2.IsBackground = true;
th2.Start();
Thread.Sleep(500);
ShowThreadInformation(null);
}
private static void ShowThreadInformation(Object state)
{
lock (obj) {
var th = Thread.CurrentThread;
Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId);
Console.WriteLine(" Background thread: {0}", th.IsBackground);
Console.WriteLine(" Thread pool thread: {0}", th.IsThreadPoolThread);
Console.WriteLine(" Priority: {0}", th.Priority);
Console.WriteLine(" Culture: {0}", th.CurrentCulture.Name);
Console.WriteLine(" UI culture: {0}", th.CurrentUICulture.Name);
Console.WriteLine();
}
}
}
// The example displays output like the following:
// Managed thread #6:
// Background thread: True
// Thread pool thread: False
// Priority: Normal
// Culture: en-US
// UI culture: en-US
//
// Managed thread #3:
// Background thread: True
// Thread pool thread: True
// Priority: Normal
// Culture: en-US
// UI culture: en-US
//
// Managed thread #4:
// Background thread: False
// Thread pool thread: False
// Priority: Normal
// Culture: en-US
// UI culture: en-US
//
// Managed thread #1:
// Background thread: False
// Thread pool thread: False
// Priority: Normal
// Culture: en-US
// UI culture: en-US
open System.Threading
let obj = obj ()
let showThreadInformation (state: obj) =
lock obj (fun () ->
let th = Thread.CurrentThread
printfn $"Managed thread #{th.ManagedThreadId}: "
printfn $" Background thread: {th.IsBackground}"
printfn $" Thread pool thread: {th.IsThreadPoolThread}"
printfn $" Priority: {th.Priority}"
printfn $" Culture: {th.CurrentCulture.Name}"
printfn $" UI culture: {th.CurrentUICulture.Name}"
printfn "")
ThreadPool.QueueUserWorkItem showThreadInformation |> ignore
let th1 = Thread(ParameterizedThreadStart showThreadInformation)
th1.Start()
let th2 = Thread(ParameterizedThreadStart showThreadInformation)
th2.IsBackground <- true
th2.Start()
Thread.Sleep 500
showThreadInformation ()
// The example displays output like the following:
// Managed thread #6:
// Background thread: True
// Thread pool thread: False
// Priority: Normal
// Culture: en-US
// UI culture: en-US
//
// Managed thread #3:
// Background thread: True
// Thread pool thread: True
// Priority: Normal
// Culture: en-US
// UI culture: en-US
//
// Managed thread #4:
// Background thread: False
// Thread pool thread: False
// Priority: Normal
// Culture: en-US
// UI culture: en-US
//
// Managed thread #1:
// Background thread: False
// Thread pool thread: False
// Priority: Normal
// Culture: en-US
// UI culture: en-US
Imports System.Threading
Module Example2
Private lock As New Object()
Public Sub Main()
ThreadPool.QueueUserWorkItem(AddressOf ShowThreadInformation)
Dim th1 As New Thread(AddressOf ShowThreadInformation)
th1.Start()
Dim th2 As New Thread(AddressOf ShowThreadInformation)
th2.IsBackground = True
th2.Start()
Thread.Sleep(500)
ShowThreadInformation(Nothing)
End Sub
Private Sub ShowThreadInformation(state As Object)
SyncLock lock
Dim th As Thread = Thread.CurrentThread
Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId)
Console.WriteLine(" Background thread: {0}", th.IsBackground)
Console.WriteLine(" Thread pool thread: {0}", th.IsThreadPoolThread)
Console.WriteLine(" Priority: {0}", th.Priority)
Console.WriteLine(" Culture: {0}", th.CurrentCulture.Name)
Console.WriteLine(" UI culture: {0}", th.CurrentUICulture.Name)
Console.WriteLine()
End SyncLock
End Sub
End Module
' The example displays output like the following:
' ' Managed thread #6:
' Background thread: True
' Thread pool thread: False
' Priority: Normal
' Culture: en-US
' UI culture: en-US
'
' Managed thread #3:
' Background thread: True
' Thread pool thread: True
' Priority: Normal
' Culture: en-US
' UI culture: en-US
'
' Managed thread #4:
' Background thread: False
' Thread pool thread: False
' Priority: Normal
' Culture: en-US
' UI culture: en-US
'
' Managed thread #1:
' Background thread: False
' Thread pool thread: False
' Priority: Normal
' Culture: en-US
' UI culture: en-US
Subprocesos de primer y segundo plano
Las instancias de la Thread clase representan subprocesos en primer plano o subprocesos en segundo plano. Los subprocesos en segundo plano son idénticos a los subprocesos en primer plano con una excepción: un subproceso en segundo plano no mantiene un proceso en ejecución si todos los subprocesos en primer plano han finalizado. Una vez detenidos todos los subprocesos en primer plano, el tiempo de ejecución detiene todos los subprocesos en segundo plano y se cierra.
De forma predeterminada, los subprocesos siguientes se ejecutan en primer plano:
El subproceso de aplicación principal.
Todos los subprocesos creados mediante una llamada a un Thread constructor de clases.
Los subprocesos siguientes se ejecutan en segundo plano de forma predeterminada:
Subprocesos del grupo de subprocesos, que proceden de un grupo de subprocesos de trabajo mantenidos por el tiempo de ejecución. Puede configurar el grupo de subprocesos y programar el trabajo en los subprocesos del grupo de subprocesos mediante la ThreadPool clase .
Nota:
Las operaciones asincrónicas basadas en tareas se ejecutan automáticamente en subprocesos del grupo de subprocesos. Las operaciones asincrónicas basadas en tareas usan las Task clases y Task<TResult> para implementar el patrón asincrónico basado en tareas.
Todos los subprocesos que entran en el entorno de ejecución administrado desde código no administrado.
Puede cambiar un subproceso para que se ejecute en segundo plano estableciendo la IsBackground propiedad en cualquier momento. Los subprocesos en segundo plano son útiles para cualquier operación que debe continuar siempre que se ejecute una aplicación, pero no debe impedir que la aplicación finalice, como supervisar los cambios del sistema de archivos o las conexiones de socket entrantes.
En el ejemplo siguiente se muestra la diferencia entre los subprocesos en primer plano y en segundo plano. Es como el primer ejemplo de la sección Iniciar un subproceso , salvo que establece que el subproceso se ejecute en segundo plano antes de iniciarlo. Como se muestra en la salida, el bucle se interrumpe antes de que se ejecute durante cinco segundos.
using System;
using System.Diagnostics;
using System.Threading;
public class Example
{
public static void Main()
{
var th = new Thread(ExecuteInForeground);
th.IsBackground = true;
th.Start();
Thread.Sleep(1000);
Console.WriteLine("Main thread ({0}) exiting...",
Thread.CurrentThread.ManagedThreadId);
}
private static void ExecuteInForeground()
{
var sw = Stopwatch.StartNew();
Console.WriteLine("Thread {0}: {1}, Priority {2}",
Thread.CurrentThread.ManagedThreadId,
Thread.CurrentThread.ThreadState,
Thread.CurrentThread.Priority);
do {
Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
Thread.CurrentThread.ManagedThreadId,
sw.ElapsedMilliseconds / 1000.0);
Thread.Sleep(500);
} while (sw.ElapsedMilliseconds <= 5000);
sw.Stop();
}
}
// The example displays output like the following:
// Thread 3: Background, Priority Normal
// Thread 3: Elapsed 0.00 seconds
// Thread 3: Elapsed 0.51 seconds
// Main thread (1) exiting...
open System.Diagnostics
open System.Threading
let executeInForeground () =
let sw = Stopwatch.StartNew()
printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
while sw.ElapsedMilliseconds <= 5000 do
printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
Thread.Sleep 500
sw.Stop()
let th = Thread executeInForeground
th.IsBackground <- true
th.Start()
Thread.Sleep 1000
printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."
// The example displays output like the following:
// Thread 3: Background, Priority Normal
// Thread 3: Elapsed 0.00 seconds
// Thread 3: Elapsed 0.51 seconds
// Main thread (1) exiting...
Imports System.Diagnostics
Imports System.Threading
Module Example1
Public Sub Main()
Dim th As New Thread(AddressOf ExecuteInForeground)
th.IsBackground = True
th.Start()
Thread.Sleep(1000)
Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId)
End Sub
Private Sub ExecuteInForeground()
Dim start As DateTime = DateTime.Now
Dim sw As Stopwatch = Stopwatch.StartNew()
Console.WriteLine("Thread {0}: {1}, Priority {2}",
Thread.CurrentThread.ManagedThreadId,
Thread.CurrentThread.ThreadState,
Thread.CurrentThread.Priority)
Do
Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
Thread.CurrentThread.ManagedThreadId,
sw.ElapsedMilliseconds / 1000)
Thread.Sleep(500)
Loop While sw.ElapsedMilliseconds <= 5000
sw.Stop()
End Sub
End Module
' The example displays output like the following:
' Thread 3: Background, Priority Normal
' Thread 3: Elapsed 0.00 seconds
' Thread 3: Elapsed 0.51 seconds
' Main thread (1) exiting...
Referencias culturales y subprocesos
Cada subproceso tiene una referencia cultural, representada por la CurrentCulture propiedad y una referencia cultural de interfaz de usuario, representada por la CurrentUICulture propiedad . La referencia cultural actual admite operaciones sensibles a la referencia cultural, como el análisis y el formato, la comparación de cadenas y la ordenación, y también controla el sistema de escritura y el calendario usados por un subproceso. La referencia cultural actual de la interfaz de usuario proporciona una recuperación que distingue la referencia cultural de los recursos en los archivos de recursos.
Importante
Las CurrentCulture propiedades y CurrentUICulture no funcionan de forma confiable cuando se usan con ningún subproceso distinto del subproceso actual. En .NET Framework, leer estas propiedades es confiable, aunque no es el establecimiento de estas propiedades para un subproceso distinto del subproceso actual. En .NET Core, se produce una InvalidOperationException excepción si un subproceso intenta leer o escribir estas propiedades en otro subproceso. Se recomienda usar las CultureInfo.CurrentCulture propiedades y CultureInfo.CurrentUICulture para recuperar y establecer la referencia cultural actual.
Cuando se crea una instancia de un nuevo subproceso, la referencia cultural y la referencia cultural de la interfaz de usuario se definen mediante la referencia cultural del sistema actual y la referencia cultural de la interfaz de usuario, y no la referencia cultural de la interfaz de usuario del subproceso desde el que se crea el nuevo subproceso. Esto significa, por ejemplo, que si la referencia cultural actual del sistema es inglés (Estados Unidos) y la referencia cultural actual del subproceso de aplicación principal es francés (Francia), la referencia cultural de un nuevo subproceso creado llamando al Thread(ParameterizedThreadStart) constructor desde el subproceso principal es inglés (Estados Unidos) y no francés (Francia). Para obtener más información, vea la sección "Referencia cultural y subprocesos" del tema de clase CultureInfo .
Importante
Esto no es cierto en los subprocesos que ejecutan operaciones asincrónicas para aplicaciones destinadas a .NET Framework 4.6 y versiones posteriores. En este caso, la referencia cultural y la referencia cultural de la interfaz de usuario forman parte del contexto de una operación asincrónica; el subproceso en el que se ejecuta una operación asincrónica de forma predeterminada hereda la referencia cultural y la referencia cultural de la interfaz de usuario del subproceso desde el que se inició la operación asincrónica. Para obtener más información, vea la sección "Referencia cultural y operaciones asincrónicas basadas en tareas" de los comentarios de clase CultureInfo .
Puede hacer cualquiera de las siguientes acciones para asegurarse de que todos los subprocesos que se ejecutan en una aplicación comparten la misma referencia cultural y la misma referencia cultural de la interfaz de usuario:
Puede pasar un CultureInfo objeto que represente esa referencia cultural al ParameterizedThreadStart delegado o al ThreadPool.QueueUserWorkItem(WaitCallback, Object) método .
En el caso de las aplicaciones que se ejecutan en .NET Framework 4.5 y versiones posteriores, puede definir la referencia cultural y la referencia cultural de la interfaz de usuario que se va a asignar a todos los subprocesos creados en un dominio de aplicación estableciendo el valor de las CultureInfo.DefaultThreadCurrentCulture propiedades y CultureInfo.DefaultThreadCurrentUICulture . Tenga en cuenta que se trata de una configuración de dominio por aplicación.
Para obtener más información y ejemplos, vea la sección "Referencia cultural y subprocesos" de los comentarios de clase CultureInfo .
Obtener información sobre los subprocesos de control y
Puede recuperar una serie de valores de propiedad que proporcionan información sobre un subproceso. En algunos casos, también puede establecer estos valores de propiedad para controlar la operación del subproceso. Estas propiedades de subproceso incluyen:
Un nombre. Name es una propiedad write-once que puede usar para identificar un subproceso. Su valor predeterminado es
null.Código hash, que puede recuperar llamando al GetHashCode método . El código hash se puede usar para identificar de forma única un subproceso; durante la vigencia del subproceso, su código hash no colisionará con el valor de ningún otro subproceso, independientemente del dominio de aplicación desde el que obtenga el valor.
Un identificador de subproceso. El tiempo de ejecución asigna el valor de la propiedad de solo ManagedThreadId lectura y identifica de forma única un subproceso dentro de su proceso.
Nota:
Un ThreadId de sistema operativo no tiene una relación fija con un subproceso administrado, ya que un host no administrado puede controlar la relación entre subprocesos administrados y no administrados. En concreto, un host sofisticado puede usar la API de hospedaje de CLR para programar muchos subprocesos administrados en el mismo subproceso del sistema operativo, o para mover un subproceso administrado entre diferentes subprocesos del sistema operativo.
Estado actual del subproceso. Durante su existencia, un subproceso siempre se encuentra en uno o varios de los estados definidos por la ThreadState propiedad .
Un nivel de prioridad de programación, definido por la ThreadPriority propiedad . Aunque puede establecer este valor para solicitar la prioridad de un subproceso, no se garantiza que el sistema operativo respete.
La propiedad de solo IsThreadPoolThread lectura, que indica si un subproceso es un subproceso de grupo de subprocesos.
Propiedad IsBackground Para obtener más información, consulte la sección Subprocesos en primer plano y en segundo plano.
Ejemplos
En el ejemplo siguiente se muestra la funcionalidad de subproceso simple.
using System;
using System.Threading;
// Simple threading scenario: Start a static method running
// on a second thread.
public class ThreadExample {
// The ThreadProc method is called when the thread starts.
// It loops ten times, writing to the console and yielding
// the rest of its time slice each time, and then ends.
public static void ThreadProc() {
for (int i = 0; i < 10; i++) {
Console.WriteLine("ThreadProc: {0}", i);
// Yield the rest of the time slice.
Thread.Sleep(0);
}
}
public static void Main() {
Console.WriteLine("Main thread: Start a second thread.");
// The constructor for the Thread class requires a ThreadStart
// delegate that represents the method to be executed on the
// thread. C# simplifies the creation of this delegate.
Thread t = new Thread(new ThreadStart(ThreadProc));
// Start ThreadProc. Note that on a uniprocessor, the new
// thread does not get any processor time until the main thread
// is preempted or yields. Uncomment the Thread.Sleep that
// follows t.Start() to see the difference.
t.Start();
//Thread.Sleep(0);
for (int i = 0; i < 4; i++) {
Console.WriteLine("Main thread: Do some work.");
Thread.Sleep(0);
}
Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
t.Join();
Console.WriteLine("Main thread: ThreadProc.Join has returned. Press Enter to end program.");
Console.ReadLine();
}
}
open System.Threading
// Simple threading scenario: Start a static method running
// on a second thread.
// The ThreadProc method is called when the thread starts.
// It loops ten times, writing to the console and yielding
// the rest of its time slice each time, and then ends.
let threadProc () =
for i = 0 to 9 do
printfn $"ThreadProc: {i}"
// Yield the rest of the time slice.
Thread.Sleep 0
printfn "Main thread: Start a second thread."
// The constructor for the Thread class requires a ThreadStart
// delegate that represents the method to be executed on the
// thread. F# simplifies the creation of this delegate.
let t = Thread threadProc
// Start ThreadProc. Note that on a uniprocessor, the new
// thread does not get any processor time until the main thread
// is preempted or yields. Uncomment the Thread.Sleep that
// follows t.Start() to see the difference.
t.Start()
//Thread.Sleep 0
for _ = 0 to 3 do
printfn "Main thread: Do some work."
Thread.Sleep 0
printfn "Main thread: Call Join(), to wait until ThreadProc ends."
t.Join()
printfn "Main thread: ThreadProc.Join has returned. Press Enter to end program."
stdin.ReadLine() |> ignore
Imports System.Threading
' Simple threading scenario: Start a Shared method running
' on a second thread.
Public Class ThreadExample
' The ThreadProc method is called when the thread starts.
' It loops ten times, writing to the console and yielding
' the rest of its time slice each time, and then ends.
Public Shared Sub ThreadProc()
Dim i As Integer
For i = 0 To 9
Console.WriteLine("ThreadProc: {0}", i)
' Yield the rest of the time slice.
Thread.Sleep(0)
Next
End Sub
Public Shared Sub Main()
Console.WriteLine("Main thread: Start a second thread.")
' The constructor for the Thread class requires a ThreadStart
' delegate. The Visual Basic AddressOf operator creates this
' delegate for you.
Dim t As New Thread(AddressOf ThreadProc)
' Start ThreadProc. Note that on a uniprocessor, the new
' thread does not get any processor time until the main thread
' is preempted or yields. Uncomment the Thread.Sleep that
' follows t.Start() to see the difference.
t.Start()
'Thread.Sleep(0)
Dim i As Integer
For i = 1 To 4
Console.WriteLine("Main thread: Do some work.")
Thread.Sleep(0)
Next
Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.")
t.Join()
Console.WriteLine("Main thread: ThreadProc.Join has returned. Press Enter to end program.")
Console.ReadLine()
End Sub
End Class
Este código genera una salida similar a la siguiente:
[VB, C++, C#]
Main thread: Start a second thread.
Main thread: Do some work.
ThreadProc: 0
Main thread: Do some work.
ThreadProc: 1
Main thread: Do some work.
ThreadProc: 2
Main thread: Do some work.
ThreadProc: 3
Main thread: Call Join(), to wait until ThreadProc ends.
ThreadProc: 4
ThreadProc: 5
ThreadProc: 6
ThreadProc: 7
ThreadProc: 8
ThreadProc: 9
Main thread: ThreadProc.Join has returned. Press Enter to end program.
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de