org.keycloak.executors.DefaultExecutorsProviderFactory クラス

org.keycloak.executors.DefaultExecutorsProviderFactory の継承関係図

org.keycloak.executors.DefaultExecutorsProviderFactory 連携図

公開メンバ関数
ExecutorsProvider	create (KeycloakSession session)
void	init (Config.Scope config)
void	postInit (KeycloakSessionFactory factory)
void	close ()
String	getId ()

限定公開メンバ関数
ExecutorService	getExecutor (String taskType, KeycloakSession session)
ExecutorService	retrievePool (String taskType, KeycloakSession session)
void	detectManaged ()
ExecutorService	getPoolManaged (String taskType, KeycloakSession session)
ExecutorService	createPoolEmbedded (String taskType, KeycloakSession session)
ThreadFactory	createThreadFactory (String taskType, KeycloakSession session)

静的限定公開変数類
static final Logger	logger = Logger.getLogger(DefaultExecutorsProviderFactory.class)

非公開変数類
Config.Scope	config
Boolean	managed = null
final Map< String, ExecutorService >	executors = new ConcurrentHashMap<>()

静的非公開変数類
static final int	DEFAULT_MIN_THREADS = 4
static final int	DEFAULT_MAX_THREADS = 64
static final String	MANAGED_EXECUTORS_SERVICE_JNDI_PREFIX = "java:jboss/ee/concurrency/executor/"
static final String	DEFAULT_MANAGED_EXECUTORS_SERVICE_JNDI = MANAGED_EXECUTORS_SERVICE_JNDI_PREFIX + "default"

詳解

著者

Marek Posolda

関数詳解

close()

void org.keycloak.executors.DefaultExecutorsProviderFactory.close ( )

inline

                        {
        if (managed != null && !managed) {
            for (Map.Entry<String, ExecutorService> executor : executors.entrySet()) {
                logger.debugf("Shutting down executor for task '%s'", executor.getKey());
                executor.getValue().shutdown();
            }
        }
    }

create()

ExecutorsProvider org.keycloak.executors.DefaultExecutorsProviderFactory.create ( KeycloakSession  session )

inline

                                                             {
        return new ExecutorsProvider() {

            @Override
            public ExecutorService getExecutor(String taskType) {
                return DefaultExecutorsProviderFactory.this.getExecutor(taskType, session);
            }

            @Override
            public void close() {

            }
        };
    }

createPoolEmbedded()

ExecutorService org.keycloak.executors.DefaultExecutorsProviderFactory.createPoolEmbedded ( String  taskType, KeycloakSession  session  )

inlineprotected

                                                                                           {
        Config.Scope currentScope = config.scope(taskType);
        int min = DEFAULT_MIN_THREADS;
        int max = DEFAULT_MAX_THREADS;

        if (currentScope != null) {
            min = currentScope.getInt("min", DEFAULT_MIN_THREADS);
            max = currentScope.getInt("max", DEFAULT_MAX_THREADS);
        }

        logger.debugf("Creating pool for task '%s': min=%d, max=%d", taskType, min, max);

        ThreadFactory threadFactory = createThreadFactory(taskType, session);

        if (min == max) {
            return Executors.newFixedThreadPool(min, threadFactory);
        } else {
            // Same like Executors.newCachedThreadPool. Besides that "min" and "max" are configurable
            return new ThreadPoolExecutor(min, max,
                    60L, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>(),
                    threadFactory);
        }
    }

createThreadFactory()

ThreadFactory org.keycloak.executors.DefaultExecutorsProviderFactory.createThreadFactory ( String  taskType, KeycloakSession  session  )

inlineprotected

                                                                                          {
        return new ThreadFactory() {

            private AtomicInteger i = new AtomicInteger(0);
            private int group = new Random().nextInt(2048);

            @Override
            public Thread newThread(Runnable r) {
                int threadNumber = i.getAndIncrement();
                String threadName = "kc-" + taskType + "-" + group + "-" + threadNumber;

                if (logger.isTraceEnabled()) {
                    logger.tracef("Creating thread: %s", threadName);
                }

                return new Thread(r, threadName);
            }

        };
    }

detectManaged()

void org.keycloak.executors.DefaultExecutorsProviderFactory.detectManaged ( )

