Java 8 SynchronousQueue - top ranked examples from Open Source projects

            throw new TimeoutException("Failed to acquire request scheduler slot for '" + key + "'");
    } 
 
    public Thread poll()
    { 
        Entry e = queue.poll();
        if (e == null)
            return null; 
        metric.addNano(System.nanoTime() - e.creationTime);
        return e.thread;
    } 
 
    @Override 
    public String toString()
    { 
        return "RoundRobinScheduler.WeightedQueue(key=" + key + " weight=" + weight + ")";
    } 
 
    private final static class Entry 
    { 

 * @see ERXTaskThread 
 * @see ERXExecutorService 
 *  
 */ 
public class ERXExecutorService { 
	private static final ExecutorService _executorService = new ERXTaskThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, 
					TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), new ERXTaskThreadFactory()); 
 
	/**  
	 * @return a global ExecutorService with no limit for executing runnables.  
	 **/ 
	public static ExecutorService executorService() { 
		return _executorService; 
	} 
 
	/** 
	 * This ExecutorService is useful when you want to execute tasks in parallel, but you want to (create and) 
	 * submit new tasks for execution only when the pool has at least one idle thread. 
	 *  
	 * A task will be rejected with a {@link RejectedExecutionException} when all the threads are busy 

 
        @Override 
        public synchronized void start(final StartContext context) throws StartException {
            executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                    5L, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>(),
                    threadFactory);
        } 
 
        @Override 
        public synchronized void stop(final StopContext context) {
            Thread executorShutdown = new Thread(new Runnable() {
                @Override 
                public void run() { 
                    try { 
                        executorService.shutdown();
                    } finally { 
                        executorService = null;
                        context.complete();
                    } 

	protected BlockingQueue<Runnable> createQueue(int queueCapacity) {
		if (queueCapacity > 0) {
			return new LinkedBlockingQueue<Runnable>(queueCapacity);
		} 
		else { 
			return new SynchronousQueue<Runnable>();
		} 
	} 
 
 
	@Override 
	public ExecutorService getObject() throws Exception {
		return this.exposedExecutor;
	} 
 
	@Override 
	public Class<? extends ExecutorService> getObjectType() {
		return (this.exposedExecutor != null ? this.exposedExecutor.getClass() : ExecutorService.class);
	} 
 

    return new ZoieThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, 
        new LinkedBlockingQueue<Runnable>(), threadFactory); 
  } 
 
  public static ExecutorService newCachedThreadPool() { 
    return new ZoieThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, 
        new SynchronousQueue<Runnable>()); 
  } 
 
  public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { 
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, 
        new SynchronousQueue<Runnable>(), threadFactory); 
  } 
} 

public class GeckoBackgroundThread extends Thread {
    private static final String LOOPER_NAME = "GeckoBackgroundThread";
 
    // Guarded by 'this'. 
    private static Handler sHandler = null;
    private SynchronousQueue<Handler> mHandlerQueue = new SynchronousQueue<Handler>();
 
    // Singleton, so private constructor. 
    private GeckoBackgroundThread() { 
        super(); 
    } 
 
    public void run() { 
        setName(LOOPER_NAME);
        Looper.prepare();
        try { 
            mHandlerQueue.put(new Handler());
        } catch (InterruptedException ie) {}
 
        Looper.loop();

Show More

public class GeckoBackgroundThread extends Thread {
    private static final String LOOPER_NAME = "GeckoBackgroundThread";
 
    // Guarded by 'this'. 
    private static Handler sHandler = null;
    private SynchronousQueue<Handler> mHandlerQueue = new SynchronousQueue<Handler>();
 
    // Singleton, so private constructor. 
    private GeckoBackgroundThread() { 
        super(); 
    } 
 
    public void run() { 
        setName(LOOPER_NAME);
        Looper.prepare();
        try { 
            mHandlerQueue.put(new Handler());
        } catch (InterruptedException ie) {}
 
        Looper.loop();
    } 
 
    // Get a Handler for a looper thread, or create one if it doesn't yet exist. 
    public static synchronized Handler getHandler() {
        if (sHandler == null) {
          GeckoBackgroundThread lt = new GeckoBackgroundThread();
          lt.start();
          try { 
              sHandler = lt.mHandlerQueue.take();
          } catch (InterruptedException ie) {}
        } 
        return sHandler;
    } 
 

 
public class Application { 
	public static final String MESSAGE_DONE = "Done";
 
	public static void main(String... args) {
		BlockingQueue<String> queue = new SynchronousQueue<>();
		(new Thread(new Producer(queue))).start();
		(new Thread(new Consumer(queue))).start();
	} 
} 

    } 
 
    private void error(String msg) {
        Log.e(LOGTAG, msg);
        try { 
            mDataQueue.put("ERROR\n" + msg + "\n");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } 
    } 
 
    private void eglError(EGL10 egl, String msg) {
        error(msg + " (EGL error " + Integer.toHexString(egl.eglGetError()) + ")");
    } 
 
    public String getData() {
        String data = mDataQueue.poll();
        if (data != null)
            return data;
 

Show More

    } 
 
    private void error(String msg) {
        Log.e(LOGTAG, msg);
        try { 
            mDataQueue.put("ERROR\n" + msg + "\n");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } 
    } 
 
    private void eglError(EGL10 egl, String msg) {
        error(msg + " (EGL error " + Integer.toHexString(egl.eglGetError()) + ")");
    } 
 
    public String getData() {
        String data = mDataQueue.poll();
        if (data != null)
            return data;
 
        error("We need the GfxInfo data, but it is not yet available. " + 
              "We have to wait for it, so expect abnormally long startup times. " + 
              "Please report a Mozilla bug."); 
        try { 
            data = mDataQueue.take();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } 
        Log.i(LOGTAG, "GfxInfo data is finally available.");
        return data;

	protected BlockingQueue<Runnable> createQueue(int queueCapacity) {
		if (queueCapacity > 0) {
			return new LinkedBlockingQueue<Runnable>(queueCapacity);
		} 
		else { 
			return new SynchronousQueue<Runnable>();
		} 
	} 
 
	/** 
	 * Return the underlying ThreadPoolExecutor for native access. 
	 * @return the underlying ThreadPoolExecutor (never {@code null}) 
	 * @throws IllegalStateException if the ThreadPoolTaskExecutor hasn't been initialized yet 
	 */ 
	public ThreadPoolExecutor getThreadPoolExecutor() throws IllegalStateException {
		Assert.state(this.threadPoolExecutor != null, "ThreadPoolTaskExecutor not initialized");
		return this.threadPoolExecutor;
	} 
 
	/** 

 * @author Mark Fisher 
 */ 
public class RendezvousChannel extends QueueChannel { 
 
	public RendezvousChannel() { 
		super(new SynchronousQueue<Message<?>>()); 
	} 
 
}