下文是笔者编写的单例模式实现的八种方式，如下所示:
单例模式的简介
我们将一个类在当前进程中只有一个实例的这种模式，称之为“单例模式”
那么Java代码如何实现一个单例模式呢？下文将一一到来，如下所示:
单例模式的注意事项: 1.单例模式在一个进程中只有一个实例 2.单例类通常由自己创建自身的实例 3.单例类给其他对象提供的都是同一个实例
测试代码
package com.java265.Singleton; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("------单例模式-----"); //创建100个线程进行测试 for(int i=0;i<100;i++) { new Thread(()->{ System.out.println(Single01.getInstance()); }).start(); } } }
单例实现模式1
饿汉式单例模式：
直接使用一个静态变量，在JVM加载类时，生成一个单例实例
如下
package com.java265.Singleton; public class Single01 { private static final Single01 INSTANCE = new Single01(); private Single01() {} public static Single01 getInstance () { return INSTANCE; } }
使用static静态代码块生成一个单例类
package com.java265.Singleton; public class Single02 { private static final Single02 INSTANCE; static { INSTANCE = new Single02(); } private Single02() {} public static Single02 getInstance() { return INSTANCE; } public void t() { System.out.println("Single02 t方法" + ""); } }
使用判断的方式，创建单例模式，
但是此处不是一个线程安全的创建方式
package com.java265.Singleton; /* * 这是一个线程不安全的创建单例模式的方式 * 这是一个懒汉式的创建单例模式的方式 * */ public class Single03 { private static Single03 INSTANCE; private Single03() { } public static Single03 getInstance() { if(INSTANCE ==null) { // 多个线程都会被卡在此处， // 当sleep运行完毕后，多个线程会同时创建实例，此处的代码是产生线程不安全的根源 try { Thread.sleep(100); }catch(InterruptedException e) { } INSTANCE = new Single03(); } return INSTANCE; } }
使用 synchronized为方法加上锁,使其线程安全
package com.java265.Singleton; public class Single04 { private static volatile Single04 INSTANCE; private Single04() { } /* * 懒汉式生成单例实例 此处使用 synchronized 安全锁 */ public static synchronized Single04 getInstance() { if(INSTANCE ==null) { try { Thread.sleep(100); }catch(InterruptedException e) { } INSTANCE = new Single04(); } return INSTANCE; } }
减少锁粒度，将synchronized关键字直接加在方法内部具体的位置上
package com.java265.Singleton; public class Single05 { private static Single05 INSTANCE; private Single05() { } public static Single05 getInstance() { if(INSTANCE ==null) { /* * 将锁直接加到方法体里面 此时出现了一个新的问题 当所有的线程都堵塞在此处，也会创建多个实例 */ synchronized(Single05.class) { try { Thread.sleep(100); }catch(InterruptedException e) { } INSTANCE = new Single05(); } } return INSTANCE; } }
将synchronized锁放入在方法体中，同时使用双重检查，避免创建多个实例
package com.java265.Singleton; public class Single06 { private static Single06 INSTANCE; private Single06() { } public static Single06 getInstance() { if(INSTANCE ==null) { synchronized(Single06.class) { try { Thread.sleep(100); }catch(InterruptedException e) { } if(INSTANCE == null) { INSTANCE = new Single06(); } } } return INSTANCE; } }
使用静态内部类的方式创建一个单例对象
此方式主要借助JVM加载类时，内部类不会被加载
当我们使用内部类的时，才会被加载，此时由JVM保证静态内部类的唯一性
package com.java265.Singleton; /* * 采用内部类的方式实现一个单例模式 * */ public class Single07 { private Single07() { } private static class Single07Holder { private final static Single07 INSTANCE = new Single07(); } public static Single07 getInstance() { return Single07Holder.INSTANCE; } }
使用枚举创建一个静态内部类
package com.java265.Singleton; /* * 采用枚举实现一个单例模式 * */ public enum Single08 { INSTANCE; public static Single08 getInstance() { return INSTANCE; } }
内容来源于网络如有侵权请私信删除
文章来源: 博客园
- 还没有人评论，欢迎说说您的想法！
客服
