Unlock the monitor
495928
def do_unlock
      unless(owner?(Thread.current))
        raise ThreadError.new("Thread #{Thread.current} is not the current owner: #{@lock_owner}")
      end
      Thread.exclusive do
        @locks.delete_if{|t|!t.alive?}
        unless(@locks.empty?)
          old_owner = @lock_owner
          @lock_owner = @locks.shift
          @lock_owner.wakeup unless old_owner == @lock_owner
        else
          @lock_owner = nil
        end
      end
    end
140642
def begin(self):
        """"""
        # Turn on the oscillator.
        self._device.writeList(HT16K33_SYSTEM_SETUP | HT16K33_OSCILLATOR, [])
        # Turn display on with no blinking.
        self.set_blink(HT16K33_BLINK_OFF)
        # Set display to full brightness.
        self.set_brightness(15)
1258250
public final void unlockFromRead(L locker) {
        adjustReadLockCount(locker, -1);

        int readLocks;
        while ((readLocks = decrementReadLocks(mState)) < 0) {}

        if (readLocks == 0) {
            Node h = mRWHead;
            if (h != null && h.mWaitStatus != 0) {
                unparkReadWriteSuccessor(h);
            }
        }
    }
825427
def press(self):
    """"""
    self._lutron.send(Lutron.OP_EXECUTE, Keypad._CMD_TYPE, self._keypad.id,
                      self.component_number, Button._ACTION_PRESS)
901028
def unlock(self):
        
        cursor = connection.cursor()
        cursor.execute("UNLOCK TABLES")
        logger.debug('Unlocked tables')
        row = cursor.fetchone()
        return row
288844
def unlock(self):
        
        return self._encode_invoke(lock_unlock_codec, thread_id=thread_id(),
                                   reference_id=self.reference_id_generator.get_and_increment())
789038
def _add_monitor(monitors, handle, callback, devices, events):
    """"""

    for conn_string in devices:
        data = monitors.get(conn_string)
        if data is None:
            data = dict()
            monitors[conn_string] = data

        for event in events:
            event_dict = data.get(event)
            if event_dict is None:
                event_dict = dict()
                data[event] = event_dict

            event_dict[handle] = callback
272766
function() {
      var t = this;

      // Detach any prior monitor
      if (t.monitor) {
        t.monitor.off('change', t.onMonitorChange, t);
        delete t.monitor;
      }
    }
1082185
public function unlock()
    {
        if ($this->fp !== null) {
            flock($this->fp, LOCK_UN);
            fclose($this->fp);
            $this->fp = null;
        }

        return true;
    }
721238
void unlockCurrent() {

        if (m_currentResource != null) {
            if ((m_lockAction != null) && m_lockAction.getChange().equals(LockChange.locked)) {
                CmsLockUtil.tryUnlock(A_CmsUI.getCmsObject(), m_currentResource);
            }
        }
        m_lockAction = null;
    }
1232572
def setmonitor(self, enable=True):
        """"""
        # We must reset the monitor cache
        if enable:
            res = self.setmode('monitor')
        else:
            res = self.setmode('managed')
        if not res:
            log_runtime.error("Npcap WlanHelper returned with an error code !")
        self.cache_mode = None
        tmp = self.cache_mode = self.ismonitor()
        return tmp if enable else (not tmp)
1249513
def _unlock(self):
        """"""
        if self.locked:
            try:
                self.device.cu.unlock()
                self.locked = False
            except JnrpUnlockError as jue:
                raise UnlockError(jue.messsage)
565560
def remove(self, cb):
        """"""
        if cb in self.callbacks:
            self.callbacks.remove(cb)
            new_monitor = 0
            for c in self.callbacks:
                new_monitor |= c.bit
            if new_monitor != self.monitor:
                self.monitor = new_monitor
                yield from self.pi._pigpio_aio_command(
                    _PI_CMD_NB, self.handle, self.monitor)
48359
def _unlock(self):
        '''
        
        '''
        if self._devel: self.logger.debug("Unlocking Index")
        if self._is_locked():
            os.remove(self._lck)
            return True
        else:
            return True
1129496
def enable_display(self, enable):
        """"""
        if enable:
            self.displaycontrol |= LCD_DISPLAYON
        else:
            self.displaycontrol &= ~LCD_DISPLAYON
        self.write8(LCD_DISPLAYCONTROL | self.displaycontrol)
759490
def resetMonitors(self):
        
        Debug.error("*** BE AWARE: experimental - might not work ***")
        Debug.error("Re-evaluation of the monitor setup has been requested")
        Debug.error("... Current Region/Screen objects might not be valid any longer")
        Debug.error("... Use existing Region/Screen objects only if you know what you are doing!")
        self.__init__(self._screenId)
        self.showMonitors()
401349
function() {
			var self = this;
			self.$input.prop('disabled', false);
			self.$control_input.prop('disabled', false).prop('tabindex', self.tabIndex);
			self.isDisabled = false;
			self.unlock();
		}