Examples with Lock java.util.concurrent.locks.Lock used on opensource projects

Example 26 with Lock

use of java.util.concurrent.locks.Lock in project tomcat by apache.

the class OperationInfo method getSignature.

/**
     * @return the set of parameters for this operation.
     */
public ParameterInfo[] getSignature() {
    Lock readLock = parametersLock.readLock();
    readLock.lock();
    try {
        return this.parameters;
    } finally {
        readLock.unlock();
    }
}

Example 27 with Lock

use of java.util.concurrent.locks.Lock in project tomcat by apache.

the class OperationInfo method addParameter.

// --------------------------------------------------------- Public Methods
/**
     * Add a new parameter to the set of arguments for this operation.
     *
     * @param parameter The new parameter descriptor
     */
public void addParameter(ParameterInfo parameter) {
    Lock writeLock = parametersLock.writeLock();
    writeLock.lock();
    try {
        ParameterInfo[] results = new ParameterInfo[parameters.length + 1];
        System.arraycopy(parameters, 0, results, 0, parameters.length);
        results[parameters.length] = parameter;
        parameters = results;
        this.info = null;
    } finally {
        writeLock.unlock();
    }
}

Example 28 with Lock

use of java.util.concurrent.locks.Lock in project weave by continuuity.

the class DefaultServiceDiscovered method watchChanges.

@Override
public Cancellable watchChanges(ChangeListener listener, Executor executor) {
    ListenerCaller caller = new ListenerCaller(listener, executor);
    // Add the new listener with a write lock.
    Lock writeLock = callerLock.writeLock();
    writeLock.lock();
    try {
        listenerCallers.add(caller);
    } finally {
        writeLock.unlock();
    }
    // Invoke listener for the first time.
    // Race would happen between this method and the setDiscoverables() method, but it's ok as the contract of
    // adding a new listener is that onChange will be called at least once. The actual changes is already
    // reflected by the atomic reference "discoverables", hence it's consistent.
    caller.invoke();
    return caller;
}

Example 29 with Lock

use of java.util.concurrent.locks.Lock in project weave by continuuity.

the class DefaultServiceDiscovered method setDiscoverables.

void setDiscoverables(Set<Discoverable> discoverables) {
    this.discoverables.set(discoverables);
    // Collect all listeners with a read lock to the listener list.
    List<ListenerCaller> callers = Lists.newArrayList();
    Lock readLock = callerLock.readLock();
    readLock.lock();
    try {
        callers.addAll(listenerCallers);
    } finally {
        readLock.unlock();
    }
    // Invoke listeners.
    for (ListenerCaller caller : callers) {
        caller.invoke();
    }
}

Example 30 with Lock

use of java.util.concurrent.locks.Lock in project che by eclipse.

the class StripedLocks method writeLock.

/**
     * Acquire write lock for provided key.
     */
public Unlocker writeLock(String key) {
    Lock lock = striped.get(key).writeLock();
    lock.lock();
    return new LockUnlocker(lock);
}