Thread Constructores

Referencia

Definición

Espacio de nombres:: System.Threading

Ensamblado:: System.Threading.Thread.dll

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

Inicializa una nueva instancia de la clase Thread.

Sobrecargas

Thread(ParameterizedThreadStart)	Inicializa una nueva instancia de la clase Thread, especificando un delegado que permite pasar un objeto al subproceso cuando este último se inicia.
Thread(ThreadStart)	Inicializa una nueva instancia de la clase Thread.
Thread(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.
Thread(ThreadStart, Int32)	Inicializa una nueva instancia de la clase Thread, especificando el tamaño de pila máximo para el subproceso.

Thread(ParameterizedThreadStart)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

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

public:
 Thread(System::Threading::ParameterizedThreadStart ^ start);

public Thread (System.Threading.ParameterizedThreadStart start);

new System.Threading.Thread : System.Threading.ParameterizedThreadStart -> System.Threading.Thread

Public Sub New (start As ParameterizedThreadStart)

Parámetros

start: ParameterizedThreadStart

Delegado que representa los métodos que deben invocarse cuando empieza a ejecutarse este subproceso.

Excepciones

ArgumentNullException

start es null.

Ejemplos

En el ejemplo siguiente se muestra la sintaxis para crear y usar un ParameterizedThreadStart delegado con un método estático y un método de instancia.

using namespace System;
using namespace System::Threading;

namespace SystemThreadingExample
{
    public ref class Work
    {
    public:
        void StartThreads()
        {
            // Start a thread that calls a parameterized static method.
            Thread^ newThread = gcnew
                Thread(gcnew ParameterizedThreadStart(Work::DoWork));
            newThread->Start(42);
              
            // Start a thread that calls a parameterized instance method.
            Work^ someWork = gcnew Work;
            newThread = gcnew Thread(
                        gcnew ParameterizedThreadStart(someWork,
                        &Work::DoMoreWork));
            newThread->Start("The answer.");
        }

        static void DoWork(Object^ data)
        {
            Console::WriteLine("Static thread procedure. Data='{0}'", 
                data);
        }

        void DoMoreWork(Object^ data)
        {
            Console::WriteLine("Instance thread procedure. Data='{0}'", 
                data);
        }
    };
}

//Entry point of example application
int main()
{
    SystemThreadingExample::Work^ samplework = 
        gcnew SystemThreadingExample::Work();
    samplework->StartThreads();
}
// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

using System;
using System.Threading;

public class Work
{
    public static void Main()
    {
        // Start a thread that calls a parameterized static method.
        Thread newThread = new Thread(Work.DoWork);
        newThread.Start(42);

        // Start a thread that calls a parameterized instance method.
        Work w = new Work();
        newThread = new Thread(w.DoMoreWork);
        newThread.Start("The answer.");
    }
 
    public static void DoWork(object data)
    {
        Console.WriteLine("Static thread procedure. Data='{0}'",
            data);
    }

    public void DoMoreWork(object data)
    {
        Console.WriteLine("Instance thread procedure. Data='{0}'",
            data);
    }
}
// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

open System.Threading

type Work() =
    static member DoWork(data: obj) =
        printfn $"Static thread procedure. Data='{data}'"

    member _.DoMoreWork(data: obj) =
        printfn $"Instance thread procedure. Data='{data}'"

// Start a thread that calls a parameterized static method.
let newThread = Thread(ParameterizedThreadStart Work.DoWork)
newThread.Start 42

// Start a thread that calls a parameterized instance method.
let w = Work()
let newThread2 = Thread(ParameterizedThreadStart w.DoMoreWork)
newThread.Start "The answer."

// This example displays output like the following:
//       Static thread procedure. Data='42'
//       Instance thread procedure. Data='The answer.'

Imports System.Threading

Public Class Work
    Shared Sub Main()
        ' Start a thread that calls a parameterized static method.
        Dim newThread As New Thread(AddressOf Work.DoWork)
        newThread.Start(42)

        ' Start a thread that calls a parameterized instance method.
        Dim w As New Work()
        newThread = New Thread(AddressOf w.DoMoreWork)
        newThread.Start("The answer.")
    End Sub
 
    Public Shared Sub DoWork(ByVal data As Object)
        Console.WriteLine("Static thread procedure. Data='{0}'",
                          data)
    End Sub

    Public Sub DoMoreWork(ByVal data As Object) 
        Console.WriteLine("Instance thread procedure. Data='{0}'",
                          data)
    End Sub
End Class
' This example displays output like the following:
'    Static thread procedure. Data='42'
'    Instance thread procedure. Data='The answer.'

Comentarios

Un subproceso no comienza a ejecutarse cuando se crea. Para programar el subproceso para su ejecución, llame al Start método . Para pasar un objeto de datos al subproceso, use la sobrecarga del Start(Object) método .

Nota:

Los usuarios de Visual Basic pueden omitir el ThreadStart constructor al crear un subproceso. Use el operador al pasar el AddressOf método, por ejemplo, Dim t As New Thread(AddressOf ThreadProc). Visual Basic llama automáticamente al ThreadStart constructor.

Consulte también

Se aplica a

Thread(ThreadStart)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

Inicializa una nueva instancia de la clase Thread.

public:
 Thread(System::Threading::ThreadStart ^ start);

public Thread (System.Threading.ThreadStart start);

new System.Threading.Thread : System.Threading.ThreadStart -> System.Threading.Thread

Public Sub New (start As ThreadStart)

Parámetros

start: ThreadStart

Delegado ThreadStart que representa los métodos que deben invocarse cuando empieza a ejecutarse este subproceso.

Excepciones

ArgumentNullException

El parámetro start es null.

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear un subproceso que ejecuta un método estático.

using namespace System;
using namespace System::Threading;
ref class Work
{
private:
   Work(){}


public:
   static void DoWork(){}

};

int main()
{
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( &Work::DoWork ) );
   newThread->Start();
}

