/** * Refresh locks held by the authorization <code>authID</code>. * * <p>(remember that the lock may have expired) * * @param authID Authorization identifing Lock to refresh * @param transaction Transaction with authorization for lockID * @return <code>true</code> if lock was found and refreshed * @throws IOException If transaction not authorized to refresh authID * @throws IllegalArgumentException If authID or transaction not provided */ public synchronized boolean refresh(String authID, Transaction transaction) throws IOException { if (authID == null) { throw new IllegalArgumentException("lockID required"); } if ((transaction == null) || (transaction == Transaction.AUTO_COMMIT)) { throw new IllegalArgumentException( "Tansaction required (with authorization for " + authID + ")"); } Lock lock; boolean refresh = false; for (Iterator i = allLocks().iterator(); i.hasNext(); ) { lock = (Lock) i.next(); if (lock.isExpired()) { i.remove(); } else if (lock.isMatch(authID)) { if (lock.isAuthorized(transaction)) { lock.refresh(); refresh = true; } else { throw new IOException("Not authorized to refresh " + lock); } } } return refresh; }
/** * Lock for typeName & featureID if it exists. * * <p>This method will not return expired locks. * * @param typeName * @param featureID * @return Lock if exists, or null */ protected Lock getLock(String typeName, String featureID) { Map locks = locks(typeName); // LOGGER.info("checking for lock " + typeName + ", " + featureID // + " in locks " + locks); synchronized (locks) { if (locks.containsKey(featureID)) { Lock lock = (Lock) locks.get(featureID); if (lock.isExpired()) { locks.remove(featureID); // LOGGER.info("returning null"); return null; } else { // LOGGER.info("returing " + lock); return lock; } } else { // LOGGER.info("locks did not contain key, returning null"); // not found return null; } } }
public void run() { otherMethod(l1); otherMethod(l2); l1.unlock(); l2.unlock(); }
public Q(int limit) { this.q = new LinkedList<>(); this.limit = limit; this.lock = new ReentrantLock(); this.full = lock.newCondition(); this.empty = lock.newCondition(); }
/* * Termina a realização da Tarefa. * Retorna true se foi terminada com sucesso false caso contrário */ public boolean endTask(String id) throws InterruptedException { Map<String, Integer> objectsToSupply; String type; lock.lock(); try { if (!this.tasksRunning.containsKey(Integer.valueOf(id))) { return false; } else { type = this.tasksRunning.get(Integer.valueOf(id)); objectsToSupply = this.tasks.get(type).getObjects(); } } finally { lock.unlock(); } // Supply de todos os objetos for (Map.Entry<String, Integer> entry : objectsToSupply.entrySet()) { warehouse.supply(entry.getKey(), entry.getValue()); } lock.lock(); try { this.tasksRunning.remove(Integer.valueOf(id)); this.tasks.get(type).signalP(); } finally { lock.unlock(); } return true; }
/** Do the real work of releaseAndFindNotifyTargets */ Set<Locker> releaseAndFindNotifyTargetsInternal(long nodeId, Locker locker, int lockTableIndex) { Map<Long, Lock> lockTable = lockTables[lockTableIndex]; Lock useLock = lockTable.get(nodeId); if (useLock == null) { useLock = lockTable.get(Long.valueOf(nodeId)); } if (useLock == null) { /* Lock doesn't exist. */ return null; } Set<Locker> lockersToNotify = useLock.release(locker, memoryBudget, lockTableIndex); if (lockersToNotify == null) { /* Not owner. */ return null; } /* If it's not in use at all, remove it from the lock table. */ if ((useLock.nWaiters() == 0) && (useLock.nOwners() == 0)) { lockTables[lockTableIndex].remove(nodeId); if (useLock.isThin()) { memoryBudget.updateLockMemoryUsage(REMOVE_TOTAL_THINLOCKIMPL_OVERHEAD, lockTableIndex); } else { memoryBudget.updateLockMemoryUsage(REMOVE_TOTAL_LOCKIMPL_OVERHEAD, lockTableIndex); } } return lockersToNotify; }
static void AdultItinerary() { System.out.println("--- called adult itinerary"); /* This is where you should put your solutions. Make calls to the BoatGrader to show that it is synchronized. For example: bg.AdultRowToMolokai(); indicates that an adult has rowed the boat across to Molokai */ pilotLock.acquire(); // While the boat is not at Oahu or there are more than 2 children on Oahu, // put the adult on Oahu thread to sleep (because we wouldn't send and adult in // these scenarios). while (boatLocation != 0 || numChildrenOnOahu >= 2) { System.out.println("--- can't send an adult to Molokai right now"); adultReadyAtOahu.sleep(); } System.out.println("--- sending an adult to Molokai"); numAdultsOnOahu--; // an adult is rowing Oahu --> Molokai, so decrement bg.AdultRowToMolokai(); numAdultsOnMolokai++; // adult has rowed over, so increment printState(); boatLocation = 1; // boat is now at Molokai childReadyAtMolokai.wake(); // wake up child at Molokai since it's now their turn pilotLock.release(); }
synchronized int unlockReference(LockTable lset, Lockable ref, Object qualifier, Object group) { // look for locks matching our reference and qualifier. HashMap dl = (HashMap) groups.get(group); if (dl == null) return 0; Lock lockInGroup = lset.unlockReference(this, ref, qualifier, dl); if (lockInGroup == null) { return 0; } if (lockInGroup.getCount() == 1) { if (dl.isEmpty()) { groups.remove(group); saveGroup(dl); if ((callbackGroup != null) && group.equals(callbackGroup)) { nextLimitCall = limit; } } return 1; } // the lock item will be left in the group lockInGroup.count--; dl.put(lockInGroup, lockInGroup); return 1; }
public void run() { while (true) { LinkedList<PacketCallbackStruct> list = null; try { queuedPacketCallbacksLock.lock(); try { queuedPacketCallbacksNotEmpty.await(); } catch (Exception e) { Log.error( "RDPServer.PacketCallbackThread: queuedPacketCallbacksNotEmpty.await() caught exception " + e.getMessage()); } list = queuedPacketCallbacks; queuedPacketCallbacks = new LinkedList<PacketCallbackStruct>(); } finally { queuedPacketCallbacksLock.unlock(); } if (Log.loggingNet) Log.net("RDPServer.PacketCallbackThread: Got " + list.size() + " queued packets"); for (PacketCallbackStruct pcs : list) { try { callbackProcessPacket(pcs.cb, pcs.con, pcs.packet); } catch (Exception e) { Log.exception("RDPServer.PacketCallbackThread: ", e); } } } }
/** Test if this module is working. */ public static void selfTest() { System.out.print("Enter Condition2.selfTest\n"); Lock lock = new Lock(); Condition2 condition = new Condition2(lock); KThread t[] = new KThread[10]; for (int i = 0; i < 10; i++) { t[i] = new KThread(new Condition2Test(lock, condition)); t[i].setName("Thread" + i).fork(); } KThread.yield(); lock.acquire(); System.out.print("condition.wake();\n"); condition.wake(); System.out.print("condition.wakeAll();\n"); condition.wakeAll(); lock.release(); System.out.print("Leave Condition2.selfTest\n"); t[9].join(); }
/* * Inicia a realização de uma Tarefa. * Retorna o ID se foi iniciada com sucesso -1 caso contrário */ public int beginTask(String type) { Map<String, Integer> objectsToConsume; lock.lock(); try { if (!this.tasks.containsKey(type)) return -1; else { objectsToConsume = this.tasks.get(type).getObjects(); } } finally { lock.unlock(); } try { warehouse.consume(objectsToConsume); } catch (Exception e) { return -1; } lock.lock(); try { countID++; this.tasksRunning.put(countID, type); return countID; // Retornar o ID da tarefa } finally { lock.unlock(); } }
public LockAttemptResult lock( LockType requestType, Locker locker, boolean nonBlockingRequest, MemoryBudget mb, int lockTableIndex) throws DatabaseException { if (this.locker != null && this.locker != locker) { /* Lock is already held by someone else so mutate. */ Lock newLock = new LockImpl(new LockInfo(this.locker, this.lockType)); return newLock.lock(requestType, locker, nonBlockingRequest, mb, lockTableIndex); } LockGrantType grant = null; if (this.locker == null) { this.locker = locker; this.lockType = requestType; grant = LockGrantType.NEW; } else { /* The requestor holds this lock. Check for upgrades. */ LockUpgrade upgrade = lockType.getUpgrade(requestType); if (upgrade.getUpgrade() == null) { grant = LockGrantType.EXISTING; } else { LockType upgradeType = upgrade.getUpgrade(); assert upgradeType != null; this.lockType = upgradeType; grant = (upgrade.getPromotion() ? LockGrantType.PROMOTION : LockGrantType.EXISTING); } } return new LockAttemptResult(this, grant, false); }
public Lock transferMultiple( Long nodeId, Locker currentLocker, Locker[] destLockers, MemoryBudget mb, int lockTableIndex) throws DatabaseException { Lock newLock = new LockImpl(new LockInfo(this.locker, this.lockType)); return newLock.transferMultiple(nodeId, currentLocker, destLockers, mb, lockTableIndex); }
/** Do the real work of dumpLockTableInternal. */ void dumpLockTableInternal(StatGroup tableStats, int i, boolean clear) { StatGroup oneTable = new StatGroup("Single lock table", "Temporary stat group"); IntStat totalLocks = new IntStat(oneTable, LOCK_TOTAL); IntStat waiters = new IntStat(oneTable, LOCK_WAITERS); IntStat owners = new IntStat(oneTable, LOCK_OWNERS); IntStat readLocks = new IntStat(oneTable, LOCK_READ_LOCKS); IntStat writeLocks = new IntStat(oneTable, LOCK_WRITE_LOCKS); Map<Long, Lock> lockTable = lockTables[i]; totalLocks.add(lockTable.size()); for (Lock lock : lockTable.values()) { waiters.add(lock.nWaiters()); owners.add(lock.nOwners()); /* Go through all the owners for a lock. */ for (LockInfo info : lock.getOwnersClone()) { if (info.getLockType().isWriteLock()) { writeLocks.increment(); } else { readLocks.increment(); } } } tableStats.addAll(oneTable); }
// the landing method public void landing(int flight_num, int wind) throws InterruptedException { L.lock(); try { // if turn is set to takeoff, then wait if (turn == 0) { C.await(); } wind_direction = wind; RunwaySystem(); System.out.println( "Flight " + flight_num + " is cleared for landing on runway " + runway_number + runway_direction); System.out.println("Flight " + flight_num + " has arrived. The runway is now clear."); System.out.println("===========>\n"); // set the turn for takeoff turn = 0; C.signalAll(); } finally { L.unlock(); } }
/** ロック開放後同一カテゴリとキーでロック取得可能. */ @Test public void ロック開放後同一カテゴリとキーでロック取得可能() { Lock lock = LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null); lock.release(); Lock lock2 = LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null); assertNotNull(lock2); lock2.release(); }
/** Handle the timeout of a previous lock mapped to this key */ protected void handleLockExpiry(Object key, Lockable lock) { LOG.expired(key); long ts = getInternalRegion().nextTimestamp() + getInternalRegion().getTimeout(); // create new lock that times out immediately Lock newLock = new Lock(ts, uuid, nextLockId.getAndIncrement(), null); newLock.unlock(ts); getInternalRegion().put(key, newLock); }
/* * @return true if this site has given such a lock, @testLock */ public boolean isActiveLockExist(Lock testLock) { for (Lock lock : this.activeLocks) { if (lock.isEqual(testLock)) { return true; } } return false; }
public void release() { lock.lock(); try { if (counter > 0) --counter; } finally { lock.unlock(); } }
/* Termina a sessão de um utilizador */ public void logout(String nick) { lock.lock(); try { this.users.get(nick).setAtivo(false); } finally { lock.unlock(); } }
/** Test ensureValid returns true after acquire */ public void testValidAfterAcquire() throws IOException { Path tempPath = createTempDir(); Directory dir = getDirectory(tempPath); Lock l = dir.obtainLock("commit"); l.ensureValid(); // no exception l.close(); dir.close(); }
/** * Release locks held by the authorization <code>authID</code>. * * <p>(remember that the lock may have expired) * * @param authID Authorization identifing Lock to release * @param transaction Transaction with authorization for lockID * @return <code>true</code> if lock was found and released * @throws IOException If transaction not authorized to release authID * @throws IllegalArgumentException If authID or transaction not provided */ public boolean release(String authID, Transaction transaction) throws IOException { // LOGGER.info("release called on lock: " + authID + ", trans: " // + transaction); if (authID == null) { throw new IllegalArgumentException("lockID required"); } if ((transaction == null) || (transaction == Transaction.AUTO_COMMIT)) { throw new IllegalArgumentException( "Tansaction required (with authorization for " + authID + ")"); } Lock lock; boolean release = false; // This could be done more efficiently, and perhaps cleaner, // but these maps within a map are just nasty. The previous way of // calling iterator.remove() didn't actually remove anything, as it // was only iterating through the values of a map, which I believe // java just copies, so it's immutable. Or perhaps we just moved // through too many iterator layers... for (Iterator i = lockTables.values().iterator(); i.hasNext(); ) { Map fidMap = (Map) i.next(); Set unLockedFids = new HashSet(); for (Iterator j = fidMap.keySet().iterator(); j.hasNext(); ) { String fid = (String) j.next(); lock = (Lock) fidMap.get(fid); // LOGGER.info("checking lock " + lock + ", is match " // + lock.isMatch(authID)); if (lock.isExpired()) { unLockedFids.add(fid); // fidMap.remove(fid); concurrent modification error. } else if (lock.isMatch(authID)) { // LOGGER.info("matches, is authorized: " // + lock.isAuthorized(transaction)); if (lock.isAuthorized(transaction)) { unLockedFids.add(fid); // fidMap.remove(fid); release = true; } else { throw new IOException("Not authorized to release " + lock); } } } for (Iterator k = unLockedFids.iterator(); k.hasNext(); ) { fidMap.remove(k.next()); } } return release; }
/** Handle the timeout of a previous lock mapped to this key */ protected void handleLockExpiry(SessionImplementor session, Object key, Lockable lock) { LOG.info("Cached entry expired : " + key); long ts = getInternalRegion().nextTimestamp() + getInternalRegion().getTimeout(); // create new lock that times out immediately Lock newLock = new Lock(ts, uuid, nextLockId.getAndIncrement(), null); newLock.unlock(ts); getInternalRegion().put(session, key, newLock); }
/** 違うカテゴリであれば同キー名での連続取得が可能. */ @Test public void 違うカテゴリであれば同キー名での連続取得が可能() { Lock lockOData = LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null); Lock lockDav = LockManager.getLock(Lock.CATEGORY_DAV, "aaa", null, null); assertNotNull(lockOData); assertNotNull(lockDav); lockDav.release(); lockOData.release(); }
public void acquire() throws InterruptedException { lock.lock(); try { while (!(counter < permits)) queue.await(); ++counter; } finally { lock.unlock(); } }
/* * * Date By Description * MM/DD/YYYY * ---------- -- ----------- * 11/17/2003 INB Ensure that no <code>Lock</code> is set on an * <code>InterruptedException</code>. Clear the thread on * release of the primary <code>Lock</code>. * 11/12/2003 INB Created. * */ final void lockRead(String locationI) throws java.lang.InterruptedException { boolean grabbed = false; try { try { // Look for an existing read lock. Lock readLock; readLock = (Lock) getReadLocks().find(Thread.currentThread()); if (readLock != null) { // If there is a read lock already, just apply it again. readLock.lock(locationI, true); } else { // If one doesn't exist, create one. readLock = new Lock(this); readLock.lock(locationI, true); // Grab the primary lock before adding the lock to the // door. This ensures that there is no write lock active or // waiting. Release the primary lock after the read lock is // created. grabbed = true; try { getPrimaryLock().grab(locationI, true, false); } catch (java.lang.InterruptedException e) { readLock.unlock(); throw e; } synchronized (getReadLocks()) { getReadLocks().add(readLock); } synchronized (getPrimaryLock()) { getPrimaryLock().release(); if (getPrimaryLock().count == 0) { getPrimaryLock().setThread(null); } grabbed = false; } } } catch (com.rbnb.utility.SortException e) { throw new com.rbnb.compat.InternalError(); } } finally { if (grabbed) { // Release the primary lock if we got it. synchronized (getPrimaryLock()) { getPrimaryLock().release(); if (getPrimaryLock().count == 0) { getPrimaryLock().setThread(null); } } } } }
private void sessionHeartBeat(String id, String sessionId) { Lock lock = locks.get(id); if (lock.getSessionId().equals(sessionId)) { lock.setLastHeartBeat(new Date().getTime()); } else { // who are you?? } }
public void stopSession(String id, String sessionId, PrintWriter writer) { Lock lock = locks.get(id); try { lock.unlock(sessionId); } finally { writer.flush(); } }
public void setDone(boolean b) { try { lock.lock(); done = b; if (!done) cv.signal(); } finally { lock.unlock(); } }
/** Handle the timeout of a previous lock mapped to this key */ protected void handleLockExpiry(Object key, Lockable lock) { logger.trace("handleLockExpiry Key=[{}] Lockable=[{}}]", key, lock); // create new lock that times out immediately final long timeStamp = region.nextTimestamp() + region.getTimeout(); final Lock newLock = new Lock(timeStamp, uuid, nextLockId.getAndIncrement(), null); newLock.unlock(timeStamp); region.put(key, newLock); }