标签：Singleton 01 getInstance static 单例 println 设计模式 public out
单例模式
什么是单例模式
单例模式确保一个类只有一个实例，并提供一个全局访问点，实现单例模式的方法是私有化构造函数，通过一个单独的getInstance()方法实例化对象，并返回这个实例。
保证在JVM中只有一个实例 幂等
JVM中如何保证实例的幂等问题 保证唯一性
饿汉、懒汉 双重检验
单例模式优缺点
1、单例类只有一个实例
2、共享资源，全局使用
3、节省创建时间，提高性能
缺点：可能存在线程不安全的问题 解决线程安全问题
单例的七种写法
分别是「饿汉」、「懒汉(非线程安全)」、「懒汉(线程安全)」、「双重校验锁」、「静态内部类」、「枚举」和「容器类管理、静态块初始化
饿汉式
public class SingletonV1 {
/**
* 饿汉式 优点：先天性线程是安全的，当类初始化的 就会创建该对象 缺点：如果饿汉式使用过多，可能会影响项目启动的效率问题。
*/
private static SingletonV1 singletonV1 = new SingletonV1();
/**
* 将构造函数私有化 禁止初始化
*/
private SingletonV1() {
}
public static SingletonV1 getInstance() {
return singletonV1;
}
public static void main(String[] args) {
SingletonV1 instance1 = SingletonV1.getInstance();
SingletonV1 instance2 = SingletonV1.getInstance();
System.out.println(instance1 == instance2);
}
}
优缺点
优点：先天性线程是安全的，当类初始化的 就会创建该对象
缺点：如果饿汉式使用过多，可能会影响项目启动的效率问题。
懒汉式（线程不安全）
public class SingletonV2 {
/**
* 懒汉式 （线程不安全）
*/
private static SingletonV2 singletonV2;
private SingletonV2() {
}
/**
* 在真正需要创建对象的时候使用...
*
* @return
*/
public static SingletonV2 getInstance() {
if (singletonV2 == null) {
try {
Thread.sleep(2000);
} catch (Exception e) {
}
singletonV2 = new SingletonV2();
}
return singletonV2;
}
public static void main(String[] args) {
// SingletonV2 instance1 = SingletonV2.getInstance();
// SingletonV2 instance2 = SingletonV2.getInstance();
// System.out.println(instance1 == instance2);
// 1.模拟线程不安全
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
public void run() {
SingletonV2 instance1 = SingletonV2.getInstance();
System.out.println(Thread.currentThread().getName() + "," + instance1);
}
}).start();
}
}
}
懒汉式（线程安全）
public class SingletonV3 {
/**
* 懒汉式 线程安全
*/
private static SingletonV3 singletonV3;
private SingletonV3() {
}
/**
* 能够解决线程安全问题，创建和获取实例时都上锁 ，效率非常低，所以推荐使用双重检验锁
*
* @return
*/
public synchronized static SingletonV3 getInstance() {
try {
Thread.sleep(2000);
} catch (Exception e) {
}
if (singletonV3 == null) {
System.out.println("创建实例SingletonV3");
singletonV3 = new SingletonV3();
}
System.out.println("获取SingletonV3实例");
return singletonV3;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
public void run() {
SingletonV3 instance1 = SingletonV3.getInstance();
System.out.println(Thread.currentThread().getName() + "," + instance1);
}
}).start();
}
}
}
双重检验锁(DCL)
public class SingletonV4 {
/**
* volatile 禁止重排序和 提高可见性
*/
private volatile static SingletonV4 singletonV4;
private SingletonV4() {
}
public static SingletonV4 getInstance() {
if (singletonV4 == null) { // 第一次判断如果没有创建对象 开始上锁...
synchronized (SingletonV4.class) {
if (singletonV4 == null) { // 当用户抢到锁，判断初始化
System.out.println("第一次开始创建实例对象....获取锁啦...");
try {
Thread.sleep(2000);
} catch (Exception e) {
}
singletonV4 = new SingletonV4();
}
}
}
return singletonV4;
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
public void run() {
SingletonV4 instance1 = SingletonV4.getInstance();
System.out.println(Thread.currentThread().getName() + "," + instance1);
}
}).start();
}
}
}
静态内部内形式
public class SingletonV5 {
private SingletonV5() {
System.out.println("对象初始...");
}
public static SingletonV5 getInstance() {
return SingletonV5Utils.singletonV5;
}
/**
* 静态内部方式能够避免同步带来的效率问题和有能实现延迟加载
*/
public static class SingletonV5Utils {
private static SingletonV5 singletonV5 = new SingletonV5();
}
public static void main(String[] args) {
System.out.println("项目启动成功");
SingletonV5 instance1 = SingletonV5.getInstance();
SingletonV5 instance2 = SingletonV5.getInstance();
System.out.println(instance1 == instance2);
}
}
枚举形式
枚举形式能够先天性，防止反射和序列化破解单例。
public enum EnumSingleton {
INSTANCE;
// 枚举能够绝对有效的防止实例化多次,和防止反射和序列化破解
public void add() {
System.out.println("add方法...");
}
}
public static void main(String[] args) throws Exception {
EnumSingleton instance1 = EnumSingleton.INSTANCE;
EnumSingleton instance2 = EnumSingleton.INSTANCE;
System.out.println(instance1 == instance2);
Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
EnumSingleton v3 = declaredConstructor.newInstance();
System.out.println(v3==instance1);
}
使用容器管理
public class SingletonManager {
private static Map<String, Object> objMap = new HashMap<String, Object>();
public static void registerService(String key, Object instance) {
if (!objMap.containsKey(key)) {
objMap.put(key, instance);
}
}
public static Object getService(String key) {
{
return objMap.get(key);
}
}
}
这种使用SingletonManager 将多种单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
如何防止破坏单例
虽然单例通过私有构造函数，可以实现防止程序猿初始化对象，但是还可以通过反射和序列化技术破解单例。
使用反射技术破解单例
// 1. 使用懒汉式创建对象
SingletonV3 instance1 = SingletonV3.getInstance();
// 2. 使用Java反射技术初始化对象 执行无参构造函数
Constructor declaredConstructor = SingletonV3.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
SingletonV3 instance2 = declaredConstructor.newInstance();
System.out.println(instance1 == instance2);
如何防止被反射破解
私有构造函数
private SingletonV3() throws Exception {
synchronized (SingletonV3.class) {
if (singletonV3 != null) {
throw new Exception("该对象已经初始化..");
}
System.out.println("执行SingletonV3无参构造函数...");
}
}
使用序列化技术破解单例
Singleton instance = Singleton.getInstance();
FileOutputStream fos = new FileOutputStream("E:\\code\\Singleton.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(instance);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("E:\\code\\Singleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Singleton singleton2 = (Singleton) ois.readObject();
System.out.println(singleton2==instance)
//返回序列化获取对象 ，保证为单例
public Object readResolve() {
return singletonV3;
}
标签：Singleton,01,getInstance,static,单例,println,设计模式,public,out 来源： https://blog.csdn.net/qq_45937199/article/details/111822816
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。