inlineprotected

                                   {
        String jndiName = MANAGED_EXECUTORS_SERVICE_JNDI_PREFIX + "default";
        try {
            new InitialContext().lookup(jndiName);
            logger.debugf("We are in managed environment. Executor '%s' was available.", jndiName);
            managed = true;
        } catch (NamingException nnfe) {
            logger.debugf("We are not in managed environment. Executor '%s' was not available.", jndiName);
            managed = false;
        }
    }

getExecutor()

ExecutorService org.keycloak.executors.DefaultExecutorsProviderFactory.getExecutor ( String  taskType, KeycloakSession  session  )

inlineprotected

                                                                                    {
        ExecutorService existing = executors.get(taskType);

        if (existing == null) {
            synchronized (this) {
                if (!executors.containsKey(taskType)) {
                    ExecutorService executor = retrievePool(taskType, session);
                    executors.put(taskType, executor);
                }

                existing = executors.get(taskType);
            }
        }

        return existing;
    }

getId()

String org.keycloak.executors.DefaultExecutorsProviderFactory.getId ( )

inline

                          {
        return "default";
    }

getPoolManaged()

ExecutorService org.keycloak.executors.DefaultExecutorsProviderFactory.getPoolManaged ( String  taskType, KeycloakSession  session  )

inlineprotected

                                                                                       {
        try {
            InitialContext ctx = new InitialContext();

            // First check if specific pool for the task
            String jndiName = MANAGED_EXECUTORS_SERVICE_JNDI_PREFIX + taskType;
            try {
                ExecutorService executor = (ExecutorService) ctx.lookup(jndiName);
                logger.debugf("Found executor for '%s' under JNDI name '%s'", taskType, jndiName);
                return executor;
            } catch (NameNotFoundException nnfe) {
                logger.debugf("Not found executor for '%s' under specific JNDI name '%s'. Fallback to the default pool", taskType, jndiName);

                ExecutorService executor = (ExecutorService) ctx.lookup(DEFAULT_MANAGED_EXECUTORS_SERVICE_JNDI);
                logger.debugf("Found default executor for '%s' of JNDI name '%s'", taskType, DEFAULT_MANAGED_EXECUTORS_SERVICE_JNDI);
                return executor;
            }
        } catch (NamingException ne) {
            throw new IllegalStateException(ne);
        }
    }

init()

void org.keycloak.executors.DefaultExecutorsProviderFactory.init ( Config.Scope  config )

inline

                                          {
        this.config = config;
    }

postInit()

void org.keycloak.executors.DefaultExecutorsProviderFactory.postInit ( KeycloakSessionFactory  factory )

inline

                                                         {

    }

retrievePool()

ExecutorService org.keycloak.executors.DefaultExecutorsProviderFactory.retrievePool ( String  taskType, KeycloakSession  session  )

inlineprotected

                                                                                     {
        if (managed == null) {
            detectManaged();
        }

        if (managed) {
            return getPoolManaged(taskType, session);
        } else {
            return createPoolEmbedded(taskType, session);
        }
    }

メンバ詳解

config

Config.Scope org.keycloak.executors.DefaultExecutorsProviderFactory.config

private

DEFAULT_MANAGED_EXECUTORS_SERVICE_JNDI

final String org.keycloak.executors.DefaultExecutorsProviderFactory.DEFAULT_MANAGED_EXECUTORS_SERVICE_JNDI = MANAGED_EXECUTORS_SERVICE_JNDI_PREFIX + "default"

staticprivate

DEFAULT_MAX_THREADS

final int org.keycloak.executors.DefaultExecutorsProviderFactory.DEFAULT_MAX_THREADS = 64

staticprivate

DEFAULT_MIN_THREADS

final int org.keycloak.executors.DefaultExecutorsProviderFactory.DEFAULT_MIN_THREADS = 4

staticprivate

executors

final Map<String, ExecutorService> org.keycloak.executors.DefaultExecutorsProviderFactory.executors = new ConcurrentHashMap<>()

private

logger

final Logger org.keycloak.executors.DefaultExecutorsProviderFactory.logger = Logger.getLogger(DefaultExecutorsProviderFactory.class)

staticprotected

managed

Boolean org.keycloak.executors.DefaultExecutorsProviderFactory.managed = null

private

MANAGED_EXECUTORS_SERVICE_JNDI_PREFIX

final String org.keycloak.executors.DefaultExecutorsProviderFactory.MANAGED_EXECUTORS_SERVICE_JNDI_PREFIX = "java:jboss/ee/concurrency/executor/"

staticprivate

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/rest-service/src/services/src/main/java/org/keycloak/executors/DefaultExecutorsProviderFactory.java