Come bloccare un metodo java per proteggere più chiamate

Question

Ho un'applicazione che ogni 15 minuti circa esegue una replica da un database remoto. Mantiene solo i due repository sincronizzati. Una volta che questa replica sta andando, non è possibile farlo di nuovo. Ho configurato la seguente struttura, ma non sono sicuro che sia l'approccio corretto.

public class ReplicatorRunner { 

     private static Lock lock = new ReentrantLock(); 

     public replicate() { 

      if (lock.tryLock()) { 
       try { 
        // long running process 
       } catch (Exception e) {     
       } finally { 
        lock.unlock(); 
       }    
      } else { 
       throw new IllegalStateException("already replicating"); 
      } 

     } 

} 

public class ReplicatorRunnerInvocator { 

    public void someMethod() { 

     try { 
      ReplicatorRunner replicator = new ReplicatorRunner(); 
      replicator.replicate(); 
     } catch (IllegalStateException e) { 
      e.printStackTrace(); 
     } 

    } 

} 

Il ReplicatorRunner è la classe che possiede il metodo replicate che può essere eseguito solo uno alla volta.

Modifica. Ho bisogno della prossima chiamata per fallire (non bloccare) se il metodo è già in esecuzione su qualsiasi istanza.

Answer 1

Questo sembra buono. ReentrantLock.tryLock() assegnerà il blocco solo a un thread, quindi synchronized non è necessario. Inoltre impedisce il blocco inerente alla sincronizzazione che si dice sia un requisito. ReentrantLock è serializzabile, quindi dovrebbe funzionare in tutto il cluster.

Vai per questo.

Answer 2

un'occhiata alla classe semaforo here o contrassegnare il metodo sincronizzato il filo esecuzione del metodo in un dato momento possiede una serratura evitando altri thread per chiamare il metodo fino alla sua esecuzione termina.
Modifica: se si desidera che gli altri thread non riescano, è possibile utilizzare uno Lock e verificare se il blocco è disponibile con il metodo tryLock.

Answer 3

Change public replicate()-public synchronized replicate()

In questo modo replica sarà sempre e solo consentirà l'accesso a un thread alla volta. Sarai anche in grado di eliminare ReentrantLock e tutto il codice associato.

Answer 4

Senza guardare le specifiche del ReentrantLock, mi viene in mente che questa prevenzione di più routine di replica simultanea sarà limitata a una singola istanza JVM.

Se un'altra istanza della classe viene avviata in una JVM separata, potrebbe essere nei guai.

Perché non inserire un meccanismo di blocco nel database? Ad esempio, una riga in una tabella di controllo impostata su un valore che indica se la replica è occupata o meno, e reimpostare il valore al termine della replica.

Answer 5

ho finito per usare le seguenti:

public class ReplicatorRunner { 

     private static Semaphore lock = new Semaphore(1); 

     public replicate() { 

      if (lock.tryAcquire()) { 
       try {        
        // basic setup     
        Thread t = new Thread(new Runnable() { 
         public void run() { 
          try { 
           // long running process        
          } catch Exception (e) { 
           // handle the exceptions 
          } finally { 
           lock.release(); 
          } 
         } 
        }) 
        t.start(); 

       } catch (Exception e) { 
        // in case something goes wrong 
        // before the thread starts 
        lock.release(); 
       }    
      } else { 
       throw new IllegalStateException("already replicating"); 
      } 

     } 

} 

public class ReplicatorRunnerInvocator { 

    public void someMethod() { 

     try { 
      ReplicatorRunner replicator = new ReplicatorRunner(); 
      replicator.replicate(); 
     } catch (IllegalStateException e) { 
      e.printStackTrace(); 
     } 

    } 

}