using System;
using System.Threading;

class Test
{
    static void Main() 
    {
        Thread newThread = 
            new Thread(new ThreadStart(Work.DoWork));
        newThread.Start();
    }
}

class Work 
{
    Work() {}

    public static void DoWork() {}
}

open System.Threading

module Work =
    let doWork () = ()

let newThread = Thread(ThreadStart Work.doWork)
newThread.Start()

Imports System.Threading

Public Class Test
    <MTAThread> _
    Shared Sub Main()
        Dim newThread As New Thread(AddressOf Work.DoWork)
        newThread.Start()
    End Sub
End Class

Public Class Work 

    Private Sub New()
    End Sub

    Shared Sub DoWork()
    End Sub

End Class

En el ejemplo de código siguiente se muestra cómo crear un subproceso que ejecuta un método de instancia.

using namespace System;
using namespace System::Threading;
ref class Work
{
public:
   Work(){}

   void DoWork(){}

};

int main()
{
   Work^ threadWork = gcnew Work;
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( threadWork, &Work::DoWork ) );
   newThread->Start();
}

using System;
using System.Threading;

class Test
{
    static void Main() 
    {
        Work threadWork = new Work();
        Thread newThread = 
            new Thread(new ThreadStart(threadWork.DoWork));
        newThread.Start();
    }
}

class Work 
{
    public Work() {}

    public void DoWork() {}
}

open System.Threading

type Work() =
    member _.DoWork() = ()

let threadWork = Work()
let newThread = Thread(ThreadStart threadWork.DoWork)
newThread.Start()

Imports System.Threading

Public Class Test
    <MTAThread> _
    Shared Sub Main() 
        Dim threadWork As New Work()
        Dim newThread As New Thread(AddressOf threadWork.DoWork)
        newThread.Start()
    End Sub
End Class

Public Class Work

    Sub New()
    End Sub

    Sub DoWork() 
    End Sub

End Class

Comentarios

Un subproceso no comienza a ejecutarse cuando se crea. Para programar el subproceso para su ejecución, llame al Start método .

Nota

Consulte también

Se aplica a

Thread(ParameterizedThreadStart, Int32)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

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.

public:
 Thread(System::Threading::ParameterizedThreadStart ^ start, int maxStackSize);

public Thread (System.Threading.ParameterizedThreadStart start, int maxStackSize);

new System.Threading.Thread : System.Threading.ParameterizedThreadStart * int -> System.Threading.Thread

Public Sub New (start As ParameterizedThreadStart, maxStackSize As Integer)

Parámetros

start: ParameterizedThreadStart

Delegado ParameterizedThreadStart que representa los métodos que deben invocarse cuando empieza a ejecutarse este subproceso.

maxStackSize: Int32

Tamaño de pila máximo, en bytes, que va a usar el subproceso, o 0 para usar el tamaño de pila máximo predeterminado especificado en el encabezado del ejecutable.

Importante Para el código de confianza parcial, maxStackSize se omite si es mayor que el tamaño de pila predeterminado. No se inicia ninguna excepción.

