Examples of lock()

• ae.sun.java2d.pipe.RenderQueue.lock()
  Locks the queue for read/write access.
• cc.mallet.types.Instance.lock()
• cli.System.IO.FileStream.Lock()
• co.paralleluniverse.strands.concurrent.ReentrantLock.lock()
  Acquires the lock.

  Acquires the lock if it is not held by another strand and returns immediately, setting the lock hold count to one.

  If the current strand already holds the lock then the hold count is incremented by one and the method returns immediately.

  If the lock is held by another strand then the current strand becomes disabled for strand scheduling purposes and lies dormant until the lock has been acquired, at which time the lock hold count is set to one.

• com.alibaba.otter.shared.arbitrate.impl.zookeeper.lock.DistributedLock.lock()
  尝试获取锁操作，阻塞式可被中断
• com.alibaba.otter.shared.arbitrate.impl.zookeeper.lock.DistributedReentrantLock.lock()
• com.aragost.javahg.Repository.lock()
• com.arjuna.ats.arjuna.utils.FileLock.lock()
  @since JTS 2.1.1.
• com.cloud.utils.db.GlobalLock.lock()
• com.cybozu.vmbkp.control.VmArchiveManager.lock()
  Lock wrapper.
• com.cybozu.vmbkp.profile.ProfileAllVm.lock()
• com.dotmarketing.business.RoleAPI.lock()
  @param role @return @throws DotDataException
• com.foreach.common.concurrent.locks.distributed.DistributedLock.lock()
• com.founder.fix.fixflow.core.impl.runtime.TokenEntity.lock()
• com.hazelcast.concurrent.lock.LockStoreImpl.lock()
• com.hazelcast.core.ILock.lock()
  {@inheritDoc}
• com.hazelcast.core.IMap.lock()
  Acquires the lock for the specified key.

  If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.

  You get a lock whether the value is present in the map or not. Other threads (possibly on other systems) would block on their invoke of lock() until the non-existent key is unlocked. If the lock holder introduces the key to the map, the put() operation is not blocked. If a thread not holding a lock on the non-existent key tries to introduce the key while a lock exists on the non-existent key, the put() operation blocks until it is unlocked.

  Scope of the lock is this map only. Acquired lock is only for the key in this map.

  Locks are re-entrant so if the key is locked N times then it should be unlocked N times before another thread can acquire it.

  Warning:

  This method uses hashCode and equals of binary form of the key, not the actual implementations of hashCode and equals defined in key's class. @param key key to lock. @throws NullPointerException if the specified key is null
• com.hazelcast.core.MultiMap.lock()
  Acquires the lock for the specified key.

  If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.

  Scope of the lock is this multimap only. Acquired lock is only for the key in this multimap.

  Locks are re-entrant so if the key is locked N times then it should be unlocked N times before another thread can acquire it.

  Warning:

  This method uses hashCode and equals of binary form of the key, not the actual implementations of hashCode and equals defined in key's class.

  @param key key to lock.
• com.ibm.as400.access.SequentialFile.lock()
• com.mobixess.jodb.core.io.IOTicket.lock()
• com.netflix.exhibitor.core.config.PseudoLock.lock()
  Acquire the lock, blocking at most maxWait until it is acquired @param log the logger @param maxWait max time to wait @param unit time unit @return true if the lock was acquired @throws Exception errors
