protected static boolean isEligible(String message) { try { lock.readLock().lock(); if (hashSet.contains(message)) return false; } finally { lock.readLock().unlock(); } try { lock.writeLock().lock(); if (buffer.size() >= 100) { String rem = buffer.remove(); hashSet.remove(rem); } buffer.add(message); hashSet.add(message); return true; } finally { lock.writeLock().unlock(); } }
public void testReadWriteLockDeadlock_treatedEquivalently() { readLockA.lock(); // readLockA -> writeLockB writeLockB.lock(); readLockA.unlock(); writeLockB.unlock(); // readLockB -> writeLockA should fail. readLockB.lock(); try { writeLockA.lock(); fail("Expected PotentialDeadlockException"); } catch (PotentialDeadlockException expected) { checkMessage(expected, "ReadWriteB -> ReadWriteA", "ReadWriteA -> ReadWriteB"); } }
public void testWriteToReadLockDowngrading() { writeLockA.lock(); // writeLockA downgrades to readLockA readLockA.lock(); writeLockA.unlock(); lockB.lock(); // readLockA -> lockB readLockA.unlock(); // lockB -> writeLockA should fail try { writeLockA.lock(); fail("Expected PotentialDeadlockException"); } catch (PotentialDeadlockException expected) { checkMessage(expected, "LockB -> ReadWriteA", "ReadWriteA -> LockB"); } }
public void testReadLock_deadlock() { readLockA.lock(); // Establish an ordering from readLockA -> lockB. lockB.lock(); lockB.unlock(); readLockA.unlock(); lockB.lock(); try { readLockA.lock(); fail("Expected PotentialDeadlockException"); } catch (PotentialDeadlockException expected) { checkMessage(expected, "LockB -> ReadWriteA", "ReadWriteA -> LockB"); } }
public void testReadWriteLockDeadlock() { writeLockA.lock(); // Establish an ordering from writeLockA -> lockB lockB.lock(); writeLockA.unlock(); lockB.unlock(); // lockB -> readLockA should fail. lockB.lock(); try { readLockA.lock(); fail("Expected PotentialDeadlockException"); } catch (PotentialDeadlockException expected) { checkMessage(expected, "LockB -> ReadWriteA", "ReadWriteA -> LockB"); } }
public void testReadWriteLockDeadlock_transitive() { readLockA.lock(); // Establish an ordering from readLockA -> lockB lockB.lock(); readLockA.unlock(); lockB.unlock(); // Establish an ordering from lockB -> lockC lockB.lock(); lockC.lock(); lockB.unlock(); lockC.unlock(); // lockC -> writeLockA should fail. lockC.lock(); try { writeLockA.lock(); fail("Expected PotentialDeadlockException"); } catch (PotentialDeadlockException expected) { checkMessage(expected, "LockC -> ReadWriteA", "LockB -> LockC", "ReadWriteA -> LockB"); } }
public void testReadLock_transitive() { readLockA.lock(); // Establish an ordering from readLockA -> lockB. lockB.lock(); lockB.unlock(); readLockA.unlock(); // Establish an ordering from lockB -> readLockC. lockB.lock(); readLockC.lock(); lockB.unlock(); readLockC.unlock(); // readLockC -> readLockA readLockC.lock(); try { readLockA.lock(); fail("Expected PotentialDeadlockException"); } catch (PotentialDeadlockException expected) { checkMessage( expected, "ReadWriteC -> ReadWriteA", "LockB -> ReadWriteC", "ReadWriteA -> LockB"); } }
public V getAndPut(K key, ValueProvider<? super K, ? extends V> valueProvider, boolean shouldCache) { V value; readLock.lock(); try { value = commonCache.get(key); if (null != convertValue(value)) { return value; } } finally { readLock.unlock(); } writeLock.lock(); try { // try to find the cached value again value = commonCache.get(key); if (null != convertValue(value)) { return value; } value = null == valueProvider ? null : valueProvider.provide(key); if (shouldCache && null != convertValue(value)) { commonCache.put(key, value); } } finally { writeLock.unlock(); } return value; }
public void handle(Page page){ if (page.getHtml() == null || page.getHtml().equals("")){ return; } ProxyListPageParser parser = ProxyListPageParserFactory. getProxyListPageParser(ProxyPool.proxyMap.get(url)); List<Proxy> proxyList = parser.parse(page.getHtml()); for(Proxy p : proxyList){ ProxyPool.lock.readLock().lock(); boolean containFlag = ProxyPool.proxySet.contains(p); ProxyPool.lock.readLock().unlock(); if (!containFlag){ ProxyPool.lock.writeLock().lock(); if(ProxyPool.proxySet.add(p)){ proxyHttpClient.getProxyTestThreadExecutor().execute(new ProxyTestTask(p)); } ProxyPool.lock.writeLock().unlock(); } } }
/** * Returns the Input/Output metadata for this step. By default, each step produces and accepts optional input. */ public StepIOMetaInterface getStepIOMeta( boolean createIfAbsent ) { StepIOMetaInterface ioMeta = null; lock.readLock().lock(); try { if ( ( ioMetaVar == null ) && ( createIfAbsent ) ) { ioMeta = new StepIOMeta( true, true, true, false, false, false ); lock.readLock().unlock(); lock.writeLock().lock(); try { ioMetaVar = ioMeta; lock.readLock().lock(); // downgrade to read lock before releasing write lock } finally { lock.writeLock().unlock(); } } else { ioMeta = ioMetaVar; } return ioMeta; } finally { lock.readLock().unlock(); } }
void subscribe() { try { subscriberLock.readLock().lock(); if (subscriber == null) { subscriberLock.readLock().unlock(); subscriberLock.writeLock().lock(); try { try { if (subscriber == null) { waitForSubscription(1, TimeUnit.SECONDS); } } finally { subscriberLock.readLock().lock(); } } finally { subscriberLock.writeLock().unlock(); } } } finally { subscriberLock.readLock().unlock(); } }