Java Lock.unlock方法代码示例

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
/**
 * Adds the given object to the store. Technically this method only adds the object if it does not already exist in
 * the store. If it does this method simply increments the reference count of the object.
 * 
 * @param object the object to add to the store, may be null
 * 
 * @return the index that may be used to later retrieve the object or null if the object was null
 */
public String put(T object) {
    if (object == null) {
        return null;
    }

    Lock writeLock = rwLock.writeLock();
    writeLock.lock();
    try {
        String index = Integer.toString(object.hashCode());

        StoredObjectWrapper objectWrapper = objectStore.get(index);
        if (objectWrapper == null) {
            objectWrapper = new StoredObjectWrapper(object);
            objectStore.put(index, objectWrapper);
        }
        objectWrapper.incremementReferenceCount();

        return index;
    } finally {
        writeLock.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
public final void action(final MapleClient c, final byte mode, final byte type, final int selection) {
    if (mode != -1) {
        final NPCConversationManager cm = cms.get(c);
        if (cm == null || cm.getLastMsg() > -1) {
            return;
        }
        final Lock lock = c.getNPCLock();
        lock.lock();
        try {
            if (cm.pendingDisposal) {
                dispose(c);
            } else {
                c.setClickedNPC();
                cm.getIv().invokeFunction("action", mode, type, selection);
            }
        } catch (final ScriptException | NoSuchMethodException e) {
            System.err.println("Error executing NPC script. NPC ID : " + cm.getNpc() + ":" + e);
            dispose(c);
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
static Writer interruptibleWriterView(final StampedLock sl,
                                      final long timeout,
                                      final TimeUnit unit,
                                      final Phaser gate) {
    return new Writer("InterruptibleWriterView") { public void run() {
        if (gate != null ) toTheStartingGate(gate);
        Lock wl = sl.asWriteLock();
        try {
            if (timeout < 0)
                wl.lockInterruptibly();
            else
                wl.tryLock(timeout, unit);
            stamp(1L);  // got the lock
            check(!sl.isReadLocked());
            check(sl.isWriteLocked());
        } catch (Throwable x) { thrown(x);
        } finally { if (stamp() != 0L) wl.unlock(); } }};
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
/**
 * Return the Realm with which this Container is associated.  If there is
 * no associated Realm, return the Realm associated with our parent
 * Container (if any); otherwise return <code>null</code>.
 */
@Override
public Realm getRealm() {

    Lock l = realmLock.readLock();
    try {
        l.lock();
        if (realm != null)
            return (realm);
        if (parent != null)
            return (parent.getRealm());
        return null;
    } finally {
        l.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
/**
 * Gets a registered object by its index.
 * 
 * @param index the index of an object previously registered, may be null
 * 
 * @return the registered object or null if no object is registered for that index
 */
public T get(String index) {
    if (index == null) {
        return null;
    }

    Lock readLock = rwLock.readLock();
    readLock.lock();
    try {
        StoredObjectWrapper objectWrapper = objectStore.get(index);
        if (objectWrapper != null) {
            return objectWrapper.getObject();
        }

        return null;
    } finally {
        readLock.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
@SneakyThrows
public static <R, E extends Exception> R runWithLock(Lock lock, long maxWaitTime, ReturnableTask<R, E> task) {
    log.info("Try to lock git repository");
    if (lock.tryLock(maxWaitTime, TimeUnit.SECONDS)) {
        log.info("Git repository locked");
        try {
            return task.execute();
        } finally {
            log.info("Try to unlock git repository");
            lock.unlock();
            log.info("Git repository unlocked");
        }
    } else {
        throw new IllegalMonitorStateException("Git repository locked");
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
public void setDescription(String description) {
    Lock l = mBeanInfoLock.writeLock();
    l.lock();
    try {
        this.description = description;
        this.info = null;
    } finally {
        l.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
@Test
public void testWriteLockWriteUnlock() {
  final ReadWriteLock rwl = new CountingReadWriteLock();
  final Lock w = rwl.writeLock();
  w.lock();
  w.unlock();
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
public void setName(String name) {
    Lock l = mBeanInfoLock.writeLock();
    l.lock();
    try {
        this.name = name;
        this.info = null;
    } finally {
        l.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
@VisibleForTesting
void incrementBy(long offset, Instant startTimestamp, ImmutableList<String> labelValues) {
  Lock lock = valueLocks.get(labelValues);
  lock.lock();

  try {
    values.addAndGet(labelValues, offset);
    valueStartTimestamps.putIfAbsent(labelValues, startTimestamp);
  } finally {
    lock.unlock();
  }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
@Override
public void onOpen(WebSocketConnection client) {
    Lock lock = poolLock.writeLock();
    lock.lock();
    try {
        pool.add(client);
        if (latestStatic != null) client.send(latestStatic);
        if (latestDynamic != null) client.send(latestDynamic);
        System.out.println(String.format("[ MONITOR ] %d viewer(s) connected", pool.size()));
    } finally {
        lock.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
/**
 * Adds an obligation handler to the list of registered handlers
 * 
 * This method waits until a write lock is obtained for the set of registered obligation handlers.
 * 
 * @param handler the handler to add to the list of registered handlers.
 */
public void addObligationhandler(BaseObligationHandler handler) {
    if (handler == null) {
        return;
    }

    Lock writeLock = rwLock.writeLock();
    writeLock.lock();
    try {
        obligationHandlers.add(handler);
    } finally {
        writeLock.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
/**
 * Case1: Test for lock()
 */
@Test
public void testLock() {
    // generate lock in a free way, you should specify lock type, target, lease time, lease unit
    Lock lock = lockGenerator.gen("FAKE_LOCK", "A_TARGET", 1, TimeUnit.SECONDS);

    try {
        lock.lock();
        doYourWork();

    } finally {
        // Make sure unlock in the finally code block
        lock.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
protected Realm getRealmInternal() {
    Lock l = realmLock.readLock();
    try {
        l.lock();
        return realm;
    } finally {
        l.unlock();
    }
}
 

import java.util.concurrent.locks.Lock; //导入方法依赖的package包/类
public static <T, R> R withLock(Lock lock, Function<T, R> fun, T in) {
	lock.lock();
	try {
		return fun.apply(in);
	} finally {
		lock.unlock();
	}
}