-
EDU.oswego.cs.dl.util.concurrent.CountDown.acquire()
-
EDU.oswego.cs.dl.util.concurrent.FIFOSemaphore.acquire()
-
EDU.oswego.cs.dl.util.concurrent.Latch.acquire()
-
EDU.oswego.cs.dl.util.concurrent.Mutex.acquire()
-
EDU.oswego.cs.dl.util.concurrent.Semaphore.acquire()
Wait until a permit is available, and take one
-
EDU.oswego.cs.dl.util.concurrent.Sync.acquire()
Wait (possibly forever) until successful passage. Fail only upon interuption. Interruptions always result in `clean' failures. On failure, you can be sure that it has not been acquired, and that no corresponding release should be performed. Conversely, a normal return guarantees that the acquire was successful.
-
anvil.database.ConnectionManager.acquire()
Acquires connection of given type.
@param connectionKey Type of connection
@throws NoConnectionPoolException If connectionKey was null or given pool has not been configured.
@throws CannotReturnPooledConnectionException If connection couldn't be constructed, propably due the acquire timeout.
@return Instance of ConnectionManager
-
com.facebook.presto.jdbc.internal.jetty.io.ByteBufferPool.acquire()
Requests a {@link ByteBuffer} of the given size.
The returned buffer may have a bigger capacity than the size being requested but it will have the limit set to the given size.
@param size the size of the buffer
@param direct whether the buffer must be direct or not
@return the requested buffer
@see #release(ByteBuffer)
-
com.google.code.http4j.ConnectionManager.acquire()
@see #setMaxConnectionsPerHost(int)
@param host
@return connection for {@code host}, blocked util connections for this host is less than max connections per host value.
@throws InterruptedException
@throws IOException
-
com.google.code.http4j.impl.conn.ConnectionPool.acquire()
-
com.google.common.util.concurrent.RateLimiter.acquire()
Acquires the given number of permits from this {@code RateLimiter}, blocking until the request can be granted. Tells the amount of time slept, if any.
This method is equivalent to {@code acquire(1)}.
@return time spent sleeping to enforce rate, in seconds; 0.0 if not rate-limited
@since 16.0 (present in 13.0 with {@code void} return type})
-
com.hazelcast.concurrent.semaphore.Permit.acquire()
-
com.hazelcast.core.ISemaphore.acquire()
Acquires a permit, if one is available and returns immediately, reducing the number of available permits by one.
If no permit is available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:
- Some other thread invokes one of the {@link #release} methods for thissemaphore and the current thread is next to be assigned a permit;
- This ISemaphore instance is destroyed; or
- Some other thread {@linkplain Thread#interrupt interrupts}the current thread.
If the current thread:
- has its interrupted status set on entry to this method; or
- is {@linkplain Thread#interrupt interrupted} while waitingfor a permit,
then {@link InterruptedException} is thrown and the current thread'sinterrupted status is cleared.
@throws InterruptedException if the current thread is interrupted
@throws IllegalStateException if hazelcast instance is shutdown while waiting
-
com.netflix.astyanax.recipes.uniqueness.MultiRowUniquenessConstraint.acquire()
-
com.netflix.curator.framework.recipes.locks.InterProcessMutex.acquire()
-
com.orientechnologies.orient.core.db.document.ODatabaseDocumentPool.acquire()
-
com.ponysdk.core.UIContext.acquire()
-
com.sleepycat.je.latch.Latch.acquire()
Acquire a latch for exclusive/write access.
Wait for the latch if some other thread is holding it. If there are threads waiting for access, they will be granted the latch on a FIFO basis. When the method returns, the latch is held for exclusive access.
@throws EnvironmentFailureException if the latch is already held by thecalling thread.
-
com.sun.cldc.util.Semaphore.acquire()
Acquires a permit from this semaphore, blocking until one is available.
-
com.trendmicro.codi.lock.ZLock.acquire()
-
com.volantis.mcs.repository.lock.Lock.acquire()
Acquire the lock.
This will attempt to acquire the lock on behalf of the specified principal. One of three things will occur.
- The lock was successfully acquired for the principal in which case this method returns true and the owner is set to this principal.
- The lock was acquired by another principal in which case this method returns false and the owner is set to the other principal.
- An error occurred while attempting to access the database. In this case an exception is thrown and the state of the lock is not changed.
@param principal The principal that wants to own the lock.
@return True if the lock was acquired for the specified principal, falseif it was not.
@throws IllegalStateException if the lock is already locked.
-
edu.emory.mathcs.backport.java.util.concurrent.Semaphore.acquire()
Acquires a permit from this semaphore, blocking until one is available, or the thread is {@link Thread#interrupt interrupted}.
Acquires a permit, if one is available and returns immediately, reducing the number of available permits by one.
If no permit is available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
- Some other thread invokes the {@link #release} method for thissemaphore and the current thread is next to be assigned a permit; or
- Some other thread {@link Thread#interrupt interrupts} the currentthread.
If the current thread:
- has its interrupted status set on entry to this method; or
- is {@link Thread#interrupt interrupted} while waitingfor a permit,
then {@link InterruptedException} is thrown and the current thread'sinterrupted status is cleared.
@throws InterruptedException if the current thread is interrupted
@see Thread#interrupt
-
hudson.slaves.WorkspaceList.acquire()
Acquires the given workspace. If necessary, this method blocks until it's made available.
@return The same {@link FilePath} as given to this method.
-
java.util.concurrent.Semaphore.acquire()
Acquires a permit from this semaphore, blocking until one is available, or the thread is {@linkplain Thread#interrupt interrupted}.
Acquires a permit, if one is available and returns immediately, reducing the number of available permits by one.
If no permit is available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
- Some other thread invokes the {@link #release} method for thissemaphore and the current thread is next to be assigned a permit; or
- Some other thread {@linkplain Thread#interrupt interrupts}the current thread.
If the current thread:
- has its interrupted status set on entry to this method; or
- is {@linkplain Thread#interrupt interrupted} while waitingfor a permit,
then {@link InterruptedException} is thrown and the current thread'sinterrupted status is cleared.
@throws InterruptedException if the current thread is interrupted
-
net.sf.ehcache.concurrent.Mutex.acquire()
Wait (possibly forever) until successful passage. Fail only upon interuption. Interruptions always result in `clean' failures. On failure, you can be sure that it has not been acquired, and that no corresponding release should be performed. Conversely, a normal return guarantees that the acquire was successful.
@see Sync#acquire()
-
net.sf.ehcache.constructs.concurrent.Mutex.acquire()
Wait (possibly forever) until successful passage. Fail only upon interuption. Interruptions always result in `clean' failures. On failure, you can be sure that it has not been acquired, and that no corresponding release should be performed. Conversely, a normal return guarantees that the acquire was successful.
@see Sync#acquire()
-
oracle.toplink.essentials.internal.helper.ConcurrencyManager.acquire()
Wait for all threads except the active thread. If the active thread just increament the depth. This should be called before entering a critical section.
-
org.apache.commons.lang3.concurrent.TimedSemaphore.acquire()
Tries to acquire a permit from this semaphore. This method will block if the limit for the current period has already been reached. If {@link #shutdown()} has already been invoked, calling this method willcause an exception. The very first call of this method starts the timer task which monitors the time period set for this {@code TimedSemaphore}. From now on the semaphore is active.
@throws InterruptedException if the thread gets interrupted
@throws IllegalStateException if this semaphore is already shut down
-
org.apache.commons.transaction.locking.GenericLock.acquire()
@see org.apache.commons.transaction.locking.MultiLevelLock#acquire(java.lang.Object,int,boolean,boolean,long)
-
org.apache.commons.transaction.locking.MultiLevelLock.acquire()
Tries to acquire a certain lock level on this lock.
@param ownerId a unique id identifying the entity that wants to acquire a certain lock level on this lock
@param targetLockLevel the lock level to acquire
@param wait true if this method shall block when the desired lock level can not be acquired
@param reentrant true if lock levels of the same entity acquired earlier should not restrict compatibility with the lock level desired now
@param timeoutMSecs if blocking is enabled by the wait parameter this specifies the maximum wait time in milliseconds
@return true if the lock actually was acquired
@throws InterruptedException when the thread waiting on this method is interrupted
-
org.apache.curator.framework.recipes.locks.InterProcessMutex.acquire()
Acquire the mutex - blocking until it's available. Note: the same thread can call acquire re-entrantly. Each call to acquire must be balanced by a call to {@link #release()}
@throws Exception ZK errors, connection interruptions
-
org.apache.curator.framework.recipes.locks.InterProcessSemaphoreMutex.acquire()
-
org.apache.curator.framework.recipes.locks.InterProcessSemaphoreV2.acquire()
Acquire a lease. If no leases are available, this method blocks until either the maximum number of leases is increased or another client/process closes a lease.
The client must close the lease when it is done with it. You should do this in a finally block.
@return the new lease
@throws Exception ZK errors, interruptions, etc.
-
org.apache.hadoop.hbase.InterProcessLock.acquire()
Acquire the lock, waiting indefinitely until the lock is released or the thread is interrupted.
@throws IOException If there is an unrecoverable error releasing the lock
@throws InterruptedException If current thread is interrupted whilewaiting for the lock
-
org.apache.hadoop.hbase.master.TableLockManager.TableLock.acquire()
-
org.apache.jackrabbit.core.util.RepositoryLock.acquire()
Lock the repository home.
@throws RepositoryException if the repository lock can not be acquired
-
org.apache.lucene.facet.taxonomy.SearcherTaxonomyManager.acquire()
-
org.apache.lucene.search.SearcherManager.acquire()
Obtain the current IndexSearcher. You must match every call to acquire with one call to {@link #release}; it's best to do so in a finally clause.
-
org.apache.mina.common.ByteBuffer.acquire()
Increases the internal reference count of this buffer to defer automatic release. You have to invoke {@link #release()} as manyas you invoked this method to release this buffer.
@throws IllegalStateException if you attempt to acquire alreadyreleased buffer.
-
org.apache.qpid.server.message.MessageInstance.acquire()
-
org.apache.qpid.server.queue.QueueEntry.acquire()
-
org.apache.ws.util.lock.Lock.acquire()
DOCUMENT_ME
@throws InterruptedException DOCUMENT_ME
-
org.eclipse.aether.SyncContext.acquire()
-
org.eclipse.core.runtime.jobs.ILock.acquire()
Attempts to acquire this lock. If the lock is in use and the specified delay is greater than zero, the calling thread will block until one of the following happens:
- This lock is available
- The thread is interrupted
- The specified delay has elapsed
While a thread is waiting, locks it already owns may be granted to other threads if necessary to break a deadlock. In this situation, the calling thread may be blocked for longer than the specified delay. On returning from this call, the calling thread will once again have exclusive access to any other locks it owned upon entering the acquire method.
@param delay the number of milliseconds to delay
@return true if the lock was successfully acquired, and false otherwise.
@exception InterruptedException if the thread was interrupted
-
org.eclipse.jetty.io.ByteBufferPool.acquire()
Requests a {@link ByteBuffer} of the given size.
The returned buffer may have a bigger capacity than the size being requested but it will have the limit set to the given size.
@param size the size of the buffer
@param direct whether the buffer must be direct or not
@return the requested buffer
@see #release(ByteBuffer)
-
org.eclipse.persistence.internal.helper.ConcurrencyManager.acquire()
Wait for all threads except the active thread. If the active thread just increment the depth. This should be called before entering a critical section.
-
org.exist.storage.lock.Lock.acquire()
Acquire a lock for read.
@throws LockException
-
org.exoplatform.services.jcr.impl.util.io.SpoolFile.acquire()
-
org.jboss.as.naming.service.BinderService.acquire()
-
org.jboss.cache.DataNode.acquire()
Returns true if a lock is acquired.
@param lock_acquisition_timeout milliseconds to wait
@param lockTypeWrite lock type to use
-
org.jboss.cache.lock.NodeLock.acquire()
-
org.jboss.dna.graph.property.Binary.acquire()
Acquire any resources for this data. This method must be called before any other method on this object.
@see #release()
-
org.jboss.security.plugins.auth.JaasSecurityManagerBase.DomainInfo.acquire()
-
org.jitterbit.util.LockingFile.acquire()
Tries to obtain the lock represented by this file.
@return true iff the lock was acquired successfully; false if the lock isalready held by someone else
-
org.jooq.ConnectionProvider.acquire()
Acquire a connection from the connection lifecycle handler.
This method is called by jOOQ exactly once per execution lifecycle, i.e. per {@link ExecuteContext}. Implementations may freely chose, whether subsequent calls to this method:
- return the same connection instance
- return the same connection instance for the same thread
- return the same connection instance for the same transaction (e.g. a
javax.transaction.UserTransaction) - return a fresh connection instance every time
jOOQ will guarantee that every acquired connection is released through {@link #release(Connection)} exactly once.
@return A connection for the current ExecuteContext.
@throws DataAccessException If anything went wrong while acquiring aconnection
-
org.jooq.impl.DefaultConnectionProvider.acquire()
-
org.locationtech.udig.catalog.ICatalog.acquire()
-
org.locationtech.udig.catalog.IRepository.acquire()
Acquire a service from this repository, using the default ServiceFactory if needed and registering the result.
@param connectionParameters Connection parameters should be recognized by a ServiceExtension
@param monitor Used to track the process of connecting
@return IService
@throws IOException
-
org.locationtech.udig.catalog.IServiceFactory.acquire()
Generate a list of candidate services each with their own connection parameters.
The provided connectionParameters are used as a starting point and may be supplemented with defaults, or user credentials as required.
Please be advised that the services handles returned may already be noted in the local catalog; please use findById to check before blinding throwing in a new service handle.
@param params
@return List of candidate IService handles, list may be empty but is never null
@deprecated Use createService( Map )
-
org.menagerie.latches.spi.ZkSemaphore.acquire()
Acquires a permit from this semaphore, blocking until one is available or this thread is interrupted.
If a permit is immediately available, this method returns immediately, reducing the number of available permits in the semaphore by one.
If no permit is available, then the current thread becomes disabled and lies dormant until one of the following occurs:
- Some other party invokes the {@link #release()} method for this semaphore and the current partyis the next to be assigned a permit
- Some other party leaves the Semaphore abruptly, as in a node failure scenario.
- Some other thread interrupts the current thread
If the current thread:
- has its interrupted status set on entry to this method or
- is interrupted while waiting for a permit
then an InterruptedException is thrown and the current thread's interrupted status is cleared.
@throws InterruptedException if the current thread is interrupted
-
org.ofbiz.service.semaphore.ServiceSemaphore.acquire()
-
org.red5.server.api.so.ISharedObject.acquire()
Prevent shared object from being released. Each call to acquire must be paired with a call to release so the SO isn't held forever. This method basically is a noop for persistent SOs as their data is stored and they can be released without losing their contents.
-
org.rstudio.core.client.Barrier.acquire()
Call at the beginning of an operation.
-
org.sonatype.aether.SyncContext.acquire()
Acquires synchronized access to the specified artifacts and metadatas. The invocation will potentially block until all requested resources can be acquired by the calling thread. Acquiring resources that are already acquired by this synchronization context has no effect. Please also see the class-level documentation for information regarding reentrancy.
@param artifacts The artifacts to acquire, may be {@code null} or empty if none.
@param metadatas The metadatas to acquire, may be {@code null} or empty if none.
-
org.tmatesoft.hg.internal.CompleteRepoLock.acquire()
-
org.tmatesoft.hg.repo.HgRepositoryLock.acquire()
Perform actual locking. Waits for timeout (if specified at construction time) before throwing {@link HgRepositoryLockException} in case lock is not available immediately.
Multiple calls are possible, but corresponding number of {@link #release()} calls shall be made.
@throws HgRepositoryLockException if failed to grab a lock
-
org.voltdb.utils.DBBPool.acquire()
Acquire a byte buffer from the pool that has at least minSize capacity. If the size is greater then the size of this pools allocation a dummy allocation will be done with a heap buffer
@param minSize Minimum capacity in bytes that the ByteBuffer must have
@return A DBBContainer with a ByteBuffer that is at leastthe minimum size requested.
-
org.wiztools.restclient.IGlobalOptions.acquire()
-
org.wiztools.restclient.ProxyConfig.acquire()
-
uk.co.mmscomputing.concurrent.Semaphore.acquire()