Java tutorial
/* * Licensed to Metamarkets Group Inc. (Metamarkets) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. Metamarkets licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package io.druid.java.util.common.concurrent; import com.google.common.base.Preconditions; import com.google.common.base.Strings; import com.google.common.util.concurrent.ThreadFactoryBuilder; import javax.annotation.Nullable; import javax.validation.constraints.NotNull; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.RejectedExecutionHandler; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** */ public class Execs { /** * Returns an ExecutorService which is terminated and shutdown from the beginning and not able to accept any tasks. */ public static ExecutorService dummy() { return DummyExecutorService.INSTANCE; } public static ExecutorService singleThreaded(@NotNull String nameFormat) { return singleThreaded(nameFormat, null); } public static ExecutorService singleThreaded(@NotNull String nameFormat, @Nullable Integer priority) { return Executors.newSingleThreadExecutor(makeThreadFactory(nameFormat, priority)); } public static ExecutorService multiThreaded(int threads, @NotNull String nameFormat) { return multiThreaded(threads, nameFormat, null); } public static ExecutorService multiThreaded(int threads, @NotNull String nameFormat, @Nullable Integer priority) { return Executors.newFixedThreadPool(threads, makeThreadFactory(nameFormat, priority)); } public static ScheduledExecutorService scheduledSingleThreaded(@NotNull String nameFormat) { return scheduledSingleThreaded(nameFormat, null); } public static ScheduledExecutorService scheduledSingleThreaded(@NotNull String nameFormat, @Nullable Integer priority) { return Executors.newSingleThreadScheduledExecutor(makeThreadFactory(nameFormat, priority)); } public static ThreadFactory makeThreadFactory(@NotNull String nameFormat) { return makeThreadFactory(nameFormat, null); } public static ThreadFactory makeThreadFactory(@NotNull String nameFormat, @Nullable Integer priority) { final ThreadFactoryBuilder builder = new ThreadFactoryBuilder().setDaemon(true).setNameFormat(nameFormat); if (priority != null) { builder.setPriority(priority); } return builder.build(); } public static Thread makeThread(String name, Runnable runnable, boolean isDaemon) { Preconditions.checkArgument(!Strings.isNullOrEmpty(name), "name null/empty"); Preconditions.checkNotNull(runnable, "null runnable"); Thread t = new Thread(runnable); t.setName(name); t.setDaemon(isDaemon); return t; } /** * @param nameFormat nameformat for threadFactory * @param capacity maximum capacity after which the executorService will block on accepting new tasks * * @return ExecutorService which blocks accepting new tasks when the capacity reached */ public static ExecutorService newBlockingSingleThreaded(final String nameFormat, final int capacity) { return newBlockingSingleThreaded(nameFormat, capacity, null); } public static ExecutorService newBlockingSingleThreaded(final String nameFormat, final int capacity, final Integer priority) { final BlockingQueue<Runnable> queue; if (capacity > 0) { queue = new ArrayBlockingQueue<>(capacity); } else { queue = new SynchronousQueue<>(); } return new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, queue, makeThreadFactory(nameFormat, priority), new RejectedExecutionHandler() { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { try { executor.getQueue().put(r); } catch (InterruptedException e) { throw new RejectedExecutionException("Got Interrupted while adding to the Queue", e); } } }); } }