单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
package wbg; import com.Thr; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { ExecutorService ex= Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { ex.execute(new Runnable() { @Override public void run() { Boss boss=Boss.getInstance(); System.out.println(boss); } }); } } } class Boss { private Boss(){}; private static Boss boss=null; public static Boss getInstance() { if (boss == null) { boss = new Boss(); } return boss; } }
（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）
以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全
package wbg; import com.Thr; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { ExecutorService ex= Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { ex.execute(new Runnable() { @Override public void run() { Boss boss=Boss.getInstance(); System.out.println(boss); } }); } } } class Boss { private Boss(){}; private static Boss boss=null; public synchronized static Boss getInstance() { if (boss == null) { boss = new Boss(); } return boss; } }
package wbg; import com.Thr; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { ExecutorService ex= Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { ex.execute(new Runnable() { @Override public void run() { Boss boss=Boss.getInstance(); System.out.println(boss); } }); } } } class Boss { private Boss(){}; private static Boss boss=null; public static Boss getInstance() { if (boss == null) { synchronized(Boss.class){ if (boss == null) { boss = new Boss(); } } } return boss; } }
package wbg; import com.Thr; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { ExecutorService ex= Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { ex.execute(new Runnable() { @Override public void run() { Boss boss=Boss.getInstance(); System.out.println(boss); } }); } } } class Boss { static class LazyHolder{ private static final Boss inst=new Boss(); } private Boss(){}; public static final Boss getInstance(){ return LazyHolder.inst; } }
package wbg; public class Boss { String name; String sex; Float money; //初始化一个静态变量 private static volatile Boss boss=null; //设置为私有 private Boss() { } //构造一个静态方法，通过它初始化或返还对象 public static Boss getBoss(){ //双重检查所机制 if(boss==null){ synchronized(Boss.class){ if(boss==null){ boss=new Boss(); } } } return boss; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Float getMoney() { return money; } public void setMoney(Float money) { this.money = money; } }
package wbg; public class Boss { String name; String sex; Float money; private Boss(){}; private static final Boss boss=new Boss(); public static Boss getInstance(){ return boss; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Float getMoney() { return money; } public void setMoney(Float money) { this.money = money; } }
（0）