Excepciones

ArgumentNullException

start es null.

ArgumentOutOfRangeException

maxStackSize es menor que cero.

Comentarios

Evite usar esta sobrecarga del constructor. El tamaño de pila predeterminado usado por la sobrecarga del Thread(ParameterizedThreadStart) constructor es el tamaño de pila recomendado para los subprocesos. Si un subproceso tiene problemas de memoria, la causa más probable es el error de programación, como la recursividad infinita.

Importante

A partir de .NET Framework 4, solo el código de plena confianza puede establecerse maxStackSize en un valor mayor que el tamaño de pila predeterminado (1 megabyte). Si se especifica un valor mayor para maxStackSize cuando el código se ejecuta con confianza parcial, maxStackSize se omite y se usa el tamaño de pila predeterminado. No se inicia ninguna excepción. El código en cualquier nivel de confianza puede establecerse maxStackSize en un valor menor que el tamaño de pila predeterminado.

Nota

Si va a desarrollar una biblioteca de plena confianza que usará el código de confianza parcial y necesita iniciar un subproceso que requiera una pila grande, debe declarar plena confianza antes de crear el subproceso o se usará el tamaño de pila predeterminado. No haga esto a menos que controle completamente el código que se ejecuta en el subproceso.

Nota

En las versiones de Microsoft Windows anteriores a Windows XP y Windows Server 2003, maxStackSize se omite y se usa el tamaño de pila especificado en el encabezado ejecutable.

Si especifica un tamaño de pila muy pequeño, es posible que tenga que deshabilitar el sondeo de desbordamiento de pila. Cuando la pila está muy contenida, el sondeo puede provocar un desbordamiento de pila. Para deshabilitar el sondeo de desbordamiento de pila, agregue lo siguiente al archivo de configuración de la aplicación en una aplicación de .NET Framework.

<configuration>
  <runtime>
    <disableStackOverflowProbing enabled="true"/>
  </runtime>
</configuration>

Se aplica a

Thread(ThreadStart, Int32)

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

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

public:
 Thread(System::Threading::ThreadStart ^ start, int maxStackSize);

public Thread (System.Threading.ThreadStart start, int maxStackSize);

new System.Threading.Thread : System.Threading.ThreadStart * int -> System.Threading.Thread

Public Sub New (start As ThreadStart, maxStackSize As Integer)

Parámetros

start: ThreadStart

Delegado ThreadStart que representa los métodos que deben invocarse cuando empieza a ejecutarse este subproceso.

maxStackSize: Int32

Tamaño de pila máximo, en bytes, que va a usar el subproceso, o 0 para usar el tamaño de pila máximo predeterminado especificado en el encabezado del ejecutable.

Importante Para el código de confianza parcial, maxStackSize se omite si es mayor que el tamaño de pila predeterminado. No se inicia ninguna excepción.

Excepciones

ArgumentNullException

start es null.

ArgumentOutOfRangeException

maxStackSize es menor que cero.

Comentarios

Evite usar esta sobrecarga del constructor. El tamaño de pila predeterminado usado por la sobrecarga del Thread(ThreadStart) constructor es el tamaño de pila recomendado para los subprocesos. Si un subproceso tiene problemas de memoria, la causa más probable es el error de programación, como la recursividad infinita.

Importante

Nota

Si maxStackSize es menor que el tamaño mínimo de la pila, se usa el tamaño mínimo de la pila. Si maxStackSize no es un múltiplo del tamaño de página, se redondea al siguiente múltiplo mayor del tamaño de página. Por ejemplo, si usa la versión 2.0 de .NET Framework en Windows Vista, 256 KB (262 144 bytes) es el tamaño mínimo de la pila y el tamaño de página es de 64 KB (65 536 bytes).

Nota

En las versiones de Microsoft Windows anteriores a Windows XP y Windows Server 2003, maxStackSize se omite y se usa el tamaño de pila especificado en el encabezado ejecutable.

<configuration>
  <runtime>
    <disableStackOverflowProbing enabled="true"/>
  </runtime>
</configuration>

Se aplica a

Compartir vía

Thread Constructores

Definición

Sobrecargas

Thread(ParameterizedThreadStart)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Thread(ThreadStart)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Thread(ParameterizedThreadStart, Int32)

Parámetros

Excepciones

Comentarios

Se aplica a

Thread(ThreadStart, Int32)

Parámetros

Excepciones

Comentarios

Se aplica a

Recursos adicionales