static {
        try {
            ProviderBootStrap.init();
            String appname = ConfigManagerLoader.getConfigManager().getAppName();
            if (StringUtils.isBlank(appname) || "NULL".equalsIgnoreCase(appname)) {
                throw new RuntimeException("appname is not assigned");
            }
        } catch (Throwable var1) {
            logger.error("error while initializing service factory:", var1);
            System.exit(1);
        }

    }

public static <T> void addService(ProviderConfig<T> providerConfig) throws RpcException {
        if (StringUtils.isBlank(providerConfig.getUrl())) {
            providerConfig.setUrl(getServiceUrl(providerConfig));
        }

        try {
            ServicePublisher.addService(providerConfig);
            ServerConfig serverConfig = ProviderBootStrap.startup(providerConfig);
            providerConfig.setServerConfig(serverConfig);
            ServicePublisher.publishService(providerConfig, false);
        } catch (RegistryException var2) {
            throw new RpcException("error while adding service:" + providerConfig, var2);
        } catch (Throwable var3) {
            throw new RpcException("error while adding service:" + providerConfig, var3);
        }
    }

public static ServerConfig startup(ProviderConfig<?> providerConfig) {
    ServerConfig serverConfig = providerConfig.getServerConfig();
    if (serverConfig == null) {
        throw new IllegalArgumentException("server config is required");
    }
    // 根據(jù)protocol+port判斷當前服務器列表中是否存在相關的服務器實例
    Server server = serversMap.get(serverConfig.getProtocol() + serverConfig.getPort());
    if (server != null) {
        // 存在直接返回
        server.addService(providerConfig);
        return server.getServerConfig();
    } else {
        // 不存在先創(chuàng)建一個
        synchronized (ProviderBootStrap.class) {
            List<Server> servers = ExtensionLoader.newExtensionList(Server.class);
            for (Server s : servers) {
                if (!s.isStarted()) {
                    if (s.support(serverConfig)) {
                        s.start(serverConfig);
                        // 添加服務
                        s.addService(providerConfig);
                        serversMap.put(s.getProtocol() + serverConfig.getPort(), s);
                        logger.warn("pigeon " + s + "[version:" + VersionUtils.VERSION + "] has been started");
                        break;
                    }
                }
            }
            server = serversMap.get(serverConfig.getProtocol() + serverConfig.getPort());
            // 預啟動內(nèi)部的請求處理器核心線程
            if (server != null) {
                server.getRequestProcessor().getRequestProcessThreadPool().prestartAllCoreThreads();
                return server.getServerConfig();
            }
            return null;
        }
    }
}

public <T> void addService(ProviderConfig<T> providerConfig) {
        this.requestProcessor.addService(providerConfig);
        this.doAddService(providerConfig);
        List<ServiceChangeListener> listeners = ServiceChangeListenerContainer.getListeners();
        Iterator i$ = listeners.iterator();

        while(i$.hasNext()) {
            ServiceChangeListener listener = (ServiceChangeListener)i$.next();
            listener.notifyServiceAdded(providerConfig);
        }

    }

public synchronized <T> void addService(ProviderConfig<T> providerConfig) {
        String url = providerConfig.getUrl();
        Map<String, ProviderMethodConfig> methodConfigs = providerConfig.getMethods();
        ServiceMethodCache methodCache = ServiceMethodFactory.getServiceMethodCache(url);
        Set<String> methodNames = methodCache.getMethodMap().keySet();
        if (this.needStandalonePool(providerConfig)) {
            if (this.methodThreadPools == null) {
                this.methodThreadPools = new ConcurrentHashMap();
            }

            if (this.serviceThreadPools == null) {
                this.serviceThreadPools = new ConcurrentHashMap();
            }

            if (providerConfig.getActives() > 0 && CollectionUtils.isEmpty(methodConfigs)) {
                DynamicThreadPool pool = (DynamicThreadPool)this.serviceThreadPools.get(url);
                if (pool == null) {
                    int actives = providerConfig.getActives();
                    int coreSize = (int)((float)actives / DEFAULT_POOL_RATIO_CORE) > 0 ? (int)((float)actives / DEFAULT_POOL_RATIO_CORE) : actives;
                    pool = new DynamicThreadPool("Pigeon-Server-Request-Processor-service", coreSize, actives, actives);
                    this.serviceThreadPools.putIfAbsent(url, pool);
                }
            }

            if (!CollectionUtils.isEmpty(methodConfigs)) {
                Iterator i$ = methodNames.iterator();

                while(i$.hasNext()) {
                    String name = (String)i$.next();
                    if (methodConfigs.containsKey(name)) {
                        String key = url + "#" + name;
                        DynamicThreadPool pool = (DynamicThreadPool)this.methodThreadPools.get(key);
                        if (pool == null) {
                            int actives = DEFAULT_POOL_ACTIVES;
                            ProviderMethodConfig methodConfig = (ProviderMethodConfig)methodConfigs.get(name);
                            if (methodConfig != null && methodConfig.getActives() > 0) {
                                actives = methodConfig.getActives();
                            }

                            int coreSize = (int)((float)actives / DEFAULT_POOL_RATIO_CORE) > 0 ? (int)((float)actives / DEFAULT_POOL_RATIO_CORE) : actives;
                            pool = new DynamicThreadPool("Pigeon-Server-Request-Processor-method", coreSize, actives, actives);
                            this.methodThreadPools.putIfAbsent(key, pool);
                        }
                    }
                }
            }
        }

    }