单例模式(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; } }