Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase Thread

 

Publicado: octubre de 2016

Crea y controla un subproceso, establece su prioridad y obtiene su estado.

Espacio de nombres:   System.Threading
Ensamblado:  mscorlib (en mscorlib.dll)


[ClassInterfaceAttribute(ClassInterfaceType.None)]
[ComVisibleAttribute(true)]
public sealed class Thread : CriticalFinalizerObject, _Thread

NombreDescripción
System_CAPS_pubmethodThread(ParameterizedThreadStart)

Inicializa una nueva instancia de la clase Thread, especificando un delegado que permite pasar un objeto al subproceso cuando este último se inicia.

System_CAPS_pubmethodThread(ParameterizedThreadStart, Int32)

Inicializa una nueva instancia de la clase Thread y, para ello, especifica un delegado que permite pasar un objeto al subproceso cuando este último se inicia; además, especifica el tamaño de pila máximo para el subproceso.

System_CAPS_pubmethodThread(ThreadStart)

Inicializa una nueva instancia de la clase Thread.

System_CAPS_pubmethodThread(ThreadStart, Int32)

Inicializa una nueva instancia de la clase Thread, especificando el tamaño de pila máximo para el subproceso.

NombreDescripción
System_CAPS_pubpropertyApartmentState

Obsoleto. Obtiene o establece el estado de apartamento de este subproceso.

System_CAPS_pubpropertySystem_CAPS_staticCurrentContext

Obtiene el contexto actual donde se está ejecutando el subproceso.

System_CAPS_pubpropertyCurrentCulture

Obtiene o establece la referencia cultural del subproceso actual.

System_CAPS_pubpropertySystem_CAPS_staticCurrentPrincipal

Obtiene o establece la entidad de seguridad actual del subproceso (de la seguridad basada en roles).

System_CAPS_pubpropertySystem_CAPS_staticCurrentThread

Obtiene el subproceso actualmente en ejecución.

System_CAPS_pubpropertyCurrentUICulture

Obtiene o establece la referencia cultural actual utilizada por el administrador de recursos para buscar recursos específicos de la referencia cultural en tiempo de ejecución.

System_CAPS_pubpropertyExecutionContext

Obtiene un objeto ExecutionContext que contiene información sobre los distintos contextos del subproceso actual.

System_CAPS_pubpropertyIsAlive

Obtiene un valor que indica el estado de ejecución del subproceso actual.

System_CAPS_pubpropertyIsBackground

Obtiene o establece un valor que indica si un subproceso es o no un subproceso en segundo plano.

System_CAPS_pubpropertyIsThreadPoolThread

Obtiene un valor que indica si un subproceso pertenece al grupo de subprocesos administrados o no.

System_CAPS_pubpropertyManagedThreadId

Obtiene un identificador único para el actual subproceso administrado.

System_CAPS_pubpropertyName

Obtiene o establece el nombre del subproceso.

System_CAPS_pubpropertyPriority

Obtiene o establece un valor que indica la prioridad de programación de un subproceso.

System_CAPS_pubpropertyThreadState

Obtiene un valor que contiene los estados del subproceso actual.

NombreDescripción
System_CAPS_pubmethodAbort()

Produce una excepción ThreadAbortException en el subproceso en el que se invoca, para iniciar el proceso de finalización del subproceso. Normalmente, una llamada a este método finaliza el subproceso.

System_CAPS_pubmethodAbort(Object)

Produce una excepción ThreadAbortException en el subproceso en el que se invoca, para iniciar el proceso de finalización del subproceso, proporcionando al mismo tiempo información sobre excepciones relativa a la terminación del subproceso. Normalmente, una llamada a este método finaliza el subproceso.

System_CAPS_pubmethodSystem_CAPS_staticAllocateDataSlot()

Asigna una ranura de datos sin nombre en todos los subprocesos. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

System_CAPS_pubmethodSystem_CAPS_staticAllocateNamedDataSlot(String)

Asigna una ranura de datos con nombre en todos los subprocesos. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

System_CAPS_pubmethodSystem_CAPS_staticBeginCriticalRegion()

Notifica a un host que la ejecución está a punto de entrar en una región del código donde los efectos de una anulación del subproceso o de una excepción no controlada podrían constituir un riesgo para otras tareas del dominio de aplicaciones.

System_CAPS_pubmethodSystem_CAPS_staticBeginThreadAffinity()

Notifica a un host que el código administrado está a punto de ejecutar instrucciones que dependen de la identidad del subproceso del sistema operativo físico actual.

System_CAPS_pubmethodDisableComObjectEagerCleanup()

Desactiva la limpieza automática de contenedores RCW (Runtime Callable Wrappers) para el subproceso actual.

System_CAPS_pubmethodSystem_CAPS_staticEndCriticalRegion()

