code: public static void lock(Lock lock, String callerClass, String callerMethod, Object... args) {
  		final String sourceMethod = "lock"; //$NON-NLS-1$
  		final boolean isTraceLogging = log.isLoggable(Level.FINER);
  		if (isTraceLogging) {
  			log.entering(sourceClass, sourceMethod, new Object[]{Thread.currentThread(), lock, callerClass, callerMethod, args});
  		}
  		long start = System.currentTimeMillis();
  		boolean quiesced = false, logged = false;
  		try {
  			while (!lock.tryLock(SIGNAL_LOG_INTERVAL_SECONDS, TimeUnit.SECONDS)) {
  				if (!quiesced) {
  					quiesced = logWaiting(callerClass, callerMethod, lock, start, args);
  					logged = true;
  				}
  			}
  		} catch (InterruptedException ex) {
  			// InterruptedException is not thrown by Lock.lock() so convert to a
  			// RuntimeException.
  			throw new RuntimeException(ex);
  		}
  		if (logged) {
  			logResuming(callerClass, callerMethod, lock, start);
  		}
  		if (isTraceLogging) {
  			log.exiting(sourceClass, sourceMethod, Arrays.asList(Thread.currentThread(), lock, callerClass, callerMethod));
  		}
  		return;
  	}
docs: Implements the same semantics as {@link Lock#lock()}, except that the wait will periodically
  time out within this method to log a warning message that the thread appears stuck. This
  cycle will be repeated until the lock is obtained. If the thread has waited for an extended
  period, then wait logging is quiesced to avoid overwhelming the logs. If and when a thread
  that has been reported as being stuck finally does obtain the lock, then a warning level
  message is logged to indicate that the thread is resuming.
  
  @param lock
  the Lock object to wait on
  @param callerClass
  the caller class
  @param callerMethod
  the caller method
  @param args
  extra arguments to be appended to the log message