Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
* We get 55000 tasks per sec with this off, 28k/s with this on.
*
* (In old Groovy version btw we could run 6500/s vs 2300/s with renaming, from a single thread.)
*
* Defaults to false if system property is not set.
*/
private static final boolean RENAME_THREADS = Boolean.parseBoolean(System.getProperty("brooklyn.executionManager.renameThreads"));
private static class PerThreadCurrentTaskHolder {
public static final ThreadLocal perThreadCurrentTask = new ThreadLocal();
}
public static ThreadLocal getPerThreadCurrentTask() {
return PerThreadCurrentTaskHolder.perThreadCurrentTask;
}
/** @deprecated in 0.4.0, use Tasks.current() */
public static Task getCurrentTask() { return Tasks.current(); }
/** convenience for setting "blocking details" on any task where the current thread is running;
* typically invoked prior to a wait, for transparency to a user;
* then invoked with 'null' just after the wait
*
* @deprecated in 0.4.0, use Tasks.setBlockingDetails */
public static void setBlockingDetails(String description) {
Tasks.setBlockingDetails(description);
}
/** convenience for setting "blocking details" on any task where the current thread is running,
* while the passed code is executed; often used from groovy as
*
*
* @deprecated in 0.4.0, use Tasks.withBlockingDetails */
public static Object withBlockingDetails(String description, Callable code) throws Exception {
return Tasks.withBlockingDetails(description, code);
}
private final ThreadFactory threadFactory;
private final ThreadFactory daemonThreadFactory;
private final ExecutorService runner;
private final ScheduledExecutorService delayedRunner;
// TODO Could have a set of all knownTasks; but instead we're having a separate set per tag,
// so the same task could be listed multiple times if it has multiple tags...
//access to the below is synchronized in code in this class, to allow us to preserve order while guaranteeing thread-safe
//(but more testing is needed before we are sure it is thread-safe!)
//synch blocks are as finely grained as possible for efficiency
//Not using a CopyOnWriteArraySet for each, because profiling showed this being a massive perf bottleneck.
private ConcurrentMap> tasksByTag = new ConcurrentHashMap>();
private ConcurrentMap tasksById = new ConcurrentHashMap();
@Deprecated
private ConcurrentMap preprocessorByTag = new ConcurrentHashMap();
private ConcurrentMap schedulerByTag = new ConcurrentHashMap();
private final AtomicLong totalTaskCount = new AtomicLong();
private final AtomicInteger incompleteTaskCount = new AtomicInteger();
private final AtomicInteger activeTaskCount = new AtomicInteger();
private final List listeners = new CopyOnWriteArrayList();
public BasicExecutionManager(String contextid) {
threadFactory = newThreadFactory(contextid);
daemonThreadFactory = new ThreadFactoryBuilder()
.setThreadFactory(threadFactory)
.setDaemon(true)
.build();
// use Executors.newCachedThreadPool(daemonThreadFactory), but timeout of 1s rather than 60s for better shutdown!
runner = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 1L, TimeUnit.SECONDS, new SynchronousQueue(),
daemonThreadFactory);
delayedRunner = new ScheduledThreadPoolExecutor(1, daemonThreadFactory);
}
/**
* For use by overriders to use custom thread factory.
* But be extremely careful: called by constructor, so before sub-class' constructor will
* have been invoked!
*/
protected ThreadFactory newThreadFactory(String contextid) {
return new ThreadFactoryBuilder()
.setNameFormat("brooklyn-execmanager-"+contextid+"-%d")
.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler(){
@Override
public void uncaughtException(Thread t, Throwable e) {
log.error("Uncaught exception in thread "+t.getName(), e);
}})
.build();
}
public void shutdownNow() {
runner.shutdownNow();
}
public void addListener(ExecutionListener listener) {
listeners.add(listener);
}
public void removeListener(ExecutionListener listener) {
listeners.remove(listener);
}
/**
* Deletes the given tag, including all tasks using this tag.
*
* Useful, for example, if an entity is being expunged so that we don't keep holiding
* a reference to it as a tag.
*/
public void deleteTag(Object tag) {
Set tasks = tasksByTag.remove(tag);
if (tasks != null) {
for (Task task : tasks) {
deleteTask(task);
}
}
}
public void deleteTask(Task task) {
Set tags = checkNotNull((BasicTask)task, "task").tags;
if (tags != null) {
for (Object tag : tags) {
Set tasks = getMutableTasksWithTagOrNull(tag);
if (tasks != null) tasks.remove(task);
}
}
tasksById.remove(task.getId());
}
public boolean isShutdown() {
return runner.isShutdown();
}
public long getTotalTasksSubmitted() {
return totalTaskCount.get();
}
public long getNumIncompleteTasks() {
return incompleteTaskCount.get();
}
public long getNumActiveTasks() {
return activeTaskCount.get();
}
public long getNumInMemoryTasks() {
return tasksById.size();
}
private Set getMutableTasksWithTag(Object tag) {
if (tag == null) {
System.out.println("argph, null");
}
tasksByTag.putIfAbsent(tag, Collections.synchronizedSet(new LinkedHashSet()));
return tasksByTag.get(tag);
}
private Set getMutableTasksWithTagOrNull(Object tag) {
return tasksByTag.get(tag);
}
@Override
public Task getTask(String id) {
return tasksById.get(id);
}
@Override
public Set> getTasksWithTag(Object tag) {
Set result = getMutableTasksWithTag(tag);
synchronized (result) {
return (Set)Collections.unmodifiableSet(new LinkedHashSet(result));
}
}
@Override
public Set> getTasksWithAnyTag(Iterable tags) {
Set result = new LinkedHashSet();
Iterator ti = tags.iterator();
while (ti.hasNext()) {
result.addAll(getTasksWithTag(ti.next()));
}
return Collections.unmodifiableSet(result);
}
@Override
public Set> getTasksWithAllTags(Iterable tags) {
//NB: for this method retrieval for multiple tags could be made (much) more efficient (if/when it is used with multiple tags!)
//by first looking for the least-used tag, getting those tasks, and then for each of those tasks
//checking whether it contains the other tags (looking for second-least used, then third-least used, etc)
Set result = new LinkedHashSet();
boolean first = true;
Iterator ti = tags.iterator();
while (ti.hasNext()) {
Object tag = ti.next();
if (first) {
first = false;
result.addAll(getTasksWithTag(tag));
} else {
result.retainAll(getTasksWithTag(tag));
}
}
return Collections.unmodifiableSet(result);
}
public Set