Notifica a un host que la ejecución está a punto de entrar en una región de código donde los efectos de una anulación del subproceso o de una excepción no controlada se limitan a la tarea actual.

System_CAPS_pubmethodSystem_CAPS_staticEndThreadAffinity()

Notifica a un host que el código administrado ha terminado de ejecutar instrucciones que dependen de la identidad del subproceso del sistema operativo físico actual.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Se asegura de que los recursos se liberan y que se llevan a cabo otras operaciones de limpieza cuando el recolector de elementos no utilizados recupere el objeto Thread.(Invalida CriticalFinalizerObject.Finalize()).

System_CAPS_pubmethodSystem_CAPS_staticFreeNamedDataSlot(String)

Elimina la asociación entre un nombre y una ranura en todos los subprocesos del proceso. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

System_CAPS_pubmethodGetApartmentState()

Devuelve un valor ApartmentState que indica el estado del apartamento.

System_CAPS_pubmethodGetCompressedStack()

Obsoleto. Devuelve un objeto CompressedStack que se puede utilizar para capturar la pila correspondiente al subproceso actual.

System_CAPS_pubmethodSystem_CAPS_staticGetData(LocalDataStoreSlot)

Recupera el valor de la ranura especificada en el subproceso actual, dentro del dominio actual del subproceso. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

System_CAPS_pubmethodSystem_CAPS_staticGetDomain()

Devuelve el dominio en el que se está ejecutando el subproceso actual.

System_CAPS_pubmethodSystem_CAPS_staticGetDomainID()

Devuelve un identificador único del dominio de la aplicación.

System_CAPS_pubmethodGetHashCode()

Devuelve un código hash para el subproceso actual.(Invalida Object.GetHashCode()).

System_CAPS_pubmethodSystem_CAPS_staticGetNamedDataSlot(String)

Busca una ranura de datos con nombre. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodInterrupt()

Interrumpe un subproceso que se encuentra en estado de subproceso WaitSleepJoin.

System_CAPS_pubmethodJoin()

Bloquea el subproceso de llamada hasta que el subproceso representado por esta instancia finaliza, pero continúa bombeando SendMessage y COM estándar.

System_CAPS_pubmethodJoin(Int32)

Bloquea el subproceso de llamada hasta que el subproceso representado por esta instancia finaliza o transcurre el tiempo especificado, pero continúa bombeando SendMessage y COM estándar.

System_CAPS_pubmethodJoin(TimeSpan)

Bloquea el subproceso de llamada hasta que el subproceso representado por esta instancia finaliza o transcurre el tiempo especificado, pero continúa bombeando SendMessage y COM estándar.

System_CAPS_pubmethodSystem_CAPS_staticMemoryBarrier()

Sincroniza el acceso a la memoria de la siguiente forma: el procesador que ejecuta el subproceso actual no puede reordenar las instrucciones de forma que los accesos a la memoria anteriores a la llamada a MemoryBarrier se ejecuten después de los accesos a memoria que siguen a la llamada a MemoryBarrier.

System_CAPS_pubmethodSystem_CAPS_staticResetAbort()

Cancela un método Abort solicitado para el subproceso actual.

System_CAPS_pubmethodResume()

Obsoleto. Reanuda un subproceso que se ha suspendido.

System_CAPS_pubmethodSetApartmentState(ApartmentState)

Establece el estado del apartamento de un subproceso antes de iniciarse.

System_CAPS_pubmethodSetCompressedStack(CompressedStack)

Obsoleto. Aplica un objeto CompressedStack capturado al subproceso actual.

System_CAPS_pubmethodSystem_CAPS_staticSetData(LocalDataStoreSlot, Object)

Establece los datos de la ranura especificada en el subproceso actualmente en ejecución, para el dominio actual de dicho subproceso. Para obtener un mejor rendimiento, utilice en su lugar los campos marcados con el atributo ThreadStaticAttribute.

System_CAPS_pubmethodSystem_CAPS_staticSleep(Int32)

Suspende el subproceso actual durante el número de milisegundos especificado.

System_CAPS_pubmethodSystem_CAPS_staticSleep(TimeSpan)

Suspende el subproceso actual durante la cantidad de tiempo especificada.

System_CAPS_pubmethodSystem_CAPS_staticSpinWait(Int32)

Hace que un subproceso espere el número de veces definido por el parámetro iterations.

System_CAPS_pubmethodStart()

Hace que el sistema operativo cambie el estado de la instancia actual a ThreadState.Running.

System_CAPS_pubmethodStart(Object)

Hace que el sistema operativo cambie el estado de la instancia actual a ThreadState.Running; también puede proporcionar un objeto que contiene datos para que los use el método ejecutado por el subproceso.

