//AbstractExecutorService实现了ExecutorService接口
public class ThreadPoolExecutor extends AbstractExecutorService

//ScheduledExecutorService继承ExecutorService接口
public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService

/**
 * 用给定的初始参数创建一个新的ThreadPoolExecutor。
 */
public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
                          int maximumPoolSize,//线程池的最大线程数
                          long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
                          TimeUnit unit,//时间单位
                          BlockingQueue<Runnable> workQueue,//任务队列，用来储存等待执行任务的队列
                          ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可
                          RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务
                           ) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

import java.util.Date;

/**
 * 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
 * @author shuang.kou
 */
public class MyRunnable implements Runnable {

    private String command;

    public MyRunnable(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return this.command;
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorDemo {

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final Long KEEP_ALIVE_TIME = 1L;
    public static void main(String[] args) {

        //使用阿里巴巴推荐的创建线程池的方式
        //通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());

        for (int i = 0; i < 10; i++) {
            //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
            Runnable worker = new MyRunnable("" + i);
            //执行Runnable
            executor.execute(worker);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}

// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

 private static int workerCountOf(int c) {
     return c & CAPACITY;
 }
 //任务队列
 private final BlockingQueue<Runnable> workQueue;

 public void execute(Runnable command) {
     // 如果任务为null，则抛出异常。
     if (command == null)
         throw new NullPointerException();
     // ctl 中保存的线程池当前的一些状态信息
     int c = ctl.get();

     //  下面会涉及到 3 步 操作
     // 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize
     // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
     if (workerCountOf(c) < corePoolSize) {
         if (addWorker(command, true))
             return;
         c = ctl.get();
     }
     // 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里
     // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去
     if (isRunning(c) && workQueue.offer(command)) {
         int recheck = ctl.get();
         // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
         if (!isRunning(recheck) && remove(command))
             reject(command);
             // 如果当前线程池为空就新创建一个线程并执行。
         else if (workerCountOf(recheck) == 0)
             addWorker(null, false);
     }
     //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
     //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
     else if (!addWorker(command, false))
         reject(command);
 }

 // 全局锁，并发操作必备
 private final ReentrantLock mainLock = new ReentrantLock();
 // 跟踪线程池的最大大小，只有在持有全局锁mainLock的前提下才能访问此集合
 private int largestPoolSize;
 // 工作线程集合，存放线程池中所有的（活跃的）工作线程，只有在持有全局锁mainLock的前提下才能访问此集合
 private final HashSet<Worker> workers = new HashSet<>();
 //获取线程池状态
 private static int runStateOf(int c)     { return c & ~CAPACITY; }
 //判断线程池的状态是否为 Running
 private static boolean isRunning(int c) {
     return c < SHUTDOWN;
 }


 /**
  * 添加新的工作线程到线程池
  * @param firstTask 要执行
  * @param core参数为true的话表示使用线程池的基本大小，为false使用线程池最大大小
  * @return 添加成功就返回true否则返回false
  */
private boolean addWorker(Runnable firstTask, boolean core) {
     retry:
     for (;;) {
         //这两句用来获取线程池的状态
         int c = ctl.get();
         int rs = runStateOf(c);

         // Check if queue empty only if necessary.
         if (rs >= SHUTDOWN &&
             ! (rs == SHUTDOWN &&
                firstTask == null &&
                ! workQueue.isEmpty()))
             return false;

         for (;;) {
            //获取线程池中线程的数量
             int wc = workerCountOf(c);
             // core参数为true的话表明队列也满了，线程池大小变为 maximumPoolSize 
             if (wc >= CAPACITY ||
                 wc >= (core ? corePoolSize : maximumPoolSize))
                 return false;
            //原子操作将workcount的数量加1
             if (compareAndIncrementWorkerCount(c))
                 break retry;
             // 如果线程的状态改变了就再次执行上述操作
             c = ctl.get();  
             if (runStateOf(c) != rs)
                 continue retry;
             // else CAS failed due to workerCount change; retry inner loop
         }
     }
     // 标记工作线程是否启动成功
     boolean workerStarted = false;
     // 标记工作线程是否创建成功
     boolean workerAdded = false;
     Worker w = null;
     try {
     
         w = new Worker(firstTask);
         final Thread t = w.thread;
         if (t != null) {
           // 加锁
             final ReentrantLock mainLock = this.mainLock;
             mainLock.lock();
             try {
                //获取线程池状态
                 int rs = runStateOf(ctl.get());
                //rs < SHUTDOWN 如果线程池状态依然为RUNNING,并且线程的状态是存活的话，就会将工作线程添加到工作线程集合中
               //(rs=SHUTDOWN && firstTask == null)如果线程池状态小于STOP，也就是RUNNING或者SHUTDOWN状态下，同时传入的任务实例firstTask为null，则需要添加到工作线程集合和启动新的Worker
                // firstTask == null证明只新建线程而不执行任务
                 if (rs < SHUTDOWN ||
                     (rs == SHUTDOWN && firstTask == null)) {
                     if (t.isAlive()) // precheck that t is startable
                         throw new IllegalThreadStateException();
                     workers.add(w);
                    //更新当前工作线程的最大容量
                     int s = workers.size();
                     if (s > largestPoolSize)
                         largestPoolSize = s;
                   // 工作线程是否启动成功
                     workerAdded = true;
                 }
             } finally {
                 // 释放锁
                 mainLock.unlock();
             }
             //// 如果成功添加工作线程，则调用Worker内部的线程实例t的Thread#start()方法启动真实的线程实例
             if (workerAdded) {
                 t.start();
               /// 标记线程启动成功
                 workerStarted = true;
             }
         }
     } finally {
        // 线程启动失败，需要从工作线程中移除对应的Worker
         if (! workerStarted)
             addWorkerFailed(w);
     }
     return workerStarted;
 }

@FunctionalInterface
public interface Runnable {
   /**
    * 被线程执行，没有返回值也无法抛出异常
    */
    public abstract void run();
}

@FunctionalInterface
public interface Callable<V> {
    /**
     * 计算结果，或在无法这样做时抛出异常。
     * @return 计算得出的结果
     * @throws 如果无法计算结果，则抛出异常
     */
    V call() throws Exception;
}

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

public void execute(Runnable command) {
  ...
}

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        //返回执行当前 Callable 的线程名字
        return Thread.currentThread().getName();
    }
}

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CallableDemo {

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final Long KEEP_ALIVE_TIME = 1L;

    public static void main(String[] args) {

        //使用阿里巴巴推荐的创建线程池的方式
        //通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());

        List<Future<String>> futureList = new ArrayList<>();
        Callable<String> callable = new MyCallable();
        for (int i = 0; i < 10; i++) {
            //提交任务到线程池
            Future<String> future = executor.submit(callable);
            //将返回值 future 添加到 list，我们可以通过 future 获得 执行 Callable 得到的返回值
            futureList.add(future);
        }
        for (Future<String> fut : futureList) {
            try {
                System.out.println(new Date() + "::" + fut.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        //关闭线程池
        executor.shutdown();
    }
}

/**
  * 创建一个可重用固定数量线程的线程池
  */
 public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
     return new ThreadPoolExecutor(nThreads, nThreads,
                                   0L, TimeUnit.MILLISECONDS,
                                   new LinkedBlockingQueue<Runnable>(),
                                   threadFactory);
 }

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

/**
  *返回只有一个线程的线程池
  */
 public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
     return new FinalizableDelegatedExecutorService
         (new ThreadPoolExecutor(1, 1,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue<Runnable>(),
                                 threadFactory));
 }

public static ExecutorService newSingleThreadExecutor() {
     return new FinalizableDelegatedExecutorService
         (new ThreadPoolExecutor(1, 1,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue<Runnable>()));
 }

/**
 * 创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它。
 */
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public class TreeNode<T> {

    /**
     * 节点ID
     */
    private Long id;

    /**
     * 节点数据
     */
    private T date;

    /**
     * 节点父节点ID
     */
    private Long parent;

    /**
     * 孩子节点
     */
    private List<TreeNode<T>> child;

    public void addChild(TreeNode<T> node) {
        if (CollectionUtils.isEmpty(this.child)) {
            this.child = new ArrayList<>();
        }
        this.child.add(node);
    }

    // Get Set ...
}

/**
 * 生成树
 *
 * @param nodes 所有节点
 * @return tree
 */
public static <T> TreeNode<T> tree(List<TreeNode<T>> nodes) {
    // 建立索引
    Map<Long, TreeNode<T>> map = nodes.stream().collect(Collectors.toMap(TreeNode::getId, item -> item));
    // ROOT 节点
    TreeNode<T> root = new TreeNode<>();
    for (TreeNode<T> node : nodes) {
        if (node.getParent() == null || node.getParent() == 0) {
            root.addChild(node);
        } else {
            Long parent = node.getParent();
            map.get(parent).addChild(node);
        }
    }
    return root;
}

/**
 * 获取节点 采用广度优先遍历
 *
 * @param id   节点id
 * @param tree 树
 * @return result
 */
public static <T> TreeNode<T> getNode(long id, TreeNode<T> tree) {
    Queue<TreeNode<T>> queue = new LinkedBlockingQueue<>();
    queue.add(tree);
    while (!queue.isEmpty()) {
        TreeNode<T> node = queue.poll();
        if (Objects.equals(node.getId(), id)) {
            return node;
        }
        if (!CollectionUtils.isEmpty(node.getChild())) {
            queue.addAll(node.getChild());
        }
    }
    return null;
}

/**
 * 深度优先遍历获取所有节点
 *
 * @param tree 树
 * @param list 节点列表
 */
public static <T> void getAllTreeNode(TreeNode<T> tree, List<TreeNode<T>> list) {
    list.add(tree);
    List<TreeNode<T>> child = tree.getChild();
    if (!CollectionUtils.isEmpty(child)) {
        for (TreeNode<T> node : child) {
            getAllTreeNode(node, list);
        }
    }
}

public class JavaLogic {
    public static void main(String[] args) {
        int a = -10;
        outBinaryString(a);
        outBinaryString(a >> 1);
        outBinaryString(a >>> 1);
    }

    public static void outBinaryString(int a) {
        System.out.printf("%20d --> ", a);
        print(a);
        System.out.println();
    }

    public static void print(int num) {
        for (int i = 31; i >= 0; i--) {
            System.out.print((num & (1 << i)) == 0 ? "0" : "1");
        }
    }
}

       -10 --> 11111111111111111111111111110110
        -5 --> 11111111111111111111111111111011
2147483643 --> 01111111111111111111111111111011

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}

/**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

int n = cap - 1;

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

tab[i = (n - 1) & hash]

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

/**
 * Implements Map.put and related methods.
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

i = (n - 1) & hash

default V getOrDefault(Object key, V defaultValue) {
    V v;
    return (((v = get(key)) != null) || containsKey(key))
        ? v
        : defaultValue;
}

public class AnnotationBeanNameGenerator implements BeanNameGenerator {

 /**
  * A convenient constant for a default {@code AnnotationBeanNameGenerator} instance,
  * as used for component scanning purposes.
  * @since 5.2
  */
 public static final AnnotationBeanNameGenerator INSTANCE = new AnnotationBeanNameGenerator();

 private static final String COMPONENT_ANNOTATION_CLASSNAME = "org.springframework.stereotype.Component";


 @Override
 public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
  if (definition instanceof AnnotatedBeanDefinition) {
   String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
   if (StringUtils.hasText(beanName)) {
    // Explicit bean name found.
    return beanName;
   }
  }
  // Fallback: generate a unique default bean name.
  return buildDefaultBeanName(definition, registry);
 }
}