• com.orientechnologies.orient.core.record.ORecord.lock()
• com.persistit.Exchange.lock()
  Invoke {@link #lock(Key,long)} with the current key and a defaulttimeout value of {@value com.persistit.SharedResource#DEFAULT_MAX_WAIT_TIME} milliseconds. @throws PersistitException
• com.saasovation.common.port.adapter.persistence.leveldb.LevelDBUnitOfWork.lock()
• com.shop.util.chunked.ChunkedByteArray.lock()
  Locks this array. Any attempt to modify it will throw {@link IllegalAccessError}
• com.sleepycat.je.txn.Locker.lock()
  Request a blocking or non-blocking lock of the given type on the given LSN. @param lsn is the node to lock. @param lockType is the type of lock to request. @param noWait is true to override the defaultNoWait setting. If true,or if defaultNoWait is true, throws LockNotAvailableException if the lock cannot be granted without waiting. @param database is the database containing lsn. @throws LockNotAvailableException if a non-blocking lock was denied. @throws LockConflictException if a blocking lock could not be acquired.
• com.sleepycat.je.txn.Txn.lock()
  Gets a lock on this nodeId and, if it is a write lock, saves an abort LSN. Caller will set the abortLsn later, after the write lock has been obtained.
• com.sun.messaging.jmq.jmsserver.core.PacketReference.lock()
  only called by the ref creator before put into MT access
• com.taobao.datasource.tm.TransactionLocal.lock()
  Lock the TransactionLocal using the current transaction

  WARN: The current implemention just "locks the transactions" @throws IllegalStateException if the transaction is not active @throws InterruptedException if the thread is interrupted

• com.twitter.common.zookeeper.DistributedLock.lock()
• com.twitter.common.zookeeper.DistributedLockImpl.lock()
• com.uic.ase.proj.xbn.array.AOSLCreator.lock()
• com.vaadin.server.VaadinSession.lock()
  it is safe to update the UI. // UI.getCurrent can also be used myUI.getContent().setCaption("Changed safely"); } }); If you for whatever reason want to do locking manually, you should do it like:

   session.lock(); try { doSomething(); } finally { session.unlock(); } 

  This method will block until the lock can be retrieved.

  {@link #getLockInstance()} can be used if more control over the lockingis required. @see #unlock() @see #getLockInstance() @see #hasLock()

• com.webobjects.eoaccess.EODatabaseContext.lock()
• com.webobjects.eocontrol.EOEditingContext.lock()
• com.webobjects.eocontrol.EOObjectStore.lock()
• com.webobjects.eocontrol.EOObjectStoreCoordinator.lock()
• com.webobjects.eocontrol.EOSharedEditingContext.lock()
• edu.emory.mathcs.backport.java.util.concurrent.locks.Lock.lock()
  Acquires the lock.

  If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.

  Implementation Considerations

  A Lock implementation may be able to detect erroneous use of the lock, such as an invocation that would cause deadlock, and may throw an (unchecked) exception in such circumstances. The circumstances and the exception type must be documented by that Lock implementation.

• edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock.lock()
  Acquires the lock.

  Acquires the lock if it is not held by another thread and returns immediately, setting the lock hold count to one.

  If the current thread already holds the lock then the hold count is incremented by one and the method returns immediately.

  If the lock is held by another thread then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired, at which time the lock hold count is set to one.

• edu.vt.rt.hyflow.benchmark.rmi.list.INode.lock()
• er.extensions.eof.ERXEC.lock()
  Overridden to emit log messages and push this instance to the locked editing contexts in this thread.
• etch.bindings.java.msg.Type.lock()
  Locks the fields for this type.
• java.nio.channels.FileChannel.lock()
  Obtain an exclusive lock on this file.

  This is a convenience method for acquiring a maximum length lock on a file. It is equivalent to:

   fileChannel.lock(0L, Long.MAX_VALUE, false) 

  @return the lock object representing the locked file area. @throws ClosedChannelException the file channel is closed. @throws NonWritableChannelException this channel was not opened for writing. @throws OverlappingFileLockException Either a lock is already held that overlaps this lock request, or another thread is waiting to acquire a lock that will overlap with this request. @throws FileLockInterruptionException The calling thread was interrupted while waiting to acquire the lock. @throws AsynchronousCloseException The channel was closed while the calling thread was waiting to acquire the lock. @throws IOException some other problem occured obtaining the requested lock.
• java.util.concurrent.locks.Lock.lock()
  Acquires the lock.

  If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.

  Implementation Considerations

  A {@code Lock} implementation may be able to detect erroneous useof the lock, such as an invocation that would cause deadlock, and may throw an (unchecked) exception in such circumstances. The circumstances and the exception type must be documented by that {@code Lock} implementation.

• java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock.lock()
• java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock.lock()
• javax.jcr.Node.lock()
  Lock the node.
• javax.jcr.lock.LockManager.lock()
• javax.persistence.EntityManager.lock()
  Set the lock mode for an entity object contained in the persistence context. @param entity @param lockMode @throws IllegalStateException if this EntityManager has been closed @throws PersistenceException if an unsupported lock callis made @throws IllegalArgumentException if the instance is notan entity or is a detached entity @throws TransactionRequiredException if there is notransaction
• mil.nga.giat.geowave.vector.plugin.lock.LockingManagement.lock()
  Lock a feature for a provided transaction. This is typically used for modifications (updates). @param transaction @param featureID
• mil.nga.giat.geowave.vector.plugin.lock.MemoryLockManager.lock()
• net.east301.keyring.util.FileBasedLock.lock()
  Lock
• net.sf.ehcache.concurrent.Sync.lock()
  Acquire lock of LockType.READ or WRITE @param type the lock type to acquire
• net.sf.ehcache.transaction.SoftLock.lock()
  Lock the soft lock
• net.sourceforge.ganttproject.gui.options.model.EnumerationOption.lock()
• net.sourceforge.ganttproject.gui.options.model.GPOption.lock()
• net.sourceforge.ganttproject.gui.options.model.GPOptionGroup.lock()
• net.sourceforge.pebble.service.StaticPageService.lock()
  Locks a given static page. @param staticPage the static page to lock @return true if the page could be locked, false otherwise
• net.timewalker.ffmq3.storage.message.MessageStore.lock()
  Lock the message associated to a given handle @throws JMSException on storage error or invalid handle
• nexj.core.rpc.file.ra.LockableFile.lock()
  Locks the file. Returns immediately if no incompatible intra-process or inter-process locks are held on the file. If incompatible locks are already held on the file, then it will block. If it is interrupted while blocking, it will return false. @param bShared True if the lock being requested is a shared lock; false otherwise. @return True if the lock was acquired successfully; false if it wasinterrupted while blocking.
• nexj.core.util.lock.Lock.lock()
  Constructs the session lock. @param nTimeout The timeout in milliseconds.
• org.apache.blur.zookeeper.ZooKeeperLockManager.lock()
• org.apache.catalina.tribes.tipis.ReplicatedMapEntry.lock()
  Lock during serialization
• org.apache.cocoon.components.pipeline.impl.PipelineComponentInfo.lock()
  Lock this component info object at the end of processor building to prevent any further changes.
• org.apache.commons.configuration.sync.SynchronizerSupport.lock()
  access to syncSupport } finally { syncSupport.unlock(LockMode.READ); } Note: Always use this method for obtaining a lock rather than accessing the object's {@link Synchronizer} directly. An implementationmay perform additional actions which are not executed when only interacting with the {@code Synchronizer}. @param mode the {@code LockMode}
• org.apache.commons.configuration2.sync.SynchronizerSupport.lock()
  access to syncSupport } finally { syncSupport.unlock(LockMode.READ); } Note: Always use this method for obtaining a lock rather than accessing the object's {@link Synchronizer} directly. An implementationmay perform additional actions which are not executed when only interacting with the {@code Synchronizer}. @param mode the {@code LockMode}
