Java编程实现排他锁代码详解

/** 
   * @param file 
   * @param strToWrite 
   * @param append 
   * @param lockTime 以毫秒为单位,该值只是方便模拟排他锁时使用，－1表示不考虑该字段 
   * @return 
   */ 
  public static Boolean lockAndWrite(File file,String strToWrite,Boolean append,int lockTimE){ 
    if(!file.exists()){ 
      return false; 
    } 
    RandomAccessFile fis = null; 
    FileChAnnel fileChAnnel = null; 
    FileLock fl = null; 
    long tsBegin = System.currentTimeMillis(); 
    try { 
      fis = new RandomAccessFile(file,"rw"); 
      fileChAnnel = fis.getChAnnel(); 
      fl = fileChAnnel.tryLock(); 
      if(fl == null || !fl.isValid()){ 
        return false; 
      } 
      log.info("threadId = {} lock success",Thread.currentThread()); 
      // if append 
      if(append){ 
        long length = fis.length(); 
        fis.seek(length); 
        fis.writeUTF(strToWritE); 
      //if not,clear the content,then write 
      }else{ 
        fis.setLength(0); 
        fis.writeUTF(strToWritE); 
      } 
      long tsEnd = System.currentTimeMillis(); 
      long @R_601_10586@lCost = (tsEnd - tsBegin); 
      if(@R_601_10586@lCost < lockTimE){ 
        Thread.sleep(lockTime - @R_601_10586@lCost); 
      } 
    } catch (Exception E) { 
      log.error("RandomAccessFile error",E); 
      return false; 
    }finally{ 
      if(fl != null){ 
        try { 
          fl.release(); 
        } catch (IOException E) { 
          e.printStackTrace(); 
        } 
      } 
      if(fileChAnnel != null){ 
        try { 
          fileChAnnel.close(); 
        } catch (IOException E) { 
          e.printStackTrace(); 
        } 
      } 
      if(fis != null){ 
        try { 
          fis.close(); 
        } catch (IOException E) { 
          e.printStackTrace(); 
        } 
      } 
    } 
    return true; 
  } 

public static void main(String[] args) { 
    new Thread("write-thread-1-lock"){ 
      @Override 
      public void run() { 
        FileLockUtils.lockAndWrite(new File("/data/Hello.txt"),"write-thread-1-lock" ＋ System.currentTimeMillis(),false,30 * 1000);} 
    }.start(); 
    new Thread("write-thread-2-lock"){ 
      @Override 
      public void run() { 
        FileLockUtils.lockAndWrite(new File("/data/Hello.txt"),"write-thread-2-lock" + System.currentTimeMillis(),30 * 1000); 
      } 
    }.start(); 
  } 

On some systems,closing a chAnnel releases all locks Held by the Java virtual machine on the 
 underlying file regardless of whether the locks were acquired via that chAnnel or via  
another chAnnel open on the same file.it is strongly recommended that,within a program,a unique 
 chAnnel be used to acquire all locks on any given file. 

public synchronized Boolean obtain() throws IOException { 
    if (lock != null) { 
      // Our instance is already locked: 
      return false; 
    } 
    // Ensure that lockDir exists and is a directory. 
    if (!lockDir.exists()) { 
      if (!lockDir.mkdirs()) 
        throw new IOException("CAnnot create directory: " + lockDir.getAbsolutePath()); 
    } else if (!lockDir.isDirectory()) { 
      // TODO: NoSuchDirectoryException instead? 
      throw new IOException("Found regular file where directory expected: " + lockDir.getAbsolutePath()); 
    } 
    final String canonicalPath = path.getCanonicalPath(); 
    // Make sure nobody else in-process has this lock Held 
    // already,and,mark it Held if not: 
    // This is a pretty crazy workaround for some documented 
    // but yet awkWARD JVM behavior: 
    // 
    // On some systems,closing a chAnnel releases all locks Held by the 
    // Java virtual machine on the underlying file 
    // regardless of whether the locks were acquired via that chAnnel or via 
    // another chAnnel open on the same file. 
    // it is strongly recommended that,a unique chAnnel 
    // be used to acquire all locks on any given 
    // file. 
    // 
    // This essentially means if we close "A" chAnnel for a given file all 
    // locks might be released... the odd part 
    // is that we can't re-obtain the lock in the same JVM but from a 
    // different process if that happens. NevertHeless 
    // this is super trappy. See LUCENE-5738 
    Boolean obtained = false; 
    if (LOCK_HelD.add(canonicalPath)) { 
      try { 
        chAnnel = FileChAnnel.open(path.toPath(),StandardopenOption.CREATE,StandardopenOption.WRITE); 
        try { 
          lock = chAnnel.tryLock(); 
          obtained = lock != null; 
        } catch (IOException | OverlappingFileLockException E) { 
          // at least on OS X,we will sometimes get an 
          // intermittent "Permission Denied" IOException,// which seems to simply mean "you failed to get 
          // the lock". But other IOExceptions could be 
          // "peRMANent" (eg,locking is not supported via 
          // the filesystem). So,we record the failure 
          // reason here; the timeout obtain (usually the 
          // one calling us) will use this as "root cause" 
          // if it fails to get the lock. 
          failureReason = e; 
        } 
      } finally { 
        if (obtained == falsE) { // not successful - clear up and move 
                      // out 
          clearLockHeld(path); 
          final FileChAnnel toClose = chAnnel; 
          chAnnel = null; 
          closeWhileHandlingException(toClosE); 
        } 
      } 
    } 
    return obtained; 
  }