docs: public final boolean tryRelease()
      throws LockFile.FileSecurityException, LockFile.UnexpectedFileIOException {
  
          boolean released = !locked;
  
          if (released) {
              return true;
          }
  
          stopHeartbeat();
          doOptionalReleaseActions();
  
          UnexpectedFileIOException closeRAFReason = null;
          FileSecurityException     securityReason = null;
  
          try {
              try {
                  closeRAF();
              } catch (UnexpectedFileIOException ex) {
                  closeRAFReason = ex;
              }
  
              try {
  
                  // Hack Alert:
                  //
                  // Even without the presence of concurrent locking attempts,
                  // the delete or exists invocations below occasionally return
                  // false otherwise, perhaps due to a race condition with the
                  // heartbeat timestamp writer task or some nio file lock release
                  // timing issue?
                  //
                  // TODO:
                  //
                  // determine if this is an external constraint or if we can
                  // solve it instead by waiting for any in-progress
                  // writeHeartbeat operation to conclude.
                  Thread.sleep(100);
              } catch (Exception ex) {
  
                  // ex.printStackTrace();
              }
  
              try {
                  released = file.delete();
  
                  // Perhaps excessive...
                  //
                  // Another Lockfile may recreate the file an instant after it is
                  // deleted above (if it it deleted successfully, that is)
                  // released = !file.exists();
              } catch (SecurityException ex) {
                  securityReason = new FileSecurityException(this, "tryRelease",
                          ex);
              }
          } finally {
  
              // Regardless of whether all release work succeeds, it is important
              // to indicate that, from the perspective of this instance, a lock
              // condition is no longer held.
              //
              // However, in a world of concurrent execution, we do not want to
              // to expose this fact extenally until *after* all release work has
              // been at least attempted.
              this.locked = false;
          }
  
          if (closeRAFReason != null) {
              throw closeRAFReason;
          } else if (securityReason != null) {
              throw securityReason;
          }
  
          return released;
      }