• org.apache.etch.bindings.java.msg.Type.lock()
  Locks the fields for this type.
• org.apache.geronimo.management.geronimo.CertificationAuthority.lock()
  This method locks the CA.
• org.apache.hadoop.hdfs.server.common.Storage.StorageDirectory.lock()
• org.apache.hadoop.hive.ql.lockmgr.HiveLockManager.lock()
  @param key object to be locked @param mode mode of the lock (SHARED/EXCLUSIVE) @param keepAlive if the lock needs to be persisted after the statement
• org.apache.harmony.awt.nativebridge.Int16Pointer.lock()
• org.apache.harmony.awt.nativebridge.Int32Pointer.lock()
• org.apache.harmony.awt.nativebridge.Int8Pointer.lock()
• org.apache.hcatalog.hbase.snapshot.lock.WriteLock.lock()
  Attempts to acquire the exclusive write lock returning whether or not it was acquired. Note that the exclusive lock may be acquired some time later after this method has been invoked due to the current lock owner going away.
• org.apache.helix.lock.HelixLock.lock()
  Synchronously acquire a lock @return true if the lock was acquired, false if could not be acquired
• org.apache.jackrabbit.api.jsr283.lock.LockManager.lock()

  Places a lock on the node at absPath. If successful, the node is said to hold the lock.

  If isDeep is true then the lock applies to the specified node and all its descendant nodes; if false, the lock applies only to the specified node. On a successful lock, the jcr:isDeep property of the locked node is set to this value.

  If isSessionScoped is true then this lock will expire upon the expiration of the current session (either through an automatic or explicit Session.logout); if false, this lock does not expire until it is explicitly unlocked, it times out, or it is automatically unlocked due to a implementation-specific limitation.

  The timeout parameter specifies the number of seconds until the lock times out (if it is not refreshed with Lock.refresh in the meantime). An implementation may use this information as a hint or ignore it altogether. Clients can discover the actual timeout by inspecting the returned Lock object.

  The ownerInfo parameter can be used to pass a string holding owner information relevant to the client. An implementation may either use or ignore this parameter. If it uses the parameter it must set the jcr:lockOwner property of the locked node to this value and return this value on Lock.getLockOwner. If it ignores this parameter the jcr:lockOwner property (and the value returned by Lock.getLockOwner) is set to either the value returned by Session.getUserID of the owning session or an implementation-specific string identifying the owner.

  The method returns a Lock object representing the new lock. If the lock is open-scoped the returned lock will include a lock token. The lock token is also automatically added to the set of lock tokens held by the current session.

  The addition or change of the properties jcr:isDeep and jcr:lockOwner are persisted immediately; there is no need to call save.

  It is possible to lock a node even if it is checked-in.

  If this node is not of mixin node type mix:lockable then an LockException is thrown.

  If this node is already locked (either because it holds a lock or a lock above it applies to it), a LockException is thrown.

  If isDeep is true and a descendant node of this node already holds a lock, then a LockException is thrown.

  If this node does not have a persistent state (has never been saved or otherwise persisted), a LockException is thrown.

  If the current session does not have sufficient privileges to place the lock, an AccessDeniedException is thrown.

  An UnsupportedRepositoryOperationException is thrown if this implementation does not support locking.

  An InvalidItemStateException is thrown if this node has pending unsaved changes.

  A RepositoryException is thrown if another error occurs. @param absPath absolute path of node to be locked @param isDeep if true this lock will apply to this node and all its descendants; iffalse, it applies only to this node. @param isSessionScoped if true, this lock expires with the current session; if false itexpires when explicitly or automatically unlocked for some other reason. @param timeoutHint desired lock timeout in seconds (servers are free toignore this value); specify {@link Long#MAX_VALUE} for no timeout. @param ownerInfo a string containing owner informationsupplied by the client; servers are free to ignore this value. @return A Lock object containing a lock token. @throws UnsupportedRepositoryOperationException if this implementation does not support locking. @throws LockException if this node is not mix:lockable or this node is already locked orisDeep is true and a descendant node of this node already holds a lock. @throws AccessDeniedException if this session does not have permission to lock this node. @throws InvalidItemStateException if this node has pending unsaved changes. @throws RepositoryException if another error occurs.

• org.apache.jackrabbit.core.lock.LockManager.lock()
  Lock a node. Checks whether the node is not locked and then returns a lock object for this node. @param node node @param isDeep whether the lock applies to this node only @param isSessionScoped whether the lock is session scoped @return lock object @throws LockException if this node already is locked, or some descendantnode is locked and isDeep is true @see javax.jcr.Node#lock
• org.apache.jackrabbit.ocm.manager.ObjectContentManager.lock()
  Lock object saved on @param path . @param path path to saved object. @param isDeep is lock deep? See JCR spec: 8.4.3 Shallow and Deep Locks @param isSessionScoped is lock session scoped? See JCR spec: Session-scoped and Open-scoped Locks @return lock - Wrapper object for a JCR lock @throws LockedException if path is locked (cannot lock same path again)
• org.apache.lenya.cms.repository.Node.lock()
  Locks the node. @throws RepositoryException if an error occurs.
• org.apache.lucene.index.DocumentsWriterPerThreadPool.ThreadState.lock()
• org.apache.maven.index.fs.Locker.lock()
  Acquires exclusive lock on specified directory. Most implementation will use marker file and will only work if all processes that require access to the directory use the same filename.
• org.apache.maven.scm.provider.integrity.Sandbox.lock()
  Executes a 'si lock' command using the relativeName of the file @param memberFile Full path to the member's current sandbox location @param relativeName Relative path from the nearest subproject or project @return MKS API Response object @throws APIException
• org.apache.ojb.odmg.TransactionExt.lock()
• org.apache.ojb.odmg.TransactionImpl.lock()
  Upgrade the lock on the given object to the given lock mode. The call has no effect if the object's current lock is already at or above that level of lock mode. @param obj object to acquire a lock on. @param lockMode lock mode to acquire. The lock modesare READ , UPGRADE , and WRITE . @exception LockNotGrantedException Description of Exception
• org.apache.slide.lock.Lock.lock()
  Put a lock on a subject. @param slideToken The token to access slide. @param lockToken Object containing all the lock information @exception ServiceAccessException Low level service access exception @exception ObjectNotFoundException One of the objects referenced in the lock token were not found @exception ObjectIsAlreadyLockedException Object is already locked with an incompatible lock token @exception AccessDeniedException Insufficient credentials to allow object locking
• org.apache.wicket.security.hive.BasicHive.lock()
  Locks this hive. No changes are allowed anymore. After this {@link #isLocked()} will return true;
• org.apache.zookeeper.recipes.lock.WriteLock.lock()
  Attempts to acquire the exclusive write lock returning whether or not it was acquired. Note that the exclusive lock may be acquired some time later after this method has been invoked due to the current lock owner going away.
• org.codehaus.groovy.reflection.ClassInfo.lock()
• org.datanucleus.ManagedConnection.lock()
  lock the access to this ManagedConnection
• org.datanucleus.store.connection.ManagedConnection.lock()
• org.drools.common.InternalRuleBase.lock()
• org.drools.core.common.InternalRuleBase.lock()
• org.drools.core.impl.InternalKnowledgeBase.lock()
• org.drools.persistence.PersistenceContext.lock()
  This method pessimistically locks the {@link WorkItemInfo} instance @param sessionInfo The persistent representation of a {@link WorkItem}
• org.dyno.visual.swing.designer.VisualDesigner.lock()
• org.eclipse.ecf.docshare2.DocShare.lock()
• org.eclipse.jgit.dircache.DirCache.lock()
  Create a new in-core index representation, lock it, and read from disk.

  The new index will be locked and then read before it is returned to the caller. Read failures are reported as exceptions and therefore prevent the method from returning a partially populated index. On read failure, the lock is released. @param indexLocation location of the index file on disk. @param fs the file system abstraction which will be necessary to perform certain file system operations. @return a cache representing the contents of the specified index file (ifit exists) or an empty cache if the file does not exist. @throws IOException the index file is present but could not be read, or the lock could not be obtained. @throws CorruptObjectException the index file is using a format or extension that this library does not support.

• org.eclipse.jgit.internal.storage.file.LockFile.lock()
  Try to establish the lock. @return true if the lock is now held by the caller; false if it is heldby someone else. @throws IOException the temporary output file could not be created. The caller does not hold the lock.
• org.eclipse.jgit.storage.file.LockFile.lock()
  Try to establish the lock. @return true if the lock is now held by the caller; false if it is heldby someone else. @throws IOException the temporary output file could not be created. The caller does not hold the lock.
• org.eclipse.jgit.storage.file.PackLock.lock()
  Create the pack-*.keep file, with the given message. @param msg message to store in the file. @return true if the keep file was successfully written; false otherwise. @throws IOException the keep file could not be written.
• org.eclipse.orion.server.core.resources.FileLocker.lock()
  Try and lock the file. This method blocks until it gets the lock.

  The caller must use {@link #release()} to release the lock.

  @return true if it acquired the lock, false otherwise. @throws IOException
• org.eclipse.osgi.service.datalocation.Location.lock()
  Attempts to lock this location with a canonical locking mechanism and return true if the lock could be acquired. Not all locations can be locked.

  Locking a location is advisory only. That is, it does not prevent other applications from modifying the same location

  @return true if the lock could be acquired; otherwise false is returned @exception IOException if there was an unexpected problem while acquiring the lock
• org.exist.dom.DocumentSet.lock()
• org.exist.versioning.svn.WorkingCopy.lock()
• org.exist.versioning.svn.internal.wc.admin.SVNAdminArea.lock()
• org.exoplatform.services.jcr.cluster.JCRWebdavConnection.lock()
• org.exoplatform.services.jcr.impl.core.NodeImpl.lock()
  {@inheritDoc}
• org.gatein.cdi.contexts.beanstore.BeanStore.lock()
• org.geoserver.platform.resource.Resource.lock()
  Acquires an exclusive lock on resource content. @return an exclusive lock
• org.gradle.api.internal.initialization.ClassLoaderScope.lock()
  Signal that no more modifications are to come, allowing the structure to be optimised if possible.
• org.h2.store.FileLock.lock()
  Lock the file if possible. A file may only be locked once. @param fileLockMethod the file locking method to use @throws DbException if locking was not successful
• org.h2.table.Table.lock()
  Lock the table for the given session. This method waits until the lock is granted. @param session the session @param exclusive true for write locks, false for read locks @param force lock even in the MVCC mode @throws DbException if a lock timeout occurred
• org.hibernate.Session.lock()
  Obtain the specified lock level upon the given object. This may be used to perform a version check (LockMode.READ), to upgrade to a pessimistic lock (LockMode.UPGRADE), or to simply reassociate a transient instance with a session (LockMode.NONE). This operation cascades to associated instances if the association is mapped with cascade="lock". @param object a persistent or transient instance @param lockMode the lock level @throws HibernateException
• org.hibernate.cache.CacheConcurrencyStrategy.lock()
  We are going to attempt to update/delete the keyed object. This method is used by "asynchronous" concurrency strategies.

  The returned object must be passed back to release(), to release the lock. Concurrency strategies which do not support client-visible locks may silently return null. @param key @param version @throws CacheException

• org.hibernate.cache.ReadWriteCache.lock()
  Stop any other transactions reading or writing this item to/from the cache. Send them straight to the database instead. (The lock does time out eventually.) This implementation tracks concurrent locks of transactions which simultaneously attempt to write to an item.
• org.hibernate.classic.Session.lock()
• org.hibernate.persister.entity.EntityPersister.lock()
  Do a version check (optional operation)
• org.hornetq.core.paging.cursor.PageCache.lock()
  When the cache is being created, We need to first read the files before other threads can get messages from this.
• org.infinispan.AdvancedCache.lock()
• org.jboss.as.ejb3.timerservice.TimerImpl.lock()
• org.jboss.as.ejb3.tx.OwnableReentrantLock.lock()
• org.jboss.cache.lock.LockManager.lock()
  Acquires a lock of type lockType, for a given owner, on a specific Node in the cache, denoted by fqn. This method will try for {@link org.jboss.cache.config.Configuration#getLockAcquisitionTimeout()} milliseconds and give up if it is unable to acquire the required lock. @param fqn Fqn to lock @param lockType type of lock to acquire @param owner owner to acquire the lock for @return true if the lock was acquired, false otherwise.
• org.jboss.ejb.EnterpriseContext.lock()
• org.jboss.ejb.EntityEnterpriseContext.lock()
• org.jboss.ha.framework.server.lock.AbstractClusterLockSupport.lock()
• org.jboss.ha.framework.server.lock.NonGloballyExclusiveClusterLockSupport.lock()
• org.jboss.jca.core.spi.transaction.local.TransactionLocal.lock()
  Lock the TransactionLocal using the current transaction

  WARN: The current implemention just "locks the transactions" @throws IllegalStateException if the transaction is not active @throws InterruptedException if the thread is interrupted

• org.jboss.tm.TransactionLocal.lock()
  Lock the TransactionLocal using the current transaction

  WARN: The current implemention just "locks the transactions" @throws IllegalStateException if the transaction is not active @throws InterruptedException if the thread is interrupted

• org.jboss.weld.context.beanstore.BeanStore.lock()
  Gets a creation lock for the given bean id. @param id The bean id @return A handle that must be used to unlock the bean
• org.jbpm.examples.doorjava.Door.lock()
• org.jbpm.graph.exe.Token.lock()
  locks a process instance for further execution. A locked token cannot continue execution. This is a non-persistent operation. This is used to prevent tokens being propagated during the execution of actions. @see #unlock(String)
• org.jitterbit.integration.client.runtime.lock.ApplicationInstanceLock.lock()
  Tries to obtain the application instance lock. @param args the startup arguments that were passed to the new application instance. The lock implementation can use these arguments to determine a course of action should the lock already be held by another instance, e.g. passing the arguments to the running instance. @return true if the lock was obtained, false if another instance ofthe application is holding the lock
• org.jpox.ManagedConnection.lock()
  lock the access to this ManagedConnection
• org.jruby.util.io.OpenFile.lock()
• org.kiji.schema.util.Lock.lock()
  Unconditionally acquires the lock. @throws IOException on I/O error.
• org.lealone.dbobject.table.Table.lock()
  Lock the table for the given session. This method waits until the lock is granted. @param session the session @param exclusive true for write locks, false for read locks @param force lock even in the MVCC mode @throws DbException if a lock timeout occurred
• org.locationtech.udig.project.internal.impl.SynchronizedEList.lock()
  Lock this list.
• org.locationtech.udig.tools.edit.support.TestHandler.lock()
• org.menagerie.locks.ReentrantZkLock.lock()
  Acquires the lock.

  If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock as been acquired.

  Note: If the ZooKeeper session expires while this method is waiting, a {@link RuntimeException} will be thrown. @inheritDoc @throws RuntimeException wrapping:

  • {@link org.apache.zookeeper.KeeperException} if the ZooKeeper serverencounters a problem
  • {@link InterruptedException} if there is a communication problem betweenthe ZooKeeper client and server
  • If the ZooKeeper session expires

  @see java.util.concurrent.locks.Lock#lock()
• org.modeshape.jcr.cache.MutableCachedNode.lock()
  Lock this node. @param sessionScoped true if the lock should be limited in scope to the lifetime of the session, or false otherwise
• org.netbeans.modules.editor.indent.api.Reformat.lock()
• org.odmg.Transaction.lock()
  Upgrade the lock on the given object to the given lock mode. The call has no effect if the object's current lock is already at or above that level of lock mode. @param obj The object to acquire a lock on. @param lockMode The lock mode to acquire. The lock modes are READ,UPGRADE, and WRITE. @exception LockNotGrantedException Is thrown if the given lock mode could not be acquired.
• org.openide.filesystems.FileObject.lock()
• org.openstreetmap.osmosis.core.util.FileBasedLock.lock()
  Obtain an exclusive lock. This will fail if another thread or process already has a lock.
• org.pentaho.reporting.engine.classic.core.layout.model.context.BoxDefinition.lock()
• org.photovault.dbhelper.ODMGXAWrapper.lock()
• org.redisson.core.RLock.lock()
  Acquires the lock.

  If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired. If the lock is acquired, it is held until unlock is invoked, or until leaseTime milliseconds have passed since the lock was granted - whichever comes first. @param leaseTime the maximum time to hold the lock after granting it, before automatically releasing it if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked. @param unit the time unit of the {@code leaseTime} argument

• org.sonatype.nexus.proxy.item.RepositoryItemUidLock.lock()
  Locks this UID for a given action. Will perform lock upgrade is needed (read -> write). Lock upgrade (ie. create action locking happens after read action already locked) happens, but does not happen atomically! Lock upgrade is actually release all (if any) read lock and then acquire write lock. Once you have exclusive lock, then only you can be sure for unique access.
• org.springframework.aop.framework.Lockable.lock()
• org.springframework.webflow.conversation.Conversation.lock()
  Lock this conversation. May block until the lock is available, if someone else has acquired the lock. @throws ConversationLockException if the lock could not be acquired
• org.springframework.webflow.execution.repository.FlowExecutionLock.lock()
  Acquire the flow execution lock. This method will block until the lock becomes available for acquisition.
• org.terasology.world.chunks.Chunk.lock()
• org.terasology.world.chunks.CoreChunk.lock()
• org.tmatesoft.sqljet.core.internal.table.ISqlJetBtreeSchemaTable.lock()
• org.tmatesoft.svn.core.internal.wc.admin.SVNAdminArea.lock()
• org.tmatesoft.svn.core.io.SVNRepository.lock()
  Locks path(s) at definite revision(s).

  Note that locking is never anonymous, so any server implementing this function will have to "pull" a username from the client, if it hasn't done so already.

  Each path to be locked is handled with the provided handler. If a path was successfully locked, the handler's {@link ISVNLockHandler#handleLock(String,SVNLock,SVNErrorMessage) handleLock()}is called that receives the path and either a lock object (representing the lock that was set on the path) or an error exception, if locking failed for that path.

  If any path is already locked by a different user and the force flag is false, then this call fails with throwing an SVNException. But if force is true, then the existing lock(s) will be "stolen" anyway, even if the user name does not match the current lock's owner.

  Paths can be both relative to the location of this driver and absolute to the repository root (starting with "/"). @param pathsToRevisions a map which keys are paths and values are revision numbers (as Longs); paths are strings and revision numbers are Long objects @param comment a comment string for the lock (optional) @param force true if the file is to be locked in any way (even if it's already locked by someone else) @param handler if not null, the lockhandler is invoked on each path to be locked @throws SVNException in the following cases:

  • force is false and a path is already locked by someone else
  • a revision of a path is less than its last changed revision
  • a path does not exist in the latest revision
  • a failure occured while connecting to a repository
  • the user authentication failed (see {@link org.tmatesoft.svn.core.SVNAuthenticationException})

  @see #unlock(Map,boolean,ISVNLockHandler) @see #getLocks(String) @see #getLock(String) @see org.tmatesoft.svn.core.SVNLock @since SVN 1.2
• org.uberfire.commons.cluster.ClusterService.lock()
• org.uberfire.commons.lock.impl.ThreadLockServiceImpl.lock()
• org.unidal.webres.resource.spi.IResourceRegistry.lock()
• org.w3c.tools.resources.DummyResourceReference.lock()
  Lock the refered resource in memory. @return A real pointer to the resource. @exception InvalidResourceException is thrown if the resource isinvalid (has been deleted or everything else).
• org.w3c.tools.resources.ResourceReference.lock()
  Lock the refered resource in memory. @return A real pointer to the resource. @exception InvalidResourceException is thrown if the resource isinvalid (has been deleted or everything else).
• org.wicketstuff.security.hive.BasicHive.lock()
  Locks this hive. No changes are allowed anymore. After this {@link #isLocked()} will returntrue;
• org.xtreemfs.babudb.log.DiskLogger.lock()
• pdp.scrabble.ihm.PlayerPanel.lock()
  Lock playerPanel.
• quicktime.std.image.ImageDescription.lock()
• quicktime.std.music.MusicData.lock()
• quicktime.util.QTHandle.lock()
• simpleserver.config.data.Chests.Chest.lock()
• sun.awt.datatransfer.ToolkitThreadBlockedHandler.lock()
• sun.java2d.pipe.RenderQueue.lock()
  Locks the queue for read/write access.
• test.aop.Lockable.lock()
• test.mixin.Lockable.lock()
• xbird.util.concurrent.lock.ILock.lock()

Examples of sun.java2d.pipe.RenderQueue.lock()

Examples of test.aop.Lockable.lock()

Examples of test.mixin.Lockable.lock()

Examples of xbird.util.concurrent.lock.ILock.lock()