/**
 * Derive a default bean name from the given bean definition.
 * <p>The default implementation delegates to {@link #buildDefaultBeanName(BeanDefinition)}.
 * @param definition the bean definition to build a bean name for
 * @param registry the registry that the given bean definition is being registered with
 * @return the default bean name (never {@code null})
 */
protected String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
 return buildDefaultBeanName(definition);
}

/**
 * Derive a default bean name from the given bean definition.
 * <p>The default implementation simply builds a decapitalized version
 * of the short class name: e.g. "mypackage.MyJdbcDao" -> "myJdbcDao".
 * <p>Note that inner classes will thus have names of the form
 * "outerClassName.InnerClassName", which because of the period in the
 * name may be an issue if you are autowiring by name.
 * @param definition the bean definition to build a bean name for
 * @return the default bean name (never {@code null})
 */
protected String buildDefaultBeanName(BeanDefinition definition) {
 String beanClassName = definition.getBeanClassName();
 Assert.state(beanClassName != null, "No bean class name set");
 String shortClassName = ClassUtils.getShortName(beanClassName);
 return Introspector.decapitalize(shortClassName);
}

AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");

// Consider name and any aliases
List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

public interface BeanNameGenerator {
    
	/**
	 * Generate a bean name for the given bean definition.
	 * @param definition the bean definition to generate a name for
	 * @param registry the bean definition registry that the given definition
	 * is supposed to be registered with
	 * @return the generated bean name
	 */
	String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry);

}

