Canais entre threads

P.canal: receber espera, o produtor rápido para quando a fila enche, e fechar termina o consumidor.

Um canal é uma fila entre threads com duas garantias: quem recebe espera até chegar algo, e — com capacidade — quem envia espera quando a fila enche. A segunda é a que protege a memória: um produtor mais rápido que o consumidor para no enviar, em vez de acumular um milhão de itens.

adopt Arcane.Concurrent as P

tarefas := P.canal(2)
feitas := []

action produzir():
    cycle i from 1 to 5:
        tarefas.enviar(i)
    tarefas.fechar()

action consumir():
    persist yes:
        t := tarefas.receber()
        given t is void:                  // fechado e vazio
            halt
        feitas.append(t * 10)

parallel:
    produzir()
    consumir()
assert feitas is [10, 20, 30, 40, 50]

• `receber(prazo)` desiste depois do prazo, em vez de esperar para sempre por um produtor que morreu.
• `tentar_receber()` não espera: void se estiver vazio.
• Entre fibras de um laço, o canal é outro — o que suspende a fibra, e não a thread: ver Canais entre fibras.