Java BlockingDeque类代码示例

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
public void testGet_concurrent() {
  assertTrue(ArbitraryInstances.get(BlockingDeque.class).isEmpty());
  assertTrue(ArbitraryInstances.get(BlockingQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(DelayQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(SynchronousQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(PriorityBlockingQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(ConcurrentMap.class).isEmpty());
  assertTrue(ArbitraryInstances.get(ConcurrentNavigableMap.class).isEmpty());
  ArbitraryInstances.get(Executor.class).execute(ArbitraryInstances.get(Runnable.class));
  assertNotNull(ArbitraryInstances.get(ThreadFactory.class));
  assertFreshInstanceReturned(
      BlockingQueue.class, BlockingDeque.class, PriorityBlockingQueue.class,
      DelayQueue.class, SynchronousQueue.class,
      ConcurrentMap.class, ConcurrentNavigableMap.class,
      AtomicReference.class, AtomicBoolean.class,
      AtomicInteger.class, AtomicLong.class, AtomicDouble.class);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
private <T> Collection<T> instantiateCollectionFromInterface(Class<? extends T> collectionType) {
    if (List.class.isAssignableFrom(collectionType)) {
        return new ArrayList<T>();
    } else if (SortedSet.class.isAssignableFrom(collectionType)) {
        return new TreeSet<T>();
    } else if (Set.class.isAssignableFrom(collectionType)) {
        return new LinkedHashSet<T>();
    } else if (BlockingDeque.class.isAssignableFrom(collectionType)) {
        return new LinkedBlockingDeque<T>();
    } else if (Deque.class.isAssignableFrom(collectionType)) {
        return new ArrayDeque<T>();
    } else if (BlockingQueue.class.isAssignableFrom(collectionType)) {
        return new LinkedBlockingDeque<T>();
    } else if (Queue.class.isAssignableFrom(collectionType)) {
        return new LinkedList<T>();
    }
    return new ArrayList<T>();
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
/**
 * takeFirst() blocks interruptibly when empty
 */
public void testTakeFirstFromEmptyBlocksInterruptibly() {
    final BlockingDeque q = new LinkedBlockingDeque();
    final CountDownLatch threadStarted = new CountDownLatch(1);
    Thread t = newStartedThread(new CheckedRunnable() {
        public void realRun() {
            threadStarted.countDown();
            try {
                q.takeFirst();
                shouldThrow();
            } catch (InterruptedException success) {}
            assertFalse(Thread.interrupted());
        }});

    await(threadStarted);
    assertThreadBlocks(t, Thread.State.WAITING);
    t.interrupt();
    awaitTermination(t);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
/**
 * takeLast() blocks interruptibly when empty
 */
public void testTakeLastFromEmptyBlocksInterruptibly() {
    final BlockingDeque q = new LinkedBlockingDeque();
    final CountDownLatch threadStarted = new CountDownLatch(1);
    Thread t = newStartedThread(new CheckedRunnable() {
        public void realRun() {
            threadStarted.countDown();
            try {
                q.takeLast();
                shouldThrow();
            } catch (InterruptedException success) {}
            assertFalse(Thread.interrupted());
        }});

    await(threadStarted);
    assertThreadBlocks(t, Thread.State.WAITING);
    t.interrupt();
    awaitTermination(t);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
static void putAllCollections(Map<Class<?>, IntFunction<?>> map, Map<Class<?>, Function<?, ?>> unmodMap)
{
    safePut(map, ArrayList.class, ArrayList::new);
    safePut(map, HashSet.class, LinkedHashSet::new);
    safePut(map, Properties.class, x -> new Properties());
    safePut(map, Hashtable.class, Hashtable::new);

    safePut(map, Collection.class, ArrayList::new);
    safePut(map, Set.class, LinkedHashSet::new);
    safePut(map, List.class, ArrayList::new);
    safePut(map, SortedSet.class, x -> new TreeSet<>());
    safePut(map, Queue.class, x -> new ConcurrentLinkedQueue<>());
    safePut(map, Deque.class, x -> new ConcurrentLinkedDeque<>());
    safePut(map, BlockingQueue.class, x -> new LinkedBlockingQueue<>());
    safePut(map, BlockingDeque.class, x -> new LinkedBlockingDeque<>());


    safePut(map, HashMap.class, LinkedHashMap::new);
    safePut(map, LinkedHashMap.class, LinkedHashMap::new);
    safePut(map, ConcurrentHashMap.class, ConcurrentHashMap::new);

    safePut(map, Map.class, LinkedHashMap::new);
    safePut(map, ConcurrentMap.class, x -> new ConcurrentSkipListMap<>());
    safePut(map, ConcurrentNavigableMap.class, x -> new ConcurrentSkipListMap<>());
    safePut(map, SortedMap.class, i -> new TreeMap<>());
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
/**
 * takeFirst() blocks interruptibly when empty
 */
public void testTakeFirstFromEmptyBlocksInterruptibly() {
    final BlockingDeque q = new LinkedBlockingDeque();
    final CountDownLatch threadStarted = new CountDownLatch(1);
    Thread t = newStartedThread(new CheckedRunnable() {
        public void realRun() {
            threadStarted.countDown();
            try {
                q.takeFirst();
                shouldThrow();
            } catch (InterruptedException success) {}
            assertFalse(Thread.interrupted());
        }});

    await(threadStarted);
    assertThreadStaysAlive(t);
    t.interrupt();
    awaitTermination(t);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
/**
 * takeLast() blocks interruptibly when empty
 */
public void testTakeLastFromEmptyBlocksInterruptibly() {
    final BlockingDeque q = new LinkedBlockingDeque();
    final CountDownLatch threadStarted = new CountDownLatch(1);
    Thread t = newStartedThread(new CheckedRunnable() {
        public void realRun() {
            threadStarted.countDown();
            try {
                q.takeLast();
                shouldThrow();
            } catch (InterruptedException success) {}
            assertFalse(Thread.interrupted());
        }});

    await(threadStarted);
    assertThreadStaysAlive(t);
    t.interrupt();
    awaitTermination(t);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
private void finishScanningCycle() {
    for (Map.Entry<String, BlockingDeque<Integer>> entry : mScanHistory.entrySet()) {
        final BlockingDeque<Integer> values = entry.getValue();


        if (values.size() < BUFFER_SIZE) {
            Log.d(TAG, entry.getKey() + ": Sorry, only got " + values.size() + " out of " + BUFFER_SIZE);
        }

        DescriptiveStatistics stats = BeaconFilter.statistics(values);

        synchronized (mScanResults) {
            for (ScanItem info : mScanResults) {
                if (info.getMacAddress().equalsIgnoreCase((entry.getKey()))) {
                    info.setRssi((int) stats.getMean());
                    Log.d(TAG, entry.getKey() + ": Calculated mean of RSSI to " + info.getRssi());
                    break;
                }
            }
        }
        mScanHistory.get(entry.getKey()).clear();
    }
    parcelIntent.putParcelableArrayListExtra(BluetoothScannerService.TAG_PARCEL, mScanResults);
    sendBroadcast(parcelIntent);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
static void putAllCollections(Map<Class<?>, IntFunction<?>> map)
{
    safePut(map, ArrayList.class, ArrayList::new);
    safePut(map, HashSet.class, LinkedHashSet::new);
    safePut(map, Properties.class, x -> new Properties());
    safePut(map, Hashtable.class, Hashtable::new);

    safePut(map, Collection.class, ArrayList::new);
    safePut(map, Set.class, LinkedHashSet::new);
    safePut(map, List.class, ArrayList::new);
    safePut(map, SortedSet.class, x -> new TreeSet<>());
    safePut(map, Queue.class, x -> new ConcurrentLinkedQueue<>());
    safePut(map, Deque.class, x -> new ConcurrentLinkedDeque<>());
    safePut(map, BlockingQueue.class, x -> new LinkedBlockingQueue<>());
    safePut(map, BlockingDeque.class, x -> new LinkedBlockingDeque<>());


    safePut(map, HashMap.class, LinkedHashMap::new);
    safePut(map, LinkedHashMap.class, LinkedHashMap::new);
    safePut(map, ConcurrentHashMap.class, ConcurrentHashMap::new);

    safePut(map, Map.class, LinkedHashMap::new);
    safePut(map, ConcurrentMap.class, x -> new ConcurrentSkipListMap<>());
    safePut(map, ConcurrentNavigableMap.class, x -> new ConcurrentSkipListMap<>());
    safePut(map, SortedMap.class, i -> new TreeMap<>());
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
private static void startFuzzer(String targetHost, Integer targetPort, Integer fuzzerPort, String fuzzType) throws IOException {
    BlockingDeque<String> queue = new LinkedBlockingDeque<String>();
    AgentEventReader reader = new AgentEventReader(queue, fuzzerPort);
    PayloadGenerator generator = new RandomBytesPayloadGenerator();

    PayloadSender sender = null;
    if ("TCP".equals(fuzzType)) {
        sender = new TCPSocketPayloadSender(targetHost, targetPort);
    } else if ("HTTP".equals(fuzzType)) {
        // TODO implement payload generator for http
    } else if ("JMX".equals(fuzzType)) {
        // TODO implement payload generator for jmx
    }

    PayloadService service = new PayloadService(queue, generator, sender);

    System.out.println(format("Fuzzer has started on %s:%d", targetHost, targetPort));

    ExecutorService executorService = Executors.newFixedThreadPool(2);
    executorService.execute(reader);
    executorService.execute(service);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
public void testGet_concurrent() {
  assertTrue(ArbitraryInstances.get(BlockingDeque.class).isEmpty());
  assertTrue(ArbitraryInstances.get(BlockingQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(DelayQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(SynchronousQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(PriorityBlockingQueue.class).isEmpty());
  assertTrue(ArbitraryInstances.get(ConcurrentMap.class).isEmpty());
  assertTrue(ArbitraryInstances.get(ConcurrentNavigableMap.class).isEmpty());
  ArbitraryInstances.get(Executor.class).execute(ArbitraryInstances.get(Runnable.class));
  assertNotNull(ArbitraryInstances.get(ThreadFactory.class));
  assertFreshInstanceReturned(
      BlockingQueue.class,
      BlockingDeque.class,
      PriorityBlockingQueue.class,
      DelayQueue.class,
      SynchronousQueue.class,
      ConcurrentMap.class,
      ConcurrentNavigableMap.class,
      AtomicReference.class,
      AtomicBoolean.class,
      AtomicInteger.class,
      AtomicLong.class,
      AtomicDouble.class);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static BlockingDeque<String> proxy(Object inputDeque) throws NoSuchMethodException {
    if (inputDeque instanceof BlockingDeque) {
        return (BlockingDeque<String>) inputDeque;
    }
    final ClassLoader cl = Thread.currentThread().getContextClassLoader();

    final Method put = inputDeque.getClass().getMethod("put", Object.class);
    final Method take = inputDeque.getClass().getMethod("take");
    final Method isEmpty = inputDeque.getClass().getMethod("isEmpty");

    return (BlockingDeque<String>)Proxy.newProxyInstance(cl, new Class[]{BlockingDeque.class}, (proxy, method, args) -> {
        switch (method.getName()) {
            case "put":
                return put.invoke(inputDeque, args);
            case "take":
                return take.invoke(inputDeque, args);
            case "isEmpty":
                return isEmpty.invoke(inputDeque, args);
        }
        throw new UnsupportedOperationException(method.toGenericString() + " is not supported");
    });
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
@Override
public void pack(BlockingDeque<PackItem> itemsDeque,
                 File packsDir,
                 String packId,
                 Consumer<PackItem> newItemSuccess,
                 Consumer<PackItem> newItemFail,
                 Consumer<File> done,
                 Runnable failed) {
    final File packFile = new File(packsDir, packId + ".zip");
    try (final ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(packFile))) {
        PackItem item = takeItem(itemsDeque);
        if (item == null) {
            failed.run();
            return;
        }
        while (!item.getFileName().equals("end")) {
            final boolean added = PackSupport.saveToZip(item, zos);
            if (added) newItemSuccess.accept(item);
            else newItemFail.accept(item);
            item = takeItem(itemsDeque);
            if (item == null) {
                failed.run();
                return;
            }
        }
    } catch (IOException e) {
        failed.run();
        return;
    }
    done.accept(packFile);
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
private <I extends PackItem> I takeItem(BlockingDeque<I> deque) {
    try {
        return deque.take();
    } catch (InterruptedException e) {
        return null;
    }
}
 

import java.util.concurrent.BlockingDeque; //导入依赖的package包/类
void pack(BlockingDeque<PackItem> itemsDeque,
File packsDir,
String packId,
Consumer<PackItem> newItemSuccess,
Consumer<PackItem> newItemFail,
Consumer<File> done,
Runnable failed);