Criando segmentos e passando dados na hora de início
Quando um processo do sistema operacional é criado, o sistema operacional injeta um segmento para executar o código nesse processo, incluindo qualquer domínio de aplicativo original. A partir desse momento, os domínios de aplicativo podem ser criados e destruídos sem nenhum thread do sistema operacional necessariamente o que está sendo criado ou destruído. Se o código que está sendo executado é gerenciado código, e em seguida, um Thread o objeto para o segmento em execução no domínio do aplicativo atual pode ser obtido Recuperando estática CurrentThread propriedade do tipo Thread. Este tópico descreve a criação de segmento e discute alternativas para passar dados para o procedimento de segmento.
Criar um segmento.
Criar uma nova Thread objeto cria um novo thread gerenciado. O Thread classe tem construtores levam uma ThreadStart delegar ou um ParameterizedThreadStart delegar; o delegado envolve o método que é invocado pelo novo thread quando você chamar o Start método. Chamando Start mais de uma vez, faz com que uma ThreadStateException ser acionada.
O Start método retorna imediatamente, muitas vezes antes do novo thread realmente começou. Você pode usar o ThreadState e IsAlive Propriedades para determinar o estado do segmento em um dado momento, mas essas propriedades nunca devem ser usado para sincronizar as atividades de threads.
Observação
Quando um thread for iniciado, não é necessário manter uma referência para o Thread objeto.O segmento continua a executar até que o procedimento de segmento termina.
O exemplo de código a seguir cria dois novos segmentos de chamada de instância e métodos estáticos em outro objeto.
Imports System
Imports System.Threading
Public class ServerClass
' The method that will be called when the thread is started.
Public Sub InstanceMethod()
Console.WriteLine(
"ServerClass.InstanceMethod is running on another thread.")
' Pause for a moment to provide a delay to make
' threads more apparent.
Thread.Sleep(3000)
Console.WriteLine(
"The instance method called by the worker thread has ended.")
End Sub
Public Shared Sub SharedMethod()
Console.WriteLine(
"ServerClass.SharedMethod is running on another thread.")
' Pause for a moment to provide a delay to make
' threads more apparent.
Thread.Sleep(5000)
Console.WriteLine(
"The Shared method called by the worker thread has ended.")
End Sub
End Class
Public class Simple
Public Shared Sub Main()
Console.WriteLine("Thread Simple Sample")
Dim serverObject As New ServerClass()
' Create the thread object, passing in the
' serverObject.InstanceMethod method using a
' ThreadStart delegate.
Dim InstanceCaller As New Thread( _
New ThreadStart(AddressOf serverObject.InstanceMethod))
' Start the thread.
InstanceCaller.Start()
Console.WriteLine("The Main() thread calls this after " _
+ "starting the new InstanceCaller thread.")
' Create the thread object, passing in the
' serverObject.SharedMethod method using a
' ThreadStart delegate.
Dim SharedCaller As New Thread( _
New ThreadStart(AddressOf ServerClass.SharedMethod))
' Start the thread.
SharedCaller.Start()
Console.WriteLine("The Main() thread calls this after " _
+ "starting the new SharedCaller thread.")
End Sub
End Class
using System;
using System.Threading;
public class ServerClass
{
// The method that will be called when the thread is started.
public void InstanceMethod()
{
Console.WriteLine(
"ServerClass.InstanceMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread.Sleep(3000);
Console.WriteLine(
"The instance method called by the worker thread has ended.");
}
public static void StaticMethod()
{
Console.WriteLine(
"ServerClass.StaticMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread.Sleep(5000);
Console.WriteLine(
"The static method called by the worker thread has ended.");
}
}
public class Simple
{
public static void Main()
{
Console.WriteLine("Thread Simple Sample");
ServerClass serverObject = new ServerClass();
// Create the thread object, passing in the
// serverObject.InstanceMethod method using a
// ThreadStart delegate.
Thread InstanceCaller = new Thread(
new ThreadStart(serverObject.InstanceMethod));
// Start the thread.
InstanceCaller.Start();
Console.WriteLine("The Main() thread calls this after "
+ "starting the new InstanceCaller thread.");
// Create the thread object, passing in the
// serverObject.StaticMethod method using a
// ThreadStart delegate.
Thread StaticCaller = new Thread(
new ThreadStart(ServerClass.StaticMethod));
// Start the thread.
StaticCaller.Start();
Console.WriteLine("The Main() thread calls this after "
+ "starting the new StaticCaller thread.");
}
}
using namespace System;
using namespace System::Threading;
public ref class ServerClass
{
public:
// The method that will be called when the thread is started.
void InstanceMethod()
{
Console::WriteLine(
"ServerClass.InstanceMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread::Sleep(3000);
Console::WriteLine(
"The instance method called by the worker thread has ended.");
}
static void StaticMethod()
{
Console::WriteLine(
"ServerClass.StaticMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread::Sleep(5000);
Console::WriteLine(
"The static method called by the worker thread has ended.");
}
};
public ref class Simple
{
public:
static void Main()
{
Console::WriteLine("Thread Simple Sample");
ServerClass^ serverObject = gcnew ServerClass();
// Create the thread object, passing in the
// serverObject.InstanceMethod method using a
// ThreadStart delegate.
Thread^ InstanceCaller = gcnew Thread(
gcnew ThreadStart(serverObject, &ServerClass::InstanceMethod));
// Start the thread.
InstanceCaller->Start();
Console::WriteLine("The Main() thread calls this after "
+ "starting the new InstanceCaller thread.");
// Create the thread object, passing in the
// serverObject.StaticMethod method using a
// ThreadStart delegate.
Thread^ StaticCaller = gcnew Thread(
gcnew ThreadStart(&ServerClass::StaticMethod));
// Start the thread.
StaticCaller->Start();
Console::WriteLine("The Main() thread calls this after "
+ "starting the new StaticCaller thread.");
}
};
int main()
{
Simple::Main();
}
Passagem de dados para Threads e recuperando dados de Threads
No.NET Framework versão 2.0, o ParameterizedThreadStart representante fornece uma maneira fácil de passar um objeto que contém os dados a um thread quando você chamar o Thread.Start sobrecarga do método. Consulte ParameterizedThreadStart para um exemplo de código.
Usando o ParameterizedThreadStart delegate não é uma maneira de tipo seguro para transmitir dados, porque o Thread.Start a sobrecarga de método aceita qualquer objeto. Uma alternativa é encapsular o procedimento de segmento e os dados em uma classe auxiliar e usar o ThreadStart Delegar para executar o procedimento de segmento. Essa técnica é mostrada nos exemplos de código de dois, o que se seguem.
Nenhum desses representantes tem um valor de retorno, porque não há nenhum lugar para retornar os dados a partir de uma chamada assíncrona. Para recuperar os resultados de um método de thread, você pode usar um método de retorno de chamada, conforme demonstrado no segundo exemplo de código.
Imports System
Imports System.Threading
' The ThreadWithState class contains the information needed for
' a task, and the method that executes the task.
'
Public Class ThreadWithState
' State information used in the task.
Private boilerplate As String
Private value As Integer
' The constructor obtains the state information.
Public Sub New(text As String, number As Integer)
boilerplate = text
value = number
End Sub
' The thread procedure performs the task, such as formatting
' and printing a document.
Public Sub ThreadProc()
Console.WriteLine(boilerplate, value)
End Sub
End Class
' Entry point for the example.
'
Public Class Example
Public Shared Sub Main()
' Supply the state information required by the task.
Dim tws As New ThreadWithState( _
"This report displays the number {0End.", 42)
' Create a thread to execute the task, and then
' start the thread.
Dim t As New Thread(New ThreadStart(AddressOf tws.ThreadProc))
t.Start()
Console.WriteLine("Main thread does some work, then waits.")
t.Join()
Console.WriteLine( _
"Independent task has completed main thread ends.")
End Sub
End Class
using System;
using System.Threading;
// The ThreadWithState class contains the information needed for
// a task, and the method that executes the task.
//
public class ThreadWithState
{
// State information used in the task.
private string boilerplate;
private int value;
// The constructor obtains the state information.
public ThreadWithState(string text, int number)
{
boilerplate = text;
value = number;
}
// The thread procedure performs the task, such as formatting
// and printing a document.
public void ThreadProc()
{
Console.WriteLine(boilerplate, value);
}
}
// Entry point for the example.
//
public class Example
{
public static void Main()
{
// Supply the state information required by the task.
ThreadWithState tws = new ThreadWithState(
"This report displays the number {0}.", 42);
// Create a thread to execute the task, and then
// start the thread.
Thread t = new Thread(new ThreadStart(tws.ThreadProc));
t.Start();
Console.WriteLine("Main thread does some work, then waits.");
t.Join();
Console.WriteLine(
"Independent task has completed; main thread ends.");
}
}
using namespace System;
using namespace System::Threading;
// The ThreadWithState class contains the information needed for
// a task, and the method that executes the task.
//
public ref class ThreadWithState
{
private:
// State information used in the task.
String^ boilerplate;
int value;
// The constructor obtains the state information.
public:
ThreadWithState(String^ text, int number)
{
boilerplate = text;
value = number;
}
// The thread procedure performs the task, such as formatting
// and printing a document.
void ThreadProc()
{
Console::WriteLine(boilerplate, value);
}
};
// Entry point for the example.
//
public ref class Example
{
public:
static void Main()
{
// Supply the state information required by the task.
ThreadWithState^ tws = gcnew ThreadWithState(
"This report displays the number {0}.", 42);
// Create a thread to execute the task, and then
// start the thread.
Thread^ t = gcnew Thread(gcnew ThreadStart(tws, &ThreadWithState::ThreadProc));
t->Start();
Console::WriteLine("Main thread does some work, then waits.");
t->Join();
Console::WriteLine(
"Independent task has completed; main thread ends.");
}
};
int main()
{
Example::Main();
}
Recuperar dados com os métodos de retorno de chamada
O exemplo a seguir demonstra um método de retorno de chamada que recupera dados de um thread. O construtor da classe que contém os dados e o método de thread também aceita um delegado que representa o método de retorno de chamada; antes do método de thread termina, ele invoca o delegado de retorno de chamada.
Imports System
Imports System.Threading
' The ThreadWithState class contains the information needed for
' a task, the method that executes the task, and a delegate
' to call when the task is complete.
'
Public Class ThreadWithState
' State information used in the task.
Private boilerplate As String
Private value As Integer
' Delegate used to execute the callback method when the
' task is complete.
Private callback As ExampleCallback
' The constructor obtains the state information and the
' callback delegate.
Public Sub New(text As String, number As Integer, _
callbackDelegate As ExampleCallback)
boilerplate = text
value = number
callback = callbackDelegate
End Sub
' The thread procedure performs the task, such as
' formatting and printing a document, and then invokes
' the callback delegate with the number of lines printed.
Public Sub ThreadProc()
Console.WriteLine(boilerplate, value)
If Not (callback Is Nothing) Then
callback(1)
End If
End Sub
End Class
' Delegate that defines the signature for the callback method.
'
Public Delegate Sub ExampleCallback(lineCount As Integer)
' Entry point for the example.
'
Public Class Example
Public Shared Sub Main()
' Supply the state information required by the task.
Dim tws As New ThreadWithState( _
"This report displays the number {0}.", _
42, _
New ExampleCallback(AddressOf ResultCallback) _
)
Dim t As New Thread(New ThreadStart(AddressOF tws.ThreadProc))
t.Start()
Console.WriteLine("Main thread does some work, then waits.")
t.Join()
Console.WriteLine( _
"Independent task has completed; main thread ends.")
End Sub
' The callback method must match the signature of the
' callback delegate.
'
Public Shared Sub ResultCallback(lineCount As Integer)
Console.WriteLine( _
"Independent task printed {0} lines.", lineCount)
End Sub
End Class
using System;
using System.Threading;
// The ThreadWithState class contains the information needed for
// a task, the method that executes the task, and a delegate
// to call when the task is complete.
//
public class ThreadWithState
{
// State information used in the task.
private string boilerplate;
private int value;
// Delegate used to execute the callback method when the
// task is complete.
private ExampleCallback callback;
// The constructor obtains the state information and the
// callback delegate.
public ThreadWithState(string text, int number,
ExampleCallback callbackDelegate)
{
boilerplate = text;
value = number;
callback = callbackDelegate;
}
// The thread procedure performs the task, such as
// formatting and printing a document, and then invokes
// the callback delegate with the number of lines printed.
public void ThreadProc()
{
Console.WriteLine(boilerplate, value);
if (callback != null)
callback(1);
}
}
// Delegate that defines the signature for the callback method.
//
public delegate void ExampleCallback(int lineCount);
// Entry point for the example.
//
public class Example
{
public static void Main()
{
// Supply the state information required by the task.
ThreadWithState tws = new ThreadWithState(
"This report displays the number {0}.",
42,
new ExampleCallback(ResultCallback)
);
Thread t = new Thread(new ThreadStart(tws.ThreadProc));
t.Start();
Console.WriteLine("Main thread does some work, then waits.");
t.Join();
Console.WriteLine(
"Independent task has completed; main thread ends.");
}
// The callback method must match the signature of the
// callback delegate.
//
public static void ResultCallback(int lineCount)
{
Console.WriteLine(
"Independent task printed {0} lines.", lineCount);
}
}
using namespace System;
using namespace System::Threading;
// Delegate that defines the signature for the callback method.
//
public delegate void ExampleCallback(int lineCount);
// The ThreadWithState class contains the information needed for
// a task, the method that executes the task, and a delegate
// to call when the task is complete.
//
public ref class ThreadWithState
{
private:
// State information used in the task.
String^ boilerplate;
int value;
// Delegate used to execute the callback method when the
// task is complete.
ExampleCallback^ callback;
public:
// The constructor obtains the state information and the
// callback delegate.
ThreadWithState(String^ text, int number,
ExampleCallback^ callbackDelegate)
{
boilerplate = text;
value = number;
callback = callbackDelegate;
}
// The thread procedure performs the task, such as
// formatting and printing a document, and then invokes
// the callback delegate with the number of lines printed.
void ThreadProc()
{
Console::WriteLine(boilerplate, value);
if (callback != nullptr)
{
callback(1);
}
}
};
// Entry point for the example.
//
public ref class Example
{
public:
static void Main()
{
// Supply the state information required by the task.
ThreadWithState^ tws = gcnew ThreadWithState(
"This report displays the number {0}.",
42,
gcnew ExampleCallback(&Example::ResultCallback)
);
Thread^ t = gcnew Thread(gcnew ThreadStart(tws, &ThreadWithState::ThreadProc));
t->Start();
Console::WriteLine("Main thread does some work, then waits.");
t->Join();
Console::WriteLine(
"Independent task has completed; main thread ends.");
}
// The callback method must match the signature of the
// callback delegate.
//
static void ResultCallback(int lineCount)
{
Console::WriteLine(
"Independent task printed {0} lines.", lineCount);
}
};
int main()
{
Example::Main();
}