public class Facade {
    private SubsystemA systemA;
    private SubsystemB systemB;
    private SubsystemC systemC;

    public void operation() {
        // system A、B、C operations
    }
}

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

	@Nullable
	String getId();

	String getApplicationName();

	String getDisplayName();

	long getStartupDate();

	@Nullable
	ApplicationContext getParent();

	AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

}

public interface Subject {

    void request();
}

public class RealSubject implements Subject {

    public void request() {
        System.out.println("real request");
    }
}

public class Proxy implements Subject {
    private Subject subject;

    public Proxy(Subject subject) {
        this.subject = subject;
    }

    public void request() {
        System.out.println("before request");
        subject.request();
        System.out.println("after request");

    }
}

public class SubjectInvocationHandler implements InvocationHandler {
    private Subject subject;

    public SubjectInvocationHandler(Subject subject) {
        this.subject = subject;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before invoke");
        Object result = method.invoke(subject, args);
        System.out.println("after invoke");
        return result;
    }

    public static void main(String[] args) {
        Subject subject = new RealSubject();
        SubjectInvocationHandler invocationHandler = new SubjectInvocationHandler(subject);
        Subject proxy = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(),
                subject.getClass().getInterfaces(), invocationHandler);
        proxy.request();
    }
}

public class SubjectProxy implements MethodInterceptor {

    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before invoke");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("after invoke");
        return result;
    }

    public static void main(String[] args) {
        SubjectProxy subjectProxy = new SubjectProxy();

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealSubject.class);
        enhancer.setCallback(subjectProxy);

        Subject proxy = (RealSubject) enhancer.create();
        proxy.request();
    }
}

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	@Override
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        // 如果设置了代理应该执行积极的优化（默认为false），或显示设置使用cglib代理，或代理的对象没有实现接口
		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
            // 如果目标类是接口，或者已经是Jdk的动态代理类，则创建jdk动态代理
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

	/**
	 * Determine whether the supplied {@link AdvisedSupport} has only the
	 * {@link org.springframework.aop.SpringProxy} interface specified
	 * (or no proxy interfaces specified at all).
	 */
	private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
		Class<?>[] ifcs = config.getProxiedInterfaces();
		return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
	}

}

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    ...

    @Override
	public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
		}
		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}

    ...
}

public interface Target {

    void request();
}

public class Adaptee {

    public void specificRequest() {
        System.out.println("specific request");
    }
}

public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        adaptee.specificRequest();
    }
}

public class FutureTask<V> implements RunnableFuture<V> {

    ...

    // 构造函数1
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    
    // 构造函数2
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

    ...

}

public class Executors {

    ...

    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
    
    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

    ...

}

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // Determine handler for the current request.
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            // Determine handler adapter for the current request.
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // Process last-modified header, if supported by the handler.
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }

            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            // Actually invoke the handler.
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }

            applyDefaultViewName(processedRequest, mv);
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            // As of 4.3, we're processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

/**
 * @see AbstractBeanFactory
 */
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
        if (mbd.isSingleton()) {
            // Register a DisposableBean implementation that performs all destruction
            // work for the given bean: DestructionAwareBeanPostProcessors,
            // DisposableBean interface, custom destroy method.
            registerDisposableBean(beanName,
                    new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
        else {
            // A bean with a custom scope...
            Scope scope = this.scopes.get(mbd.getScope());
            if (scope == null) {
                throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
            }
            scope.registerDestructionCallback(beanName,
                    new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
    }
}

class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable {
    ....
    public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
            List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {

        Assert.notNull(bean, "Disposable bean must not be null");
        this.bean = bean;
        this.beanName = beanName;
        this.invokeDisposableBean =
                (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy"));
        this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
        this.acc = acc;
        String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
        if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
                !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
            this.destroyMethodName = destroyMethodName;
            Method destroyMethod = determineDestroyMethod(destroyMethodName);
            if (destroyMethod == null) {
                if (beanDefinition.isEnforceDestroyMethod()) {
                    throw new BeanDefinitionValidationException("Could not find a destroy method named '" +
                            destroyMethodName + "' on bean with name '" + beanName + "'");
                }
            }
            else {
                Class<?>[] paramTypes = destroyMethod.getParameterTypes();
                if (paramTypes.length > 1) {
                    throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                            beanName + "' has more than one parameter - not supported as destroy method");
                }
                else if (paramTypes.length == 1 && boolean.class != paramTypes[0]) {
                    throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                            beanName + "' has a non-boolean parameter - not supported as destroy method");
                }
                destroyMethod = ClassUtils.getInterfaceMethodIfPossible(destroyMethod);
            }
            this.destroyMethod = destroyMethod;
        }
        this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    }

    ...
}