System_CAPS_pubmethodSuspend()

Obsoleto. Suspende el subproceso o, si este ya se ha suspendido, no tiene efecto alguno.

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

System_CAPS_pubmethodTrySetApartmentState(ApartmentState)

Establece el estado del apartamento de un subproceso antes de iniciarse.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(Byte)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(Double)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(Int16)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(Int32)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(Int64)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(IntPtr)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(Object)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(SByte)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(Single)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(UInt16)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(UInt32)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(UInt64)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileRead(UIntPtr)

Lee el valor de un campo. El valor es el último que haya escrito cualquier procesador de un equipo, independientemente del número de procesadores y del estado de la caché del procesador.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(Byte, Byte)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(Double, Double)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(Int16, Int16)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(Int32, Int32)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(Int64, Int64)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(IntPtr, IntPtr)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(Object, Object)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(SByte, SByte)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(Single, Single)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(UInt16, UInt16)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(UInt32, UInt32)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(UInt64, UInt64)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticVolatileWrite(UIntPtr, UIntPtr)

Escribe inmediatamente un valor en un campo, de manera que el valor sea visible para todos los procesadores del equipo.

System_CAPS_pubmethodSystem_CAPS_staticYield()

Hace que el subproceso que realiza la llamada ceda la ejecución a otro subproceso que está listo para ejecutarse en el procesador actual. El sistema operativo selecciona el subproceso al que se va a ceder la ejecución.

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethod_Thread.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Thread.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz.

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Thread.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Thread.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.

When a process starts, the common language runtime automatically creates a single foreground thread to execute application code. Along with this main foreground thread, a process can create one or more threads to execute a portion of the program code associated with the process. These threads can execute either in the foreground or in the background. In addition, you can use the T:System.Threading.ThreadPool class to execute code on worker threads that are managed by the common language runtime.

In this section

Starting a thread
Retrieving Thread objects
Foreground and background threads
Culture and threads
Getting information about and controlling threads
Accessing the source code for the Thread class

You start a thread by supplying a delegate that represents the method the thread is to execute in its class constructor. You then call the M:System.Threading.Thread.Start method to begin execution.

