Blocco thread Java durante la registrazione del canale con selettore mentre viene chiamato select(). Cosa fare?

Question

Ho una domanda di base. Perché e come il metodo di registrazione di SelectableChannel può essere nella chiamata di blocco. Consentitemi di fornire uno scenario.

Ho creato un oggetto Selector nel registro di classe come segue.

private static Selector selector = Selector.open(); 

Ho anche un metodo nella stessa classe (Registro) per registrare il canale con il selettore.

public static SelectionKey registerChannel(SelectableChannel channel, 
      int ops) throws IOException { 

     channel.configureBlocking(false); 
     return channel.register(selector, ops); 
    } 

E c'è un'altra classe di nome request, che ha metodo che legge i dati provenienti da canali, i processi e le chiamate seguente metodo per registrare il canale.

selectonKey = Register.register(socketChannel, SelectionKey.OP_READ); 

Qui a questo punto il thread è bloccato, non dando la chiave di ciò che sta aspettando. Ho verificato che il selettore è aperto. Per favore forniscimi un aiuto per capire come posso risolvere questo problema. C'è un blocco che posso rilasciare.

Qualsiasi input sarebbe apprezzato.

In aggiunta a ciò che ho descritto. Ulteriori test hanno rivelato che se il metodo Register.register viene chiamato dallo stesso thread, è in grado di registrarsi ma dopo di ciò se qualche altro thread tenta di richiamare il metodo, thread non si muove avanti.

Answer 1

Hai provato a stampare una traccia di stack di tutti i thread nel programma (utilizzando kill -QUIT in Unix o Ctrl + Break in Windows o utilizzando l'utilità jstack)?

AbstractSelectableChannel contiene un blocco su cui è necessario sincronizzare configureBlocking e register. Questo blocco è accessibile anche attraverso il metodo blockingLock(), quindi un altro thread potrebbe bloccare il blocco causando il blocco della chiamata al registro (ma senza traccia dello stack è difficile dirlo).

Answer 2

È necessario utilizzare un blocco e sincronizzare manualmente.

nello stesso thread si esegue il ciclo di selezione hanno un ReentrantLock:

final ReentrantLock selectorLock = new ReentrantLock(); 

Poi, quando è necessario registrarsi con il selettore fare qualcosa di simile:

selectorLock.lock(); 
try { 
    selector.wakeup(); 
    socketChannel.register(selector, ops); 
} finally { 
    selectorLock.unlock(); 
} 

Infine, durante il vostro loop che stai chiamando accept(), qualcosa del genere:

selectorLock.lock(); 
selectorLock.unlock(); 

selector.select(500); 

E t gallina continua con il resto della tua logica.

Questo costrutto garantisce che la chiamata register() non blocca garantendo che non c'è mai un'altra select() tra corrispondenti wakeup() e register() chiamate.

Answer 3

Questa è una funzionalità di base della maggior parte delle implementazioni NIO che non è evidente dalla documentazione.

È necessario effettuare tutte le chiamate di registro dallo stesso thread che esegue la selezione o si verificheranno deadlock. Di solito questo viene fatto fornendo una coda di registrazioni/deregistrations/interest-changes su cui è scritto e quindi viene chiamato selector.wakeup(). Quando il thread di selezione si attiva, controlla la coda ed esegue tutte le operazioni richieste.

Answer 4

Registrare il canale da qualsiasi thread:

synchronized (selectorLock2) { 
    selector.wakeup(); 
    synchronized (selectorLock1) { 
     channel.register(selector, ops); 
    } 
} 

il ciclo di selezione dovrebbe essere simile a questo:

while (true) { 
    synchronized (selectorLock1) { 
     selector.select(); 
    } 
    synchronized (selectorLock2) {} 

    .... 
}