X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fbinding%2Fcodegen%2Fimpl%2FSingletonHolder.java;h=ac26445bf408677b6e397c9fbb77bcf4fcaa19de;hb=567792806ed799ac649cc125bffb4debde40d254;hp=291677a79a4fba3a16d27e1929e1fd23e2e14743;hpb=2c9ffa0406763f72332d60e3a49c57640ffafdcf;p=controller.git diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java index 291677a79a..ac26445bf4 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/SingletonHolder.java @@ -7,33 +7,81 @@ */ package org.opendaylight.controller.sal.binding.codegen.impl; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.ThreadFactory; - +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; +import com.google.common.util.concurrent.ThreadFactoryBuilder; import javassist.ClassPool; - import org.opendaylight.controller.sal.binding.codegen.RuntimeCodeGenerator; import org.opendaylight.controller.sal.binding.spi.NotificationInvokerFactory; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; -import com.google.common.util.concurrent.ThreadFactoryBuilder; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.RejectedExecutionHandler; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; public class SingletonHolder { - public static final ClassPool CLASS_POOL = new ClassPool(); + public static final ClassPool CLASS_POOL = ClassPool.getDefault(); public static final org.opendaylight.controller.sal.binding.codegen.impl.RuntimeCodeGenerator RPC_GENERATOR_IMPL = new org.opendaylight.controller.sal.binding.codegen.impl.RuntimeCodeGenerator( CLASS_POOL); public static final RuntimeCodeGenerator RPC_GENERATOR = RPC_GENERATOR_IMPL; public static final NotificationInvokerFactory INVOKER_FACTORY = RPC_GENERATOR_IMPL.getInvokerFactory(); + + public static final int CORE_NOTIFICATION_THREADS = 4; + public static final int MAX_NOTIFICATION_THREADS = 32; + public static final int NOTIFICATION_THREAD_LIFE = 15; + private static ListeningExecutorService NOTIFICATION_EXECUTOR = null; private static ListeningExecutorService COMMIT_EXECUTOR = null; + private static ListeningExecutorService CHANGE_EVENT_EXECUTOR = null; + /** + * @deprecated This method is only used from configuration modules and thus callers of it + * should use service injection to make the executor configurable. + */ + @Deprecated public static synchronized final ListeningExecutorService getDefaultNotificationExecutor() { + if (NOTIFICATION_EXECUTOR == null) { - NOTIFICATION_EXECUTOR = createNamedExecutor("md-sal-binding-notification-%d"); + // Overriding the queue since we need an unbounded queue + // and threadpoolexecutor would not create new threads if the queue is not full + BlockingQueue queue = new LinkedBlockingQueue() { + @Override + public boolean offer(Runnable r) { + if (size() <= 1) { + // if the queue is empty (or has just 1), no need to rampup the threads + return super.offer(r); + } else { + // if the queue is not empty, force the queue to return false. + // threadpoolexecutor will spawn a new thread if the queue.offer returns false. + return false; + } + } + }; + + ThreadFactory factory = new ThreadFactoryBuilder().setDaemon(true).setNameFormat("md-sal-binding-notification-%d").build(); + + ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_NOTIFICATION_THREADS, MAX_NOTIFICATION_THREADS, + NOTIFICATION_THREAD_LIFE, TimeUnit.SECONDS, queue , factory, + new RejectedExecutionHandler() { + // if the max threads are met, then it will raise a rejectedExecution. We then push to the queue. + @Override + public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { + try { + executor.getQueue().put(r); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }); + + NOTIFICATION_EXECUTOR = MoreExecutors.listeningDecorator(executor); } + return NOTIFICATION_EXECUTOR; } @@ -45,13 +93,13 @@ public class SingletonHolder { public static synchronized final ListeningExecutorService getDefaultCommitExecutor() { if (COMMIT_EXECUTOR == null) { ThreadFactory factory = new ThreadFactoryBuilder().setDaemon(true).setNameFormat("md-sal-binding-commit-%d").build(); - /* - * FIXME: this used to be newCacheThreadPool(), but MD-SAL does not have transaction - * ordering guarantees, which means that using a concurrent threadpool results - * in application data being committed in random order, potentially resulting - * in inconsistent data being present. Once proper primitives are introduced, - * concurrency can be reintroduced. - */ + /* + * FIXME: this used to be newCacheThreadPool(), but MD-SAL does not have transaction + * ordering guarantees, which means that using a concurrent threadpool results + * in application data being committed in random order, potentially resulting + * in inconsistent data being present. Once proper primitives are introduced, + * concurrency can be reintroduced. + */ ExecutorService executor = Executors.newSingleThreadExecutor(factory); COMMIT_EXECUTOR = MoreExecutors.listeningDecorator(executor); } @@ -59,9 +107,20 @@ public class SingletonHolder { return COMMIT_EXECUTOR; } - private static ListeningExecutorService createNamedExecutor(String format) { - ThreadFactory factory = new ThreadFactoryBuilder().setDaemon(true).setNameFormat(format).build(); - ExecutorService executor = Executors.newCachedThreadPool(factory); - return MoreExecutors.listeningDecorator(executor); + public static ExecutorService getDefaultChangeEventExecutor() { + if (CHANGE_EVENT_EXECUTOR == null) { + ThreadFactory factory = new ThreadFactoryBuilder().setDaemon(true).setNameFormat("md-sal-binding-change-%d").build(); + /* + * FIXME: this used to be newCacheThreadPool(), but MD-SAL does not have transaction + * ordering guarantees, which means that using a concurrent threadpool results + * in application data being committed in random order, potentially resulting + * in inconsistent data being present. Once proper primitives are introduced, + * concurrency can be reintroduced. + */ + ExecutorService executor = Executors.newSingleThreadExecutor(factory); + CHANGE_EVENT_EXECUTOR = MoreExecutors.listeningDecorator(executor); + } + + return CHANGE_EVENT_EXECUTOR; } }