/**
 * Default implementation of the {@link BeanNameGenerator} interface, delegating to
 * {@link BeanDefinitionReaderUtils#generateBeanName(BeanDefinition, BeanDefinitionRegistry)}.
 *
 * @author Juergen Hoeller
 * @since 2.0.3
 */
public class DefaultBeanNameGenerator implements BeanNameGenerator {

	/**
	 * A convenient constant for a default {@code DefaultBeanNameGenerator} instance,
	 * as used for {@link AbstractBeanDefinitionReader} setup.
	 * @since 5.2
	 */
	public static final DefaultBeanNameGenerator INSTANCE = new DefaultBeanNameGenerator();


	@Override
	public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
		return BeanDefinitionReaderUtils.generateBeanName(definition, registry);
	}

}

public static String generateBeanName(
		BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
		throws BeanDefinitionStoreException {

	String generatedBeanName = definition.getBeanClassName();
	if (generatedBeanName == null) {
		if (definition.getParentName() != null) {
			generatedBeanName = definition.getParentName() + "$child";
		}
		else if (definition.getFactoryBeanName() != null) {
			generatedBeanName = definition.getFactoryBeanName() + "$created";
		}
	}
	if (!StringUtils.hasText(generatedBeanName)) {
		throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " +
				"'class' nor 'parent' nor 'factory-bean' - can't generate bean name");
	}

	String id = generatedBeanName;
	if (isInnerBean) {
		// Inner bean: generate identity hashcode suffix.
		id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
	}
	else {
		// Top-level bean: use plain class name with unique suffix if necessary.
		return uniqueBeanName(generatedBeanName, registry);
	}
	return id;
}

