Run as long there is still an event for the key.
160505
public void runMoreOrStop(AsyncEvent<K> _event) {
    for (;;) {
      try {
        _event.execute();
      } catch (Throwable t) {
        cache.getLog().warn("Async event exception", t);
      }
      final K key = _event.getKey();
      synchronized (getLockObject(key)) {
        Queue<AsyncEvent<K>> q = keyQueue.get(key);
        if (q.isEmpty()) {
          keyQueue.remove(key);
          return;
        }
        _event = q.remove();
      }
    }
  }
1280170
def _set_key(self):
        '''
        
        '''
        if self.roll:
            self.date = time.strftime(self.date_format,
                                      time.gmtime(self.start_time))

            self.final_key = '{}:{}'.format(self.key, self.date)
        else:
            self.final_key = self.key
1086600
private void onMiss(long key) {
    Node node = new Node(key, WINDOW);
    node.appendToTail(headWindow);
    data.put(key, node);
    windowSize++;
    evict();
  }
74396
function press(event) {
      if (event.keyCode === 39) {
        Components.Run.make(Components.Direction.resolve('>'));
      }

      if (event.keyCode === 37) {
        Components.Run.make(Components.Direction.resolve('<'));
      }
    }
1136856
public Long pexpireAt(Object key, long millisecondsTimestamp) {
		Jedis jedis = getJedis();
		try {
			return jedis.pexpireAt(keyToBytes(key), millisecondsTimestamp);
		}
		finally {close(jedis);}
	}
1241461
def start(self, key):
        
        start_d = self._get_limiter(key).start()
        self._cleanup_limiter(key)
        return start_d
361083
public Long expire(Object key, int seconds) {
		Jedis jedis = getJedis();
		try {
			return jedis.expire(keyToBytes(key), seconds);
		}
		finally {close(jedis);}
	}
1299095
def run(self):
        """"""
        self.state = True
        self.hm.KeyAll = self.handler
        self.hm.HookKeyboard()
        while self.state:
            time.sleep(0.01)
            pythoncom.PumpWaitingMessages()
1108440
private void verifyKey(final String key) {

		if (!theKey.get().equals(key)) {
			try {
				throw new RuntimeException("Must have same key for Redis Pipeline in Dynomite. This key: " + key);
			} finally {
				discardPipelineAndReleaseConnection();
			}
		}
	}
26886
private void checkKey(final byte[] key) {
		if (theBinaryKey.get() != null) {
			verifyKey(key);
		} else {
			boolean success = theBinaryKey.compareAndSet(null, key);
			if (!success) {
				// someone already beat us to it. that's fine, just verify
				// that the key is the same
				verifyKey(key);
			} else {
				pipelined(key);
			}
		}
	}
517685
def tap_key(self, character='', n=1, interval=0):
        """"""
        for i in range(n):
            self.press_key(character)
            self.release_key(character)
            time.sleep(interval)
227987
public void time(Runnable event) {
        long startTime = this.clock.getTick();
        try {
            event.run();
        } finally {
            update(this.clock.getTick() - startTime);
        }
    }
160968
def timer(self, key, **dims):
        """"""
        return super(RegexRegistry, self).timer(self._get_key(key), **dims)
27596
def track_duration(self, key):
        
        if key not in self.durations:
            self.durations[key] = []
        start_time = time.time()
        try:
            yield
        finally:
            self.durations[key].append(
                max(start_time, time.time()) - start_time)
823133
def wait(hotkey=None, suppress=False, trigger_on_release=False):
    
    if hotkey:
        lock = _Event()
        remove = add_hotkey(hotkey, lambda: lock.set(), suppress=suppress, trigger_on_release=trigger_on_release)
        lock.wait()
        remove_hotkey(remove)
    else:
        while True:
            _time.sleep(1e6)
703392
def request_finished(key):
    
    with event_lock:
        threads[key] = threads[key][1:]

        if threads[key]:
            threads[key][0].run()
299209
public Long expireAt(Object key, long unixTime) {
		Jedis jedis = getJedis();
		try {
			return jedis.expireAt(keyToBytes(key), unixTime);
		}
		finally {close(jedis);}
	}