/**
 * 抽象享元类
 */
public interface Flyweight {

    /**
     * 操作
     * 外部状态在使用时由外部设置，不保存在享元对象中，即使是同一个对象，在每一次调用时也可以传入不同的外部状态
     *
     * @param extrinsicState 外部状态
     */
    void operation(String extrinsicState);

    /**
     * 内部状态
     *
     * @return 内部状态
     */
    String getIntrinsicState();
}

/**
 * 具体享元类
 */
public class ConcreteFlyweight implements Flyweight {
    /**
     * 内部状态
     */
    private String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void operation(String extrinsicState) {
        System.out.println(String.format("内部状态：%s；外部状态：%s", intrinsicState, extrinsicState));
    }

    @Override
    public String getIntrinsicState() {
        return intrinsicState;
    }
}

/**
 * 享元工厂类
 */
public class FlyweightFactory {
    public static final Map<String, Flyweight> FLYWEIGHT_MAP = new HashMap<>();

    public static Flyweight getFlyweight(String intrinsicState) {
        // 如果在享元池中存在对象，则直接获取
        if (FLYWEIGHT_MAP.containsKey(intrinsicState)) {
            return FLYWEIGHT_MAP.get(intrinsicState);
        }
        // 否则，新建对象，并放入到享元池
        else {
            ConcreteFlyweight flyweight = new ConcreteFlyweight(intrinsicState);
            FLYWEIGHT_MAP.put(intrinsicState, flyweight);
            return flyweight;
        }
    }
}

public interface Command {

    void execute();

    void undo();
}

public class ConcreteCommand implements Command {
    /**
     * 命令接收者
     */
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }

    @Override
    public void undo() {
        // TODO
    }
}

public class Receiver {

    public void action() {
        System.out.println("do action");
    }
}

public class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void invoke() {
        command.execute();
    }
}

public class Client {

    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        ConcreteCommand command = new ConcreteCommand(receiver);

        Invoker invoker = new Invoker();
        invoker.setCommand(command);

        invoker.invoke();
    }
}

public abstract class HystrixCommand<R> extends AbstractCommand<R> implements HystrixExecutable<R>, HystrixInvokableInfo<R>, HystrixObservable<R> {
    ...

    public R execute() {
        try {
            return queue().get();
        } catch (Exception e) {
            throw Exceptions.sneakyThrow(decomposeException(e));
        }
    }