public static String uniqueBeanName(String beanName, BeanDefinitionRegistry registry) {
	String id = beanName;
	int counter = -1;

	// Increase counter until the id is unique.
	while (counter == -1 || registry.containsBeanDefinition(id)) {
		counter++;
		id = beanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
	}
	return id;
}

public class SingletonObjectHunger {
    /**
     * 私有静态实例
     */
    private static final SingletonObjectHunger INSTANCE = new SingletonObjectHunger();

    /**
     * 私有化构造函数
     */
    private SingletonObjectHunger(){
        // code
    }

    /**
     * 提供公开获取实例接口
     * @return 单例对象
     */
    public static SingletonObjectHunger getInstance(){
        return INSTANCE;
    }
}

public class SingletonObjectLazy {

    /**
     * 私有静态实例 未初始化实例
     */
    private static SingletonObjectLazy instance;

    /**
     * 私有化构造函数
     */
    private SingletonObjectLazy(){
        // code
    }

    /**
     * 提供公开获取实例接口
     * @return 单例对象
     */
    public static SingletonObjectLazy getInstance(){
        // 先判断实例是否为空，如果实例为空，则实例化对象
        if (instance == null) {
            instance = new SingletonObjectLazy();
        }
        return instance;
    }
}

1 if (instance == null) {
2     instance = new SingletonObjectLazy();

public synchronized static SingletonObjectLazy getInstance(){

public class SingletonObjectCheck {
    /**
     * 定义静态变量时，未初始化实例
     * 要解决双重检查锁模式带来空指针异常的问题，只需要使用volatile关键字，volatile关键字严格遵循happens-before原则，即在读操作前，写操作必须全部完成。
     */
    private volatile static SingletonObjectCheck instance;

    /**
     * 私有化构造函数
     */
    private SingletonObjectCheck(){

    }

    public static SingletonObjectCheck getInstance(){
        // 使用时，先判断实例是否为空，如果实例为空，则实例化对象
        if (instance == null) {
            // 使用互斥锁 只允许单一线程初始化实例
            synchronized (SingletonObjectCheck.class){
                if (instance == null) {
                    instance = new SingletonObjectCheck();
                }
            }
        }
        return instance;
    }
}

public class SingletonObjectStaticInner {

    /**
     * 私有化构造方法
     */
    private SingletonObjectStaticInner() {
    }

    /**
     * 单列持有者
     */
    private static class InstanceHolder{
        private static final SingletonObjectStaticInner INSTANCE = new SingletonObjectStaticInner();
    }

    public static SingletonObjectStaticInner getInstance(){
        return InstanceHolder.INSTANCE;
    }
}

public class SingletonObjectEnum {

    /**
     * 私有化构造函数
     */
    private SingletonObjectEnum() {
    }

    /**
     * 定义一个静态枚举类
     */
    static enum SingletonEnum {
        /**
         * 创建一个枚举对象，该对象天生为单例
         */
        INSTANCE;
        private SingletonObjectEnum SingletonObjectEnum;

        /**
         * 私有化枚举的构造函数
         */
        private SingletonEnum() {
            SingletonObjectEnum = new SingletonObjectEnum();
        }

        public SingletonObjectEnum getInstance() {
            return SingletonObjectEnum;
        }
    }

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

private SingletonObject(){
    if (instance !=null){
        throw new RuntimeException("实例已经存在，请勿重复初始化");
    }
}

public Object readResolve() throws ObjectStreamException {
        return instance;
    }