1. 饿汉式
实现代码:
public class Singleton {
private Singleton() {
}
private static Singleton singleton = new Singleton();
public static Singleton getInstance() {
return singleton;
}
}
验证一下:
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
// true
}
如果用反射, 是否仍然是单例:
结果是反射破坏了单例
public static void main(String[] args) throws Exception {
// 自定义单例方法获取
Singleton s1 = Singleton.getInstance();
// 反射获取
Constructor constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton s2 = (Singleton) constructor.newInstance();
System.out.println(s1 == s2);
//false
}
2. 懒汉式
将上面的饿汉式改为懒汉式:
public class Singleton {
private Singleton() {
}
private static Singleton singleton;
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
验证一下:
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
// true
}
不过这是一种线程不安全的单例实现.
我们在Singleton中加上sleep来模拟一下线程切换:
public class Singleton {
private Singleton() {
}
private static Singleton singleton;
public static Singleton getInstance() {
if (singleton == null) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
e.printStackTrace();
}
singleton = new Singleton();
}
return singleton;
}
}
验证一下线程不安全:
public class Main3 {
private static LinkedBlockingQueue<Singleton> singletons = new LinkedBlockingQueue<>();
public static void main(String[] args) throws Exception{
ExecutorService threadPool = Executors.newFixedThreadPool(10);
for(int i= 0;i<100;i++){
threadPool.execute(()->{
singletons.offer(Singleton.getInstance());
});
}
Singleton basic = singletons.take();
while(basic==singletons.take()){
System.out.println("continue");
continue;
}
System.out.println("走到这里说明单例失败");
}
}
3. 懒汉式+同步方法
public class Singleton {
private Singleton() {
}
private static Singleton singleton;
public synchronized static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
验证一下:
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
// true
}
由于是同步, 所以同步方法内不会出现多线程执行的情况.
4. 懒汉式+双重校验锁
因为上面那种会每次进时都会进行同步锁, 很浪费性能, 所以在加锁之间先进行校验
public class Singleton{
private Singleton() {
}
private static Singleton singleton;
public static Singleton getInstance() {
if (singleton==null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
验证一下性能:
能明显看出来性能差距...5千倍...
同步方法, 即直接在方法声明处加了Synchronize的情况:
public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}
双重校验锁:
public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}
5. 懒汉式+双重校验锁+防止指令重拍
看似简单的一段赋值语句：instance = new Singleton(); 其实JVM内部已经转换为多条指令：
memory = allocate(); //1：分配对象的内存空间
ctorInstance(memory); //2：初始化对象
instance = memory; //3：设置instance指向刚分配的内存地址
但是经过重排序后如下：
memory = allocate(); //1：分配对象的内存空间
instance = memory; //3：设置instance指向刚分配的内存地址，此时对象还没被初始化
ctorInstance(memory); //2：初始化对象
可以看到指令重排之后，instance指向分配好的内存放在了前面，而这段内存的初始化被排在了后面，在线程A初始化完成这段内存之前，线程B虽然进不去同步代码块，但是在同步代码块之前的判断就会发现instance不为空，此时线程B获得instance对象进行使用就可能发生错误。
加上volatile关键字:
public class Singleton {
private Singleton() {
}
private volatile static Singleton singleton;
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
验证一下性能:
能明显看出来加了volatile后对性能的影响, 由之前的5, 变为了302...
性能下降了, 但是相比于上面的双重校验锁, 更保证了线程安全.
public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}
6. 静态内部类
这也是一种很好的实现方式, 不仅懒加载, 还保证了线程安全, 性能也很好, 实现起来也很简单
public class Singleton {
private static class LazyHolder {
private static final Singleton instance = new Singleton();
}
private Singleton() {
}
public static Singleton getInstance() {
return LazyHolder.instance;
}
}
验证一下性能:
public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}
7. 枚举
个人对枚举类型的理解还有限, 有待学习....
public enum Singleton {
INSTANCE;
private String name;
Singleton() {
this.name = "king";
}
public static Singleton getInstance() {
return INSTANCE;
}
public String getName() {
return this.name;
}
}
验证一下性能:
public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}