Bloggers declarar: Eu sou limitado nível da tecnologia, se não no lugar de escrever, mas também agradar ao apontar deus. spray de luz ...
1: Criar um fio
static void Main(string[] args)
{
#region 创建线程
Thread thread = new Thread(PrintNumbers);
thread.Start();
PrintNumbers();
Console.ReadKey();
#endregion
}
static void PrintNumbers()
{
Console.WriteLine("Starting...");
for(int i = 0;i<10;i++)
{
Console.WriteLine(i);
}
}
Os resultados (os resultados de cada ensaio não é o mesmo):
princípio:
Quando construímos um fio, instância ou comissão ParameterizedThreadStart ThreadStart será passado para o construtor, só precisamos de desenvolver um nome de método e, em seguida, executar diferentes threads, e C # compilador irá recriar esses objetos de volta. Então nós no segmento principal da maneira usual para iniciar uma discussão para executar método PrintNumbers.
2: fio Pausa
static void Main(string[] args)
{
#region 暂停线程
Thread thread = new Thread(PrintNumbersWithDelay);
thread.Start();
PrintNumbers();
Console.ReadKey();
#endregion
}
static void PrintNumbers()
{
Console.WriteLine("Starting...");
for(int i = 0;i<10;i++)
{
Console.WriteLine(i);
}
}
static void PrintNumbersWithDelay()
{
Console.WriteLine("WithDelayStarting...");
for (int i = 0; i < 10; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine(i);
}
}
Os resultados (não mostrados): totalmente
Como funciona:
PrintNumbersWithDelay chamada de método Thread.Sleep, dormente por dois segundos, fazendo com que o fio para executar o código, antes de qualquer impressão digital irá esperar por um período de tempo especificado. Quando um segmento está em um estado de sono, ele vai ocupar tão pouco tempo de CPU. Os resultados vamos encontrar o método PrintNumbers código de código do que o método PrintNumbersWithDelay irá separar rosca na primeira corrida.
3: thread espera
static void Main(string[] args)
{
#region 线程等待
Console.WriteLine("WithDelayStarting...");
Thread thread = new Thread(PrintNumbersWithDelay);
thread.Start();
thread.Join();
Console.WriteLine("Thread Completed...");
Console.ReadKey();
#endregion
}
static void PrintNumbersWithDelay()
{
Console.WriteLine("WithDelayStarting...");
for (int i = 0; i < 10; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine(i);
}
}
resultados:
Como funciona:
Quando o programa é executado, lançou uma linha longa para impressão digital, antes de imprimir cada número que esperar dois segundos após a chamada Thread.Join método, o que nos permite esperar até que a rosca para ser concluído. Quando o segmento é o segmento acabado, o segmento principal continuará a ser executado.
4: Rescisão Tópico
static void Main(string[] args)
{
#region 线程终止
Console.WriteLine("Starting Program....");
Thread thread = new Thread(PrintNumbersWithDelay);
thread.Start();
Thread.Sleep(TimeSpan.FromSeconds(6));
thread.Abort();
Console.WriteLine("A Thread has been aborted....");
Thread t = new Thread(PrintNumbers);
t.Start();
PrintNumbers();
Console.ReadKey();
#endregion
}
static void PrintNumbersWithDelay()
{
Console.WriteLine("WithDelayStarting...");
for (int i = 0; i < 10; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine(i);
}
}
static void PrintNumbers()
{
Console.WriteLine("Starting...");
for (int i = 0; i < 10; i++)
{
Console.WriteLine(i);
}
}
resultados:
Como funciona:
rotina principal e um fio separado que execute a impressão digital, a chamada em espera seis segundos Thread.Abort método, o que dá o fio um método de injecção ThreadAbortException, resultando na rosca é terminada. Este método não sempre encerrar o segmento, o segmento alvo pode processar a excepção e chamada Tread.ResetAbort maneira de se recusar a ser encerrado, e, portanto, não recomendamos esse método para fechar o segmento.
5: A prioridade do thread
class Program
{
static void Main(string[] args)
{
Console.WriteLine($"Current thread priority:{Thread.CurrentThread.Priority}");
//在所有可用的CPU上运行
Console.WriteLine("Running on all cores available");
RunThreads();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("Running on a single core");
//设置单核CPU运行
Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
RunThreads();
Console.ReadKey();
}
static void RunThreads()
{
var sample = new ThreadSample();
var threadOne = new Thread(sample.CountNumbers);
threadOne.Name = "ThreadOne";
var threadTwo = new Thread(sample.CountNumbers);
threadTwo.Name = "ThreadTwo";
threadOne.Priority = ThreadPriority.Highest;
threadTwo.Priority = ThreadPriority.Lowest;
threadOne.Start();
threadTwo.Start();
Thread.Sleep(TimeSpan.FromSeconds(2));
sample.Stop();
}
}
class ThreadSample
{
private bool _isStopped = false;
public void Stop()
{
_isStopped = true;
}
public void CountNumbers()
{
long counter = 0;
while(!_isStopped)
{
counter++;
}
Console.WriteLine("{0} with {1,11} priority " +
"has a count = {2,13} ",
Thread.CurrentThread.Name,
Thread.CurrentThread.Priority,
counter.ToString("N0"));
}
}
resultados:
princípio:
Definir dois tópicos, prioritários são os mais altos, mais baixo, quando começar a dois tópicos em todos os resultados de CPU disponíveis muito perto, mas quando configurado em uma única CPU, os resultados variam muito, porque a maioria do tempo, o núcleo da CPU no segmento de alta prioridade para correr, apenas para deixar o resto do fio é muito pouco tempo para ser executado.
6 tópicos passagem de parâmetro
class Program
{
static void Main(string[] args)
{
//构造
var sample = new ThreadSample(5);
var threadOne = new Thread(sample.CountNumbers);
threadOne.Name = "ThreadOne";
threadOne.Start();
threadOne.Join();
Console.WriteLine("-----------------------------");
//Thread.Start
var threadTwo = new Thread(Count);
threadTwo.Name = "ThreadTwo";
threadTwo.Start(5);
threadTwo.Join();
Console.WriteLine("-----------------------------");
//lambda
var threadThree = new Thread(() => CountNumbers(5));
threadThree.Name = "ThreadThree";
threadThree.Start();
threadThree.Join();
Console.WriteLine("-----------------------------");
int i = 10;
var threadFour = new Thread(() => PrintNumber(i));
i = 20;
var threadFive = new Thread(() => PrintNumber(i));
threadFour.Start();
threadFive.Start();
Console.ReadKey();
}
static void Count(object iterations)
{
CountNumbers((int)iterations);
}
static void CountNumbers(int iterations)
{
for(int i =1;i<iterations;i++)
{
Thread.Sleep(TimeSpan.FromSeconds(0.5));
Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
}
}
static void PrintNumber(int number)
{
Console.WriteLine(number);
}
}
class ThreadSample
{
private readonly int _iterations;
public ThreadSample(int iterations)
{
_iterations = iterations;
}
public void CountNumbers()
{
for (int i = 1; i < _iterations; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(0.5));
Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
}
}
}
resultados:
princípio:
- O primeiro: criar ThreadSample objeto e fornecer um parâmetro de construtor, em seguida, usar o método CountNumbers do objeto começar a rosca
- A segunda: Método de utilização Thread.Start deve aceitar um único parâmetro do tipo de objecto no processo de iniciar uma rosca
- Terceiro: uma expressão lambda, não pertence a qualquer classe dado um método para invocar outro método com parâmetros, este método é referido como rolha de encerramento, quando todas as variáveis locais em expressões lambda, C # gera uma classe, e a variável como uma propriedade da classe. Isso pode causar vários problemas, se você usar a mesma variável em uma expressão lambda eles compartilham os valores das variáveis. Ao iniciar threadFour e linha threadFive, a impressão é de 20.
