C # multithreading
Da linha é definida como o caminho de execução do programa.Cada segmento define um fluxo único de controle. Se sua aplicação envolve operação complexa e demorada, definir diferentes caminhos de execução é muitas vezes rosca útil, cada thread executa um trabalho específico.
Threads sãoprocessos leves.Um exemplo comum é a utilização de fios em paralelo de programação de aplicação moderno sistema operativo. Use tópicos economizando ciclos de CPU resíduos, melhorando a eficiência da aplicação.
Até agora, temos preparado um programa é um processo único para ser executado como uma instância de aplicativo single-threaded está em execução. No entanto, com uma tal aplicação só pode executar uma tarefa ao mesmo tempo. A fim de executar várias tarefas ao mesmo tempo, que pode ser dividido em rosca menor.
Ciclo fio da vida
ciclo de vida rosca começa classe System.Threading.Thread objeto é criado, o fim é encerrada ou concluída no segmento de execução.
A seguir lista o status do ciclo de vida de rosca:
- O estado não arranca: Quando uma instância de discussão é criada, mas o método não é chamado condição Iniciar.
- estado Pronto: pronto para ser executado quando o segmento está esperando por ciclos e condições de CPU.
- estado não-operacional: As seguintes situações não são executados sob o tópico:
- O método tem sido chamado sono
- O método tem sido chamado Espera
- Por obstrução operações de I / O
- Death Estado: Quando o segmento tem execução concluída ou o estado abortado quando.
thread principal
Em C#, classe System.Threading.Thread para o trabalho de discussão.Ele permite que você criar e acessar um aplicativo com vários segmentos em um único segmento. O primeiro segmento no processo a ser executadoé chamado o segmento principal.
Quando um programa C # começa a execução, o segmento principal é criado automaticamente. Use a classeThread para criar uma lista de discussão é chamado o segmento principal segmento de criança.Você pode usar a classe Thread propriedadeCurrentThread fio de acesso.
O programa a seguir demonstra a execução do thread principal:
using System; using System.Threading; namespace MultithreadingApplication { classe MainThreadProgram { static void Main (string [] args) { Tópico th = Thread.currentThread; th.Name = "MainThread"; Console.WriteLine ( "Este é {0}", th.Name); Console.ReadKey (); } } }
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Este é MainThread
classe Thread atributos e métodos comuns
A tabela a seguir lista a classeThread alguns atributos comuns:
属性 | 描述 |
---|---|
CurrentContext | 获取线程正在其中执行的当前上下文。 |
CurrentCulture | 获取或设置当前线程的区域性。 |
CurrentPrinciple | 获取或设置线程的当前负责人(对基于角色的安全性而言)。 |
CurrentThread | 获取当前正在运行的线程。 |
CurrentUICulture | 获取或设置资源管理器使用的当前区域性以便在运行时查找区域性特定的资源。 |
ExecutionContext | 获取一个 ExecutionContext 对象,该对象包含有关当前线程的各种上下文的信息。 |
IsAlive | 获取一个值,该值指示当前线程的执行状态。 |
IsBackground | 获取或设置一个值,该值指示某个线程是否为后台线程。 |
IsThreadPoolThread | 获取一个值,该值指示线程是否属于托管线程池。 |
ManagedThreadId | 获取当前托管线程的唯一标识符。 |
Name | 获取或设置线程的名称。 |
Priority | 获取或设置一个值,该值指示线程的调度优先级。 |
ThreadState | 获取一个值,该值包含当前线程的状态。 |
A tabela a seguir lista a classeThread alguns métodoscomumenteutilizados:
序号 | 方法名 & 描述 |
---|---|
1 | public void Abort() 在调用此方法的线程上引发 ThreadAbortException,以开始终止此线程的过程。调用此方法通常会终止线程。 |
2 | public static LocalDataStoreSlot AllocateDataSlot() 在所有的线程上分配未命名的数据槽。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。 |
3 | public static LocalDataStoreSlot AllocateNamedDataSlot(
string name)
在所有线程上分配已命名的数据槽。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。 |
4 | public static void BeginCriticalRegion() 通知主机执行将要进入一个代码区域,在该代码区域内线程中止或未经处理的异常的影响可能会危害应用程序域中的其他任务。 |
5 | public static void BeginThreadAffinity() 通知主机托管代码将要执行依赖于当前物理操作系统线程的标识的指令。 |
6 | public static void EndCriticalRegion() 通知主机执行将要进入一个代码区域,在该代码区域内线程中止或未经处理的异常仅影响当前任务。 |
7 | public static void EndThreadAffinity() 通知主机托管代码已执行完依赖于当前物理操作系统线程的标识的指令。 |
8 | public static void FreeNamedDataSlot(string name) 为进程中的所有线程消除名称与槽之间的关联。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。 |
9 | public static Object GetData(
LocalDataStoreSlot slot
)
在当前线程的当前域中从当前线程上指定的槽中检索值。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。 |
10 | public static AppDomain GetDomain() 返回当前线程正在其中运行的当前域。 |
11 | public static AppDomain GetDomainID() 返回唯一的应用程序域标识符。 |
12 | public static LocalDataStoreSlot GetNamedDataSlot(
string name
)
查找已命名的数据槽。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。 |
13 | public void Interrupt() 中断处于 WaitSleepJoin 线程状态的线程。 |
14 | public void Join() 在继续执行标准的 COM 和 SendMessage 消息泵处理期间,阻塞调用线程,直到某个线程终止为止。此方法有不同的重载形式。 |
15 | public static void MemoryBarrier() 按如下方式同步内存存取:执行当前线程的处理器在对指令重新排序时,不能采用先执行 MemoryBarrier 调用之后的内存存取,再执行 MemoryBarrier 调用之前的内存存取的方式。 |
16 | public static void ResetAbort() 取消为当前线程请求的 Abort。 |
17 | public static void SetData(
LocalDataStoreSlot slot,
Object data
)
在当前正在运行的线程上为此线程的当前域在指定槽中设置数据。为了获得更好的性能,请改用以 ThreadStaticAttribute 属性标记的字段。 |
18 | public void Start() 开始一个线程。 |
19 | public static void Sleep(
int millisecondsTimeout
)
让线程暂停一段时间。 |
20 | public static void SpinWait(
int iterations
)
导致线程等待由 iterations 参数定义的时间量。 |
21 | public static byte VolatileRead(
ref byte address
) public static double VolatileRead( ref double address ) public static int VolatileRead( ref int address ) public static Object VolatileRead( ref Object address ) 读取字段值。无论处理器的数目或处理器缓存的状态如何,该值都是由计算机的任何处理器写入的最新值。此方法有不同的重载形式。这里只给出了一些形式。 |
22 | public static void VolatileWrite(
ref byte address,
byte value
) public static void VolatileWrite( ref double address, double value ) public static void VolatileWrite( ref int address, int value ) public static void VolatileWrite( ref Object address, Object value ) 立即向字段写入一个值,以使该值对计算机中的所有处理器都可见。此方法有不同的重载形式。这里只给出了一些形式。 |
23 | public static bool Yield() 导致调用线程执行准备好在当前处理器上运行的另一个线程。由操作系统选择要执行的线程。 |
Criar um fio
Um segmento é criado estendendo a classe Thread. Executivo classe Thread estendido chama o métodoStart () para iniciar a criança threads.
O programa a seguir ilustra esse conceito:
using System; using System.Threading; namespace MultithreadingApplication { classe ThreadCreationProgram { CallToChildThread public static void () { Console.WriteLine ( "passos de rosca para crianças"); } static void Main (string [] args) { ThreadStart childref = new ThreadStart (CallToChildThread); Console.WriteLine ( "In principal: a criação de threads Criança"); Passe childThread = new Thread (childref); childThread.Start (); Console.ReadKey (); } } }
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Na principal: Criando o segmento de criança passos de rosca criança
Gerenciando Tópico
classe Thread fio fornece uma variedade de métodos de gestão.
O exemplo seguinte demonstra a utilização do métododo sono (o) é utilizado em um segmento de tempo limite específico.
using System; using System.Threading; namespace MultithreadingApplication { classe ThreadCreationProgram { CallToChildThread public static void () { Console.WriteLine ( "passos de rosca para crianças"); // Tópico está suspensa a 5000 milissegundos int sleepfor = 5000; Console.WriteLine ( "Thread Criança parou por {0} segundos", sleepfor / 1000); Thread.Sleep (sleepfor); Console.WriteLine ( "thread Criança retoma"); } static void Main (string [] args) { ThreadStart childref = new ThreadStart (CallToChildThread); Console.WriteLine ( "In principal: a criação de threads Criança"); Passe childThread = new Thread (childref); childThread.Start (); Console.ReadKey (); } } }
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Na principal: Criando o segmento de criança passos de rosca criança Tópico criança parou por 5 segundos currículos segmento de criança
destrói threads
Abort () método é usado para destruir threads.
JogandoThreadAbortException abortar threads em tempo de execução.Esta excepção não pode ser capturado, sefinalmentebloquear, o controle seráenviado, finalmentebloco.
O programa a seguir ilustra esse ponto:
using System; using System.Threading; namespace MultithreadingApplication { classe ThreadCreationProgram { CallToChildThread public static void () { tentar { Console.WriteLine ( "passos de rosca para crianças"); // Conte até 10 for (int contador = 0; counter <= 10; contador ++) { Thread.Sleep (500); Console.WriteLine (contador); } Console.WriteLine ( "Thread Criança Concluído"); } catch (ThreadAbortException e) { Console.WriteLine ( "Thread Abort Exception"); } finalmente { Console.WriteLine ( "Não foi possível capturar a exceção da linha"); } } static void Main (string [] args) { ThreadStart childref = new ThreadStart (CallToChildThread); Console.WriteLine ( "In principal: a criação de threads Criança"); Passe childThread = new Thread (childref); childThread.Start (); // Pare o thread principal por algum tempo Thread.Sleep (2000); // Agora suspensa Console.WriteLine segmento infantil ( "In principal: Abortar o segmento Criança"); childThread.Abort (); Console.ReadKey (); } } }
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Na principal: Criando o segmento de criança passos de rosca criança 0 1 2 Na principal: Abortar o segmento Criança Passe Abort Exception Não foi possível capturar a exceção Tópico