    public Future<R> queue() {
        /*
         * The Future returned by Observable.toBlocking().toFuture() does not implement the
         * interruption of the execution thread when the "mayInterrupt" flag of Future.cancel(boolean) is set to true;
         * thus, to comply with the contract of Future, we must wrap around it.
         */
        final Future<R> delegate = toObservable().toBlocking().toFuture();
    	
        final Future<R> f = new Future<R>() {

            @Override
            public boolean cancel(boolean mayInterruptIfRunning) {
                if (delegate.isCancelled()) {
                    return false;
                }

                if (HystrixCommand.this.getProperties().executionIsolationThreadInterruptOnFutureCancel().get()) {
                    /*
                     * The only valid transition here is false -> true. If there are two futures, say f1 and f2, created by this command
                     * (which is super-weird, but has never been prohibited), and calls to f1.cancel(true) and to f2.cancel(false) are
                     * issued by different threads, it's unclear about what value would be used by the time mayInterruptOnCancel is checked.
                     * The most consistent way to deal with this scenario is to say that if *any* cancellation is invoked with interruption,
                     * than that interruption request cannot be taken back.
                     */
                    interruptOnFutureCancel.compareAndSet(false, mayInterruptIfRunning);
        		}

                final boolean res = delegate.cancel(interruptOnFutureCancel.get());

                if (!isExecutionComplete() && interruptOnFutureCancel.get()) {
                    final Thread t = executionThread.get();
                    if (t != null && !t.equals(Thread.currentThread())) {
                        t.interrupt();
                    }
                }

                return res;
			}

            @Override
            public boolean isCancelled() {
                return delegate.isCancelled();
			}

            @Override
            public boolean isDone() {
                return delegate.isDone();
			}

            @Override
            public R get() throws InterruptedException, ExecutionException {
                return delegate.get();
            }

            @Override
            public R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
                return delegate.get(timeout, unit);
            }
        	
        };

        /* special handling of error states that throw immediately */
        if (f.isDone()) {
            try {
                f.get();
                return f;
            } catch (Exception e) {
                Throwable t = decomposeException(e);
                if (t instanceof HystrixBadRequestException) {
                    return f;
                } else if (t instanceof HystrixRuntimeException) {
                    HystrixRuntimeException hre = (HystrixRuntimeException) t;
                    switch (hre.getFailureType()) {
					case COMMAND_EXCEPTION:
					case TIMEOUT:
						// we don't throw these types from queue() only from queue().get() as they are execution errors
						return f;
					default:
						// these are errors we throw from queue() as they as rejection type errors
						throw hre;
					}
                } else {
                    throw Exceptions.sneakyThrow(t);
                }
            }
        }

        return f;
    }

    ...
}

public interface Strategy {

    void operation();
}

public class StrategyA implements Strategy {

    public void operation() {
        System.out.println("strategy A");
    }
}

public class StrategyB implements Strategy {

    public void operation() {
        System.out.println("strategy B");
    }
}

public class StrategyContext {
    private Strategy strategy;

    public StrategyContext(Strategy strategy) {
        this.strategy = strategy;
    }

    public void operation() {
        strategy.operation();
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
}

/**
 * 方式一
 */
public class ProductBuilder {
    private Product product;

    public ProductBuilder() {
        this.product = new Product();
    }

    public Product buildPartA(String partA) {
        product.setPartA(partA);
        return this.product;
    }

    public Product buildPartB(String partB) {
        product.setPartB(partB);
        return this.product;
    }

    public Product buildPartC(String partC) {
        product.setPartC(partC);
        return this.product;
    }

    public Product build() {
        return this.product;
    }
}

/**
 * 方式二
 */
public class ProductBuilder {
    private Product product;

    public ProductBuilder() {
        this.product = new Product();
    }

    public ProductBuilder buildPartA(String partA) {
        product.setPartA(partA);
        return this;
    }

    public ProductBuilder buildPartB(String partB) {
        product.setPartB(partB);
        return this;
    }

    public ProductBuilder buildPartC(String partC) {
        product.setPartC(partC);
        return this;
    }

    public Product build() {
        return this.product;
    }
}

public class IndexQueryBuilder {
    private String id;
    private Object object;
    private Long version;
    private String indexName;
    private String type;
    private String source;
    private String parentId;

    public IndexQueryBuilder() {
    }

    public IndexQueryBuilder withId(String id) {
        this.id = id;
        return this;
    }

    public IndexQueryBuilder withObject(Object object) {
        this.object = object;
        return this;
    }

    public IndexQueryBuilder withVersion(Long version) {
        this.version = version;
        return this;
    }

