Il metodo tryLock() di FileChannel verifica la presenza di blocchi o li interrompe semplicemente?

Question

Ho due processi che possono accedere allo stesso file in modo conciso e che volevano implementare il blocco dei file. Il problema sembra essere che un processo è scritto in java e l'altro in C e non è chiaro come il blocco a basso livello sia implementato su Java. La piattaforma è Solaris 10. Ho provato a introdurre il blocco sul file per impedire che gli aggiornamenti vengano eseguiti dal processo Java mentre il processo C sta leggendo il file. La mia idea era di tentare di acquisire un blocco dal codice java 10 volte e solo poi di scrivere incondizionatamente sul file (supponevo che il tipo di blocco fosse un blocco di avviso). Tuttavia, java tryLock() interrompe il processo C al secondo tentativo e corrompe la lettura.

Ecco il codice, semplificata (di Java):

int iAttemptCnt = 0; 
       FileChannel wchannel = new FileOutputStream(new File(fileName), false).getChannel();; 
       FileLock flock; 
    while(true){ 
     try{ 
      MyLog.log(MyLog.LVL_INFO, "attempt to lock file"); 
      if((flock = wChannel.tryLock()) == null){ 
       // lock held by another program 
       if(++iAttemptCnt >= 10 
        break;     
      } 
      else{ 
       MyLog.log(MyLog.LVL_INFO, " file locked"); 
       break; 
      } 
     }catch(OverlappingFileLockException ofle){ 
      .......      
      if(++iAttemptCnt >= 10){ 
      ... 
       break;   
      }     
     }catch(IOException ioe){ 
      throw new IOException("failed to lock the file"); 
     } 
     try{ 
      MyLog.log(MyLog.LVL_INFO, "File already locked, retrying in one second"); 
      Thread.sleep(1000); 
     }catch(InterruptedException ie){ 
      ..... 
     } 

    } 

codice C utilizza fcntl:

fd = open(filename, O_RDONLY); 

..... 

lck.l_type = F_RDLCK;/* F_RDLCK setting a shared or read lock */ 

lck.l_whence = 0; /* offset l_start from beginning of file */ 

lck.l_start = 0LL; 

lck.l_len = 0LL; /* until the end of the file address space */ 

.... 

while( fcntl(fd, F_SETLK64, &lck) < 0){ 

    if(errno == EAGAIN) 

    ....  
    else if (errno == EIO) 

    ... 

    else if(errno == ENOLCK) 

    ... 

    else if (errno == EDEADLK) 

    ... 
    if(++ii == 10){  

    break; 
    } 

    ...  

    sleep(1); 
} 

MyLongLastingRead(); 

... 
lck.l_type = F_UNLCK; 

fcntl(fd, F_SETLK, &lck); 

close(fd); 

Vuol tryLock() controlla davvero per il blocco?

Answer 1

Non sono sicuro se questo risolverà il problema o meno, ma negli esempi che ho visto il campo l_pid della struttura di flock è stato impostato come di seguito.

fl.l_pid = getpid(); 

Nella tua domanda non stai impostando questo campo. Prova a vedere se fa alcuna differenza. Spero che aiuti.