Plano de fundo
O seguinte trecho de código foi retirado de um problema em Visual C # 2005: Como programar, por Paul e Harvey Deitel (pp. 735). O snippet de código é mais ou menos um aplicativo para acessar dados usando 2 threads por meio de um buffer (chamado shared
). Apenas pule o trecho de código e veja abaixo se você gostaria de uma breve descrição do que está acontecendo (antes de ler a minha pergunta).
// Fig. 15.8: UnsynchronizedBufferTest.cs
// Showing multiple threads modifying a shared object without
// synchronization.
using System;
using System.Threading;
class UnsynchronizedBufferTest
{
static void Main(string[] args)
{
// create shared object used by threads
UnsynchronizedBufferTest shared = new UnsynchronizedBuffer();
// Random object used by each thread
Random random = new Random();
// create Producer and Consumer objects
Producer producer = new Producer(shared, random);
Consumer consumer = new Consumer(shared, random);
// create threads for producer and consumer and set
// delegates for each thread
Thread producerThread =
new Thread(new ThreadStart(producer.Produce));
producerThread.Name = "Producer";
Thread consumerThread =
new Thread(new ThreadStart(consumer.Consume));
consumerThread.Name = "Consumer";
// start each thread
producerThread.Start();
consumerThread.Start();
} // end Main
} // end class UnsynchronizedBufferTest
Apenas pela ideia básica do que está acontecendo aqui, um thread produtor está executando os dados puts em um buffer (chamado shared
). Além disso, um segmento de consumidor está executando que obtém os dados do buffer.
Os objetos Producer
e Consumer
estão de alguma forma compartilhando esse buffer, que é o que estou tendo dificuldade em entender. Pelo que eu sempre entendi sobre a linguagem C #, quando um objeto é passado para um método, é apenas uma cópia ou instância que realmente é passada. Eu acho que deve estar errado, porque quando o Producer
coloca os dados no buffer, o Consumer
vê isso ...
O trecho de código para o buffer (caso alguém precise disso) é o seguinte (pp. 734). Honestamente, eu não acho que terá nada a ver com a resposta, e que a resposta tem mais a ver com a linguagem C #, porque realmente toda essa classe representa é um inteiro.
// Fig. 15.7: UnsynchronizedBuffer.cs
// An unsynchronized shared buffer implementation.
using System;
using System.Threading;
// this class represents a single shared int
public class UnsynchronizedBuffer : Buffer
{
// buffer shared by producer and consumer threads
private int buffer = -1;
// property buffer
public int Buffer
{
get
{
Console.WriteLine("{0} reads {1}",
Thread.CurrentThread.Name, buffer);
return buffer;
} // end get
set
{
Console.WriteLine("{0} writes {1}",
Thread.CurrentThread.Name, value);
buffer = value;
} // end set
} // end property Buffer
} // end class UnsynchronizedBuffer
Pergunta
Como é possível que os dois objetos (o Producer
e o Consumer
) consigam ver as alterações que cada um faz? (ou seja, quando o Producer
definir os dados, o Consumer
poderá ver os novos dados)
Eu devo estar faltando alguma coisa no meu entendimento fundamental do C #.