    public IndexQueryBuilder withIndexName(String indexName) {
        this.indexName = indexName;
        return this;
    }

    public IndexQueryBuilder withType(String type) {
        this.type = type;
        return this;
    }

    public IndexQueryBuilder withSource(String source) {
        this.source = source;
        return this;
    }

    public IndexQueryBuilder withParentId(String parentId) {
        this.parentId = parentId;
        return this;
    }

    public IndexQuery build() {
        IndexQuery indexQuery = new IndexQuery();
        indexQuery.setId(this.id);
        indexQuery.setIndexName(this.indexName);
        indexQuery.setType(this.type);
        indexQuery.setObject(this.object);
        indexQuery.setParentId(this.parentId);
        indexQuery.setSource(this.source);
        indexQuery.setVersion(this.version);
        return indexQuery;
    }
}

public abstract class AbstractClass {

    final void templateMethod() {
        operation1();
        operation2();
    }

    protected abstract void operation1();

    protected abstract void operation2();
}

public class ConcreteClassA extends AbstractClass {

    @Override
    protected void operation1() {
        System.out.println("operation1 of a");

    }

    @Override
    protected void operation2() {
        System.out.println("operation2 of a");
    }
}

public class ConcreteClassB extends AbstractClass {

    @Override
    protected void operation1() {
        System.out.println("operation1 of b");

    }

    @Override
    protected void operation2() {
        System.out.println("operation2 of b");
    }
}

public abstract class ReferService {

    // 模板方法
    public final <T> ReferPageResponse<T> queryReferPage(Map<String, Object> params, T clazz) {
        Pageable pageable = buildPageable(params);
        Page<T> page = queryForPage(pageable, params, clazz);
        return buildResponse(page);
    }

    // 数据查询由子类实现 
    protected abstract  <T> Page<T> queryForPage(Pageable pageable, Map<String, Object> params, T clazz);

    private Pageable buildPageable(Map<String, Object> params) {
        // TODO
        return null;
    }

    private <T> ReferPageResponse<T> buildResponse(Page<T> page) {
        // TODO
        return null;
    }
}

public class ReferUtils {

    public final <T> ReferPageResponse<T> queryReferPage(Map<String, Object> params, BiFunction<Pageable, Map, Page<T>> function) {
        Pageable pageable = buildPageable(params);
        Page<T> page = function.apply(pageable, params);
        return buildResponse(page);
    }

    private Pageable buildPageable(Map<String, Object> params) {
        // TODO
        return null;
    }

    private <T> ReferPageResponse<T> buildResponse(Page<T> page) {
        // TODO
        return null;
    }
}

public class SimpleFactory {

    public static Product create(String type) {
        if ("A".equals(type)) {
            return new ProjectA();
        } else if ("B".equals(type)) {
            return new ProjectB();
        } else{
            throw new RuntimeException("不支持该类产品的创建");
        }
    }
}

public interface Factory {

    Product create(String type);
}

public class FactoryA implements Factory {

    public Product create(String type) {
        if ("A".equals(type)) {
            return new ProjectA();
        } else{
            throw new RuntimeException("不支持该类产品的创建");
        }
    }
}

public class FactoryB implements Factory {

    public Product create(String type) {
        if ("B".equals(type)) {
            return new ProjectB();
        } else{
            throw new RuntimeException("不支持该类产品的创建");
        }
    }
}

public interface Factory {

    ProductA createProductA(String type);

    ProductB createProductB(String type);
}

public class FactoryA implements Factory {

    public ProductA createProductA(String type) {
        if ("1".equals(type)) {
            return new ProductA1();
        }   else{
            throw new RuntimeException("不支持该类产品的创建");
        }
    }

    public ProductB createProductB(String type) {
        if ("1".equals(type)) {
            return new ProductB1();
        } else{
            throw new RuntimeException("不支持该类产品的创建");
        }
    }
}

public class FactoryB implements Factory {

