Java LockAcquisitionException类代码示例

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private String lock(final QName lockName, final long timeToLive, boolean expectSuccess)
{
    try
    {
        String token = lock(lockName, timeToLive);
        if (!expectSuccess)
        {
            fail("Expected lock " + lockName + " to have been denied");
        }
        return token;
    }
    catch (LockAcquisitionException e)
    {
        if (expectSuccess)
        {
            // oops
            throw new RuntimeException("Expected to get lock " + lockName + " with TTL of " + timeToLive, e);
        }
        else
        {
            return null;
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private void refresh(final QName lockName, final String lockToken, final long timeToLive, boolean expectSuccess)
{
    RetryingTransactionCallback<Boolean> callback = new RetryingTransactionCallback<Boolean>()
    {
        public Boolean execute() throws Throwable
        {
            lockDAO.refreshLock(lockName, lockToken, timeToLive);
            return Boolean.TRUE;
        }
    };
    try
    {
        txnHelper.doInTransaction(callback);
        if (!expectSuccess)
        {
            fail("Expected to have failed to refresh lock " + lockName);
        }
    }
    catch (LockAcquisitionException e)
    {
        if (expectSuccess)
        {
            throw new RuntimeException("Expected to have refreshed lock " + lockName, e);
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private void release(final QName lockName, final String lockToken, boolean expectSuccess)
{
    RetryingTransactionCallback<Boolean> callback = new RetryingTransactionCallback<Boolean>()
    {
        public Boolean execute() throws Throwable
        {
            lockDAO.releaseLock(lockName, lockToken, false);
            return Boolean.TRUE;
        }
    };
    try
    {
        txnHelper.doInTransaction(callback);
        if (!expectSuccess)
        {
            fail("Expected to have failed to release lock " + lockName);
        }
    }
    catch (LockAcquisitionException e)
    {
        if (expectSuccess)
        {
            throw new RuntimeException("Expected to have released lock " + lockName, e);
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private void refreshExecutorLock(String lockToken)
{
    if (lockToken != null)
    {
        try
        {
            alfrescoJobExecutor.getJobLockService().refreshLock(lockToken, LOCK_QNAME, jobLockTTL);

            if (logger.isTraceEnabled())
            {
                logger.trace(Thread.currentThread().getName() + " refreshed lock token: " + lockToken);
            }
        }
        catch (LockAcquisitionException e)
        {
            if (logger.isTraceEnabled())
            {
                logger.trace("Failed to refresh Alfresco Job Executor lock  - may no longer exist (" + lockToken
                        + ")");
            }
            throw e;
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private void releaseExecutorLock(String lockToken)
{
    if (lockToken != null)
    {
        try
        {
            alfrescoJobExecutor.getJobLockService().releaseLock(lockToken, LOCK_QNAME);

            if (logger.isTraceEnabled())
            {
                logger.trace(Thread.currentThread().getName() + " released lock token: " + lockToken);
            }
        }
        catch (LockAcquisitionException e)
        {
            if (logger.isTraceEnabled())
            {
                logger.trace("Failed to release Alfresco Job Executor lock - may no longer exist (" + lockToken
                        + ")");
            }
            throw e;
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
/**
 * Attempts to get the lock. If the lock couldn't be taken, then <tt>null</tt> is returned.
 * 
 * @return Returns the lock token or <tt>null</tt>
 */
protected String getLock(long time)
{
    try
    {
        return jobLockService.getLock(LOCK, time);
    }
    catch (LockAcquisitionException e)
    {
        return null;
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private synchronized String acquireLock(LockCallback lockCallback) throws LockAcquisitionException
{
    // Try to get lock
    String lockToken = jobLockService.getLock(LOCK_QNAME, LOCK_TTL);
    
    // Got the lock - now register the refresh callback which will keep the lock alive
    jobLockService.refreshLock(lockToken, LOCK_QNAME, LOCK_TTL, lockCallback);
    
    if (logger.isDebugEnabled())
    {
        logger.debug("Lock acquired: " + LOCK_QNAME + ": "+ lockToken);
    }
    
    return lockToken;
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private synchronized void releaseLock(LockCallback lockCallback, String lockToken)
{
    try
    {
        if (lockCallback != null)
        {
            lockCallback.running.set(false);
        }
        
        if (lockToken != null )
        {
            jobLockService.releaseLock(lockToken, LOCK_QNAME);
            if (logger.isDebugEnabled())
            {
                logger.debug("Lock released: " + LOCK_QNAME + ": " + lockToken);
            }
        }
    }
    catch (LockAcquisitionException e)
    {
        // Ignore
        if (logger.isDebugEnabled())
        {
            logger.debug("Lock release failed: " + LOCK_QNAME + ": " + lockToken + "(" + e.getMessage() + ")");
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private String acquireLock(JobLockRefreshCallback lockCallback) throws LockAcquisitionException
{
    // Try to get lock
    String lockToken = jobLockService.getLock(LOCK_QNAME, LOCK_TTL);
    
    // Got the lock - now register the refresh callback which will keep the lock alive
    jobLockService.refreshLock(lockToken, LOCK_QNAME, LOCK_TTL, lockCallback);
    
    if (logger.isDebugEnabled())
    {
        logger.debug("lock acquired: " + LOCK_QNAME + ": " + lockToken);
    }
    
    return lockToken;
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private void releaseLock(LockCallback lockCallback, String lockToken)
{
    try
    {
        if (lockCallback != null)
        {
            lockCallback.running.set(false);
        }
        
        if (lockToken != null)
        { 
            jobLockService.releaseLock(lockToken, LOCK_QNAME);
            if (logger.isDebugEnabled())
            {
                logger.debug("Lock released: " + LOCK_QNAME + ": " + lockToken);
            }
        }
    }
    catch (LockAcquisitionException e)
    {
        // Ignore
        if (logger.isDebugEnabled())
        {
            logger.debug("Lock release failed: " + LOCK_QNAME + ": " + lockToken + "(" + e.getMessage() + ")");
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private String getLock(long time)
{
    try
    {
        return jobLockService.getLock(lock, time);
    }
    catch (LockAcquisitionException e)
    {
        return null;
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
private String getLock(long time)
{
    try
    {
        return jobLockService.getLock(LOCK_QNAME, time);
    }
    catch (LockAcquisitionException e)
    {
        return null;
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
/**
 * Helper method to refresh the current job's lock token
 */
protected void refreshLock() throws LockAcquisitionException
{
    String token = this.lockToken.get();
    if (token != null && !shutdownListener.isVmShuttingDown())
    {
        // We had a lock token AND the VM is still going
        jobLockService.refreshLock(token, LOCK, LOCK_TTL);
    }
    else
    {
        // There is no lock token on this thread, so we trigger a deliberate failure
        jobLockService.refreshLock("lock token not available", LOCK, LOCK_TTL);
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
public int execute()
{
    String lockToken = null;
    FixedAclUpdaterJobLockRefreshCallback jobLockRefreshCallback = new FixedAclUpdaterJobLockRefreshCallback();

    try
    {
        lockToken = jobLockService.getLock(lockQName, lockTimeToLive, 0, 1);
        jobLockService.refreshLock(lockToken, lockQName, lockRefreshTime, jobLockRefreshCallback);

        AclWorkProvider provider = new AclWorkProvider();
        AclWorker worker = new AclWorker();
        BatchProcessor<NodeRef> bp = new BatchProcessor<>(
                "FixedAclUpdater",
                transactionService.getRetryingTransactionHelper(),
                provider,
                numThreads, maxItemBatchSize,
                applicationContext,
                log, 100);
        int count = bp.process(worker, true);
        return count;
    }
    catch (LockAcquisitionException e)
    {
        // already running
        return 0;
    }
    finally
    {
        jobLockRefreshCallback.isActive.set(false);
        if(lockToken != null)
        {
            jobLockService.releaseLock(lockToken, lockQName);
        }
    }
}
 

import org.alfresco.repo.lock.LockAcquisitionException; //导入依赖的package包/类
/**
 * Attempts to get the lock. If the lock couldn't be taken, then <tt>null</tt> is returned.
 * 
 * @return Returns the lock token or <tt>null</tt>
 */
private String getLock(long time)
{
    try
    {
        return jobLockService.getLock(LOCK, time);
    }
    catch (LockAcquisitionException e)
    {
        return null;
    }
}