Apesar de as linhas de execução em C# serem levemente baseadas nas de Java,

existem diferenças significativas.

Em vez de apenas métodos chamados run, como em Java, qualquer método

C# pode rodar em sua própria linha de execução. Uma linha de execução
C# é criada por meio de um objeto Thread. Ao construtor Thread deve ser
enviada uma instanciação de uma classe representante (delegate) pré-definida,
ThreadStart7, para a qual deve ser enviado o método que implementa as
ações da linha de execução.

Como em Java, criar uma linha de execução não inicia sua execução concorrente. Mais uma
vez, a execução deve ser solicitada por meio de um método, nesse caso chamado Start,

Como em Java, pode-se fazer uma linha de execução esperar pelo término da execução de
outra linha de execução antes de continuar, usando o
método similarmente chamado de Join.

Uma linha de execução pode ser suspendida por uma quantidade de tempo específica usando
Sleep, um método estático público de Thread. Diferentemente
do respectivo método similar em Java, o Sleep de C# não lança nenhuma
exceção, por isso não precisa ser chamado em um bloco try.

Uma linha de execução pode ser terminada com o método Abort, apesar de ele não matar a
linha de execução. Em vez disso, ele lança a exceção
ThreadAbortException, que a linha de execução pode capturar. Quando
a linha de execução captura essa exceção, ela normalmente libera qualquer
recurso alocado, e então termina

13.8.2 Sincronizando linhas de execução

Existem três maneiras pelas quais as linhas de execução em C# podem ser sincronizadas: pela
classe Interlock, pela sentença lock ou pela classe Monitor.
Cada um desses mecanismos é projetado para uma necessidade específica. A
classe Interlock é usada quando as únicas operações que precisam ser sincronizadas são o
incremento e o decremento de um inteiro. Essas operações
são feitas atomicamente com os dois métodos de Interlock, Increment e
Decrement, os quais recebem uma referência a um inteiro como parâmetro.

A sentença lock é usada para marcar uma seção crítica de código em

uma linha de execução.

A classe Monitor define cinco métodos, Enter, Wait, Pulse, PulseAll

e Exit, que podem ser usados para fornecer uma sincronização mais sofisticada de linhas de
execução. O método Enter, que recebe uma referência a
um objeto como seu parâmetro, marca o início da sincronização da linha de
execução desse objeto. O método Wait suspende a execução da linha e instrui
a Linguagem Comum de Tempo de Execução (CLR – Common Language
Runtime) do .NET que ela quer continuar sua execução na próxima vez em
que existir uma oportunidade. O método Pulse, que também recebe uma referência a um
objeto como seu parâmetro, notifica uma linha de execução em espera que agora tem uma
chance de rodar novamente. PulseAll é similar ao
notifyAll de Java. Linhas de execução que estavam esperando são executadas na ordem em
que chamaram o método Wait. O método Exit termina a
seção crítica da linha de execução.

13.9 CONCORRÊNCIA NO NÍVEL DE SENTENÇA

Do ponto de vista de projeto de linguagem, o

objetivo é fornecer um mecanismo para que o programador possa informar
o compilador de maneiras pelas quais ele possa mapear o programa em uma
arquitetura multiprocessada.

é discutida apenas uma coleção de construções linguísticas de uma linguagem para

concorrência no nível de sentença. Essas construções e seus objetivos serão descritos em
termos da arquitetura de máquinas SIMD, apesar de as construções terem sido projetadas
para serem úteis a uma variedade de configurações arquiteturais.

O problema tratado pelas construções de linguagens discutidas é o de

minimizar a comunicação requerida entre processadores e as memórias de outros
processadores. A premissa é ser mais rápido para um processador acessar
dados em sua própria memória do que de outro processador.

13.9.1 Fortran de alto desempenho

O Fortran de Alto Desempenho (HPF – High-Performance Fortran) (HPF;

ACM, 1993b) é uma coleção de extensões ao Fortran 90 feitas para permitir
que os programadores especifiquem informações ao compilador para ajudá-lo a
otimizar a execução de programas em computadores multiprocessados. O HPF inclui tanto
novas sentenças de especificação quanto subprogramas intrínsecos, pré-definidos.

As principais sentenças de especificação do HPF são para especificar o

número de processadores, a distribuição dos dados nas memórias desses processadores e o
alinhamento dos dados com outros em termos de localização
de memória.