Diferenças Essenciais entre Processos e Threads

Comunicação entre Processos (IPC)

1. Tubos Anônimos

// Exemplo em C (Linux)
int descritores[2];
pipe(descritores);  // descritores[0]=leitura, descritores[1]=escrita
if (fork() == 0) {
    write(descritores[1], "dados", 5);
} else {
    char buffer[10];
    read(descritores[0], buffer, 10);
}

Características: Comunicação unidirecional, limitada a processos relacionados.

2. Memória Compartilhada

// Criação de segmento
int segmento = shmget(IPC_PRIVATE, 2048, 0666);
// Anexação
char *mem = shmat(segmento, NULL, 0);
// Escrita
strcpy(mem, "Informações compartilhadas");

Características: Máximo desempenho, requer sincronização explícita.

3. Filas de Mensagens

// Envio/recebimento
struct mensagem {
    long tipo;
    char conteudo[50];
};
msgsnd(idFila, &msg, sizeof(msg.conteudo), 0);
msgrcv(idFila, &msg, sizeof(msg.conteudo), 1, 0);

Características: Comunicação estruturada por tipos de mensaegm.

4. Sockets

# Python (TCP)
# Servidor
sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen()
conn, addr = sock.accept()
conn.send(b"Mensagem")

# Cliente
sock = socket.socket()
sock.connect(('localhost', 8080))
dados = sock.recv(1024)

Características: Suporte a comunicação em rede, bidirecional.

Comunicação entre Threads

1. Variáveis Compartilhadas

// Java
class Dados {
    static int contador;
}
// Thread 1
synchronized(this) { Dados.contador++; }

2. Mecanismos de Sincronização

# Python (Lock)
trava = threading.Lock()
def funcao():
    with trava:
        # Região crítica

3. Variáveis de Condição

// C++
std::mutex mux;
std::condition_variable cv;
bool pronto = false;

// Espera
std::unique_lock<std::mutex> lk(mux);
cv.wait(lk, []{return pronto;});

// Notificação
{
    std::lock_guard<std::mutex> lg(mux);
    pronto = true;
}
cv.notify_one();

Recomendações de Uso