The T:System.Threading.Thread constructors can take either of two delegate types, depending on whether you can pass an argument to the method to be executed:

  • If the method has no arguments, you pass a T:System.Threading.ThreadStart delegate to the constructor. It has the signature:

    public delegate void ThreadStart()
    

    The following example creates and starts a thread that executes the ExecuteInForeground method. The method displays information about some thread properties, then executes a loop in which it pauses for half a second and displays the elapsed number of seconds. When the thread has executed for at least five seconds, the loop ends and the thread terminates execution.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       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()
       {
          DateTime start = DateTime.Now;
          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 seconds
    
  • If the method has an argument, you pass a T:System.Threading.ParameterizedThreadStart delegate to the constructor. It has the signature:

    public delegate void ParameterizedThreadStart(object obj)
    

    The method executed by the delegate can then cast (in C#) or convert (in Visual Basic) the parameter to the appropriate type.

    The following example is identical to the previous one, except that it calls the M:System.Threading.Thread.#ctor(System.Threading.ParameterizedThreadStart) constructor. This version of the ExecuteInForeground method has a single parameter that represents the approximate number of milliseconds the loop is to execute.

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    public class Example
    {
       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;
          }
          DateTime start = DateTime.Now;
          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 seconds
    

It is not necessary to retain a reference to a T:System.Threading.Thread object once you have started the thread. The thread continues to execute until the thread procedure is complete.

You can use the static (Shared in Visual Basic) P:System.Threading.Thread.CurrentThread property to retrieve a reference to the currently executing thread from the code that the thread is executing. The following example uses the P:System.Threading.Thread.CurrentThread property to display information about the main application thread, another foreground thread, a background thread, and a thread pool thread.

using System;
using System.Threading;

public class Example
{
   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

Instances of the T:System.Threading.Thread class represent either foreground threads or background threads. Background threads are identical to foreground threads with one exception: a background thread does not keep a process running if all foreground threads have terminated. Once all foreground threads have been stopped, the runtime stops all background threads and shuts down.

By default, the following threads execute in the foreground:

  • The main application thread.

  • All threads created by calling a T:System.Threading.Thread class constructor.

The following threads execute in the background by default:

  • Thread pool threads, which are a pool of worker threads maintained by the runtime. You can configure the thread pool and schedule work on thread pool threads by using the T:System.Threading.ThreadPool class.

    System_CAPS_noteNota

    Task-based asynchronous operations automatically execute on thread pool threads. Task-based asynchronous operations use the T:System.Threading.Tasks.Task and T:System.Threading.Tasks.Task`1 classes to implement the task-based asynchronous pattern.

  • All threads that enter the managed execution environment from unmanaged code.

You can change a thread to execute in the background by setting the P:System.Threading.Thread.IsBackground property at any time. Background threads are useful for any operation that should continue as long as an application is running but should not prevent the application from terminating, such as monitoring file system changes or incoming socket connections.

The following example illustrates the difference between foreground and background threads. It is like the first example in the Starting a thread section, except that it sets the thread to execute in the background before starting it. As the output shows, the loop is interrupted before it executes for five seconds.

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()
   {
      DateTime start = DateTime.Now;
      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...

Each thread has a culture, represented by the P:System.Threading.Thread.CurrentCulture property, and a UI culture, represented by the P:System.Threading.Thread.CurrentUICulture property. The current culture supports such culture-sensitive operations as parsing and formatting, string comparison and sorting, and also controls the writing system and calendar used by a thread. The current UI culture provides for culture-sensitive retrieval of resources in resource files.

When a new thread is instantiated, its culture and UI culture are defined by the current system culture and UI culture, and not by the culture and UI culture of the thread from which the new thread is created. This means, for example, that if the current system culture is English (United States) and the current culture of the primary application thread is French (France), the culture of a new thread created by calling the M:System.Threading.Thread.#ctor(System.Threading.ParameterizedThreadStart) constructor from the primary thread is English (United States), and not French (France). For more information, see the "Culture and threads" section of the T:System.Globalization.CultureInfo class topic.

System_CAPS_importantImportante

This is not true of threads that execute asynchronous operations for apps that target the net_v46 and later versions, In this case, the culture and UI culture is part of an asynchronous operations' context; the thread on which an asynchronous operation executes by default inherits the culture and UI culture of the thread from which the asynchronous operation was launched. For more information, see the "Culture and task-based asynchronous operations" section of the T:System.Globalization.CultureInfo class topic.

You can do either of the following to ensure that all of the threads executing in an application share the same culture and UI culture:

  • You can pass a T:System.Globalization.CultureInfo object that represents that culture to the T:System.Threading.ParameterizedThreadStart delegate or the M:System.Threading.ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback,System.Object) method.

  • For apps running on the net_v45 and later versions, you can define the culture and UI culture that is to be assigned to all threads created in an application domain by setting the value of the P:System.Globalization.CultureInfo.DefaultThreadCurrentCulture and P:System.Globalization.CultureInfo.DefaultThreadCurrentUICulture properties. Note that this is a per-application domain setting.

For more information and examples, see the "Culture and threads" section of the T:System.Globalization.CultureInfo class topic.

You can retrieve a number of property values that provide information about a thread. In some cases, you can also set these property values to control the operation of the thread. These thread properties include:

  • A name. P:System.Threading.Thread.Name is a write-once property that you can use to identify a thread. Its default value is null.

  • A hash code, which you can retrieve by calling the M:System.Threading.Thread.GetHashCode method. The hash code can be used to uniquely identify a thread; for the lifetime of your thread, its hash code will not collide with the value from any other thread, regardless of the application domain from which you obtain the value.

  • A thread ID. The value of the read-only P:System.Threading.Thread.ManagedThreadId property is assigned by the runtime and uniquely identifies a thread within its process.

    System_CAPS_noteNota

    An operating-system ThreadIdhttps://msdn.microsoft.com/library/windows/desktop/ms683233.aspx has no fixed relationship to a managed thread, because an unmanaged host can control the relationship between managed and unmanaged threads. Specifically, a sophisticated host can use the CLR Hosting APIhttps://msdn.microsoft.com/library/ms404385.aspx to schedule many managed threads against the same operating system thread, or to move a managed thread between different operating system threads.

  • The thread's current state. For the duration of its existence, a thread is always in one or more of the states defined by the T:System.Threading.ThreadState property.

  • A scheduling priority level, which is defined by the T:System.Threading.ThreadPriority property. Although you can set this value to request a thread's priority, it is not guaranteed to be honored by the operating system.

  • The read-only P:System.Threading.Thread.IsThreadPoolThread property, which indicates whether a thread is a thread pool thread.

  • The P:System.Threading.Thread.IsBackground property. For more information, see the Foreground and background threads section.

To view the .NET Framework source code for the T:System.Threading.Thread class, see the Reference Sourcehttp://referencesource.microsoft.com/#mscorlib/system/threading/thread.cs#3980e012bae82e96. You can browse through the source code online, download the reference for offline viewing, and step through the sources (including patches and updates) during debugging; see instructionshttp://referencesource.microsoft.com/.

The following example demonstrates simple threading functionality.

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();
    }
}

This code produces output similar to the following:

[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.

.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0

This type is thread safe.

Volver al principio
Mostrar: