Sincronizadores: sincronizando o acesso a recursos em Java

Semáforo

Os semáforos geralmente são usados ​​quando é necessário limitar o número de threads ao trabalhar com o sistema de arquivos. O acesso a um arquivo ou outro recurso compartilhado é controlado por meio de um contador. Se seu valor for maior que zero, o acesso é permitido, mas ao mesmo tempo o contador diminuirá.

No momento em que o contador retornar a zero, a thread atual será bloqueada até que o recurso seja liberado por outra thread. O parâmetro número de permissões deve ser definido por meio do construtor.

Você precisa selecionar este parâmetro individualmente, dependendo da potência do seu computador ou laptop.

public class Main {

   public static void main(String[] args) {
       Semaphore sem = new Semaphore(1);
       CommonResource res = new CommonResource();
       new Thread(new MyThread(res, sem, "MyThread_1")).start();
       new Thread(new MyThread(res, sem, "MyThread_2")).start();
       new Thread(new MyThread(res, sem, "MyThread_3")).start();
   }
}

class CommonResource {
   int value = 0;
}

class MyThread implements Runnable {
   CommonResource commonResource;
   Semaphore semaphore;
   String name;
   MyThread(CommonResource commonResource, Semaphore sem, String name) {
       this.commonResource = commonResource;
       this.semaphore = sem;
       this.name = name;
   }

   public void run() {

       try {
           System.out.println(name + "waiting permission");
           semaphore.acquire();
           commonResource.value = 1;
           for (int i = 1; i < 7; i++) {
               System.out.println(this.name + ": " + commonResource.value);
               commonResource.value++;
               Thread.sleep(150);
           }
       } catch (InterruptedException e) {
           System.out.println(e.getMessage() + " " + name);
           Thread.currentThread().interrupt();
       }
       System.out.println(name + "releases permission");
       semaphore.release();
   }
}

CountDownLatch e outros

CountDownLatch - permite que vários threads esperem até que um determinado número de operações executadas em outros threads seja concluído. Um exemplo é a instalação de um aplicativo: ele não será iniciado até que você aceite os termos de uso, até que selecione uma pasta onde instalar um novo programa e assim por diante. Existe um método countDown() especial para isso - esse método diminui o contador regressivo em um.

Assim que a contagem chegar a zero, todos os threads em espera no await continuarão seu trabalho e todas as chamadas subseqüentes de await passarão sem esperar. O contador regressivo é um contador único e não pode ser zerado.

CyclicBarrier - usado para sincronizar um determinado número de threads em um ponto. A barreira é atingida quando N threads chamam o método await(...) e bloqueiam. Depois disso, o contador é redefinido para seu valor original e os threads em espera serão liberados. Além disso, se necessário, é possível executar um código personalizado antes de desbloquear threads e redefinir o contador. Para fazer isso, um objeto com uma implementação da interface Runnable é passado pelo construtor .

Exchanger<V> — a classe Exchanger destina-se à troca de dados entre threads. Ele é digitado e digita o tipo de dados que os threads precisam trocar.

Os dados são trocados usando o único método exchange() desta classe :

V exchange(V x) throws InterruptedException
V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException

O parâmetro x representa o buffer de dados a ser trocado. A segunda forma do método também define o parâmetro timeout , o timeout e unit , o tipo de unidade de tempo a ser usado para o parâmetro timeout .

A classe Phaser permite sincronizar threads que representam uma única fase ou estágio na execução de uma ação geral. Phaser define um objeto de sincronização que espera até que uma determinada fase seja concluída. O Phaser então passa para o próximo estágio ou fase e espera que ele seja concluído novamente.

Ao trabalhar com a classe Phaser , é comum primeiro criar seu objeto. Em seguida, precisamos registrar todos os participantes. Para se registrar para cada participante, o método register() é chamado , ou você pode dispensar esse método passando o número necessário de participantes para o construtor Phaser .

Em seguida, cada participante executa um determinado conjunto de ações que compõem a fase. E o sincronizador Phaser espera até que todos os participantes tenham concluído a execução da fase. Para informar ao sincronizador que a fase terminou, o participante deve chamar o método reach() ou reachAndAwaitAdvance() . O sincronizador então passa para a próxima fase.