    public ProductA createProductA(String type) {
        if ("2".equals(type)) {
            return new ProductA2();
        }   else{
            throw new RuntimeException("不支持该类产品的创建");
        }
    }

    public ProductB createProductB(String type) {
        if ("2".equals(type)) {
            return new ProductB2();
        } else{
            throw new RuntimeException("不支持该类产品的创建");
        }
    }
}

public class Executors {

    ...

    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;
    
        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }
    
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

    ...

}

public class PageDataBuilderFactory {

    public static PageDataBuilder getPageDataBuilder(String pageType) {
        PageTypeEnum pageTypeEnum;
        try {
            pageTypeEnum = PageTypeEnum.valueOfName(pageType);
        } catch (Exception e) {
            throw new RuntimeException(String.format("尚未支持该页面类型：%s", pageType));
        }

        switch (pageTypeEnum) {
            case LIST_PAGE:
                return new ListPageDataBuilder();
            case CARD_PAGE:
                return new CardPageDataBuilder();
            default:
                throw new RuntimeException(String.format("尚未支持该页面类型：%s", pageTypeEnum.getName()));
        }
    }
}

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getSingleton() {
        return instance;
    }
}

public enum Singleton {
    INSTANCE;
}

public class Singleton {
    /**
     * volatile：保证线程间变量可见性
     */
    private volatile static Singleton instance;

    private Singleton() {
        // 可能存在成员初始化操作，这时需要使用volatile关键字
    }

    public static Singleton getInstance() {
        if (instance == null) {
            // 只在第一次初始化时才同步
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Singleton {

    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonInner.instance;
    }

    private static class SingletonInner {
        private static Singleton instance = new Singleton();
    }
}

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonEnum.INSTANCE.getInstance();
    }

    private enum SingletonEnum {
        /**
         * 唯一值
         */
        INSTANCE;

        private Singleton singleton;

        SingletonEnum() {
            singleton = new Singleton();
        }

        public Singleton getInstance() {
            return singleton;
        }
    }
}

public final class Unsafe {
    private static final Unsafe theUnsafe;

    ...

    private Unsafe() {
    }

    ...

    @CallerSensitive
    public static Unsafe getUnsafe() {
        Class var0 = Reflection.getCallerClass();
        if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
            throw new SecurityException("Unsafe");
        } else {
            return theUnsafe;
        }
    }

    ...

    static {
        ...
        theUnsafe = new Unsafe();
        ...
    }
}

/**
 * Return the (raw) singleton object registered under the given name.
 * <p>Checks already instantiated singletons and also allows for an early
 * reference to a currently created singleton (resolving a circular reference).
 * @param beanName the name of the bean to look for
 * @param allowEarlyReference whether early references should be created or not
 * @return the registered singleton object, or {@code null} if none found
 */
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从缓存（ConcurrentHashMap）中获取bean实例
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果bean实例为null，且正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { // double-check:1
        synchronized (this.singletonObjects) {
            // 从缓存（ConcurrentHashMap）中获取early bean实例
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果bean实例为null，且允许创建early reference
            if (singletonObject == null && allowEarlyReference) {  // double-check:2
                // 这里并非bean实例，而是创建bean实例的工厂对象
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 返回真正的bean
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

public enum ApproveServiceRegistry {
    INSTANCE;
    private Map<String, ApproveServiceInfo<? extends BaseBillEntity>> registry = new ConcurrentHashMap<>();

    public <T extends BaseBillEntity> void register(String billType, ApproveService<T> service) {
        registry.put(billType, new ApproveServiceInfo<>(service, service.getEntityClass(), service.getBillType()));
    }

    public void remove(String billType) {
        registry.remove(billType);
    }

    public boolean contains(String billType) {
        return registry.containsKey(billType);
    }

    public ApproveServiceInfo<? extends BaseBillEntity> getService(String billType) {
        return registry.get(billType);
    }
}