单例模式的多种玩法

Posted 怒放de每一天

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了单例模式的多种玩法相关的知识，希望对你有一定的参考价值。

饿汉单例模式

简单饿汉单例模式

 
   
   
 
    
  
    
    
  
  1. public class HungrySingleton {
    2. 
  
    
    
  
  2.  private static final HungrySingleton hungrySington = new HungrySingleton();
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  private HungrySingleton() {
    5. 
  
    
    
  
  5.  }
    6. 
  
    
    
  
  6.  public static HungrySingleton getInstance(){
    7. 
  
    
    
  
  7.  return hungrySington;
    8. 
  
    
    
  
  8.  }
    9. 
  
    
    
  
  9. }
    10.

静态代码块实现饿汉模式

 
   
   
 
    
  
    
    
  
  1. public class HungryStaticSingleton {
    2. 
  
    
    
  
  2.  private static final HungryStaticSingleton hungrySington;
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  static {
    5. 
  
    
    
  
  5.  hungrySington = new HungryStaticSingleton();
    6. 
  
    
    
  
  6.  }
    7. 
  
    
    
  

    8. 
  
    
    
  
  8.  private HungryStaticSingleton() {
    9. 
  
    
    
  
  9.  }
    10. 
  
    
    
  

    11. 
  
    
    
  
  11.  public static HungryStaticSingleton getInstance() {
    12. 
  
    
    
  
  12.  return hungrySington;
    13. 
  
    
    
  
  13.  }
    14. 
  
    
    
  
  14. }
    15.

懒汉单例模式

简单懒汉单例模式（线程不安全）

 
   
   
 
    
  
    
    
  
  1. public class LazySimplySington {
    2. 
  
    
    
  
  2.  private static LazySimplySington lazy;
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  private LazySimplySington() {
    5. 
  
    
    
  
  5.  }
    6. 
  
    
    
  

    7. 
  
    
    
  
  7.  //jdk1.8之后对synchronized性能优化不少
    8. 
  
    
    
  
  8.  //不可避免还是存在一定的性能问题
    9. 
  
    
    
  
  9.  public synchronized static LazySimplySington getInstance() {
    10. 
  
    
    
  
  10.  if (lazy == null) {
    11. 
  
    
    
  
  11.  lazy = new LazySimplySington();
    12. 
  
    
    
  
  12.  }
    13. 
  
    
    
  
  13.  return lazy;
    14. 
  
    
    
  
  14.  }
    15. 
  
    
    
  
  15. }
    16.

双重检查实现单例模式（线程安全）

注意指令重排序问题，需要单独加voliate关键字

 
   
   
 
    
  
    
    
  
  1. public class LazyDoubleCheckSington {
    2. 
  
    
    
  

    3. 
  
    
    
  
  3.  private volatile static LazyDoubleCheckSington lazy = null;
    4. 
  
    
    
  

    5. 
  
    
    
  
  5.  private LazyDoubleCheckSington() {
    6. 
  
    
    
  
  6.  }
    7. 
  
    
    
  

    8. 
  
    
    
  
  8.  //jdk1.8之后对synchronized性能优化不少
    9. 
  
    
    
  
  9.  //不可避免还是存在一定的性能问题
    10. 
  
    
    
  
  10.  public static LazyDoubleCheckSington getInstance() {
    11. 
  
    
    
  
  11.  if (lazy == null) {
    12. 
  
    
    
  
  12.  synchronized (LazyDoubleCheckSington.class) {
    13. 
  
    
    
  
  13.  if (lazy == null) {
    14. 
  
    
    
  
  14.  lazy = new LazyDoubleCheckSington();
    15. 
  
    
    
  
  15.  //指令重排序的问题:也就是 第二步和第三步会颠倒,
    16. 
  
    
    
  
  16.  // 解决方式 变量上加voliate，让线程可见
    17. 
  
    
    
  

    18. 
  
    
    
  
  18.  //CPU执行时候会转换成JVM指令执行
    19. 
  
    
    
  
  19.  //1.分配内存给这个对象
    20. 
  
    
    
  
  20.  //2.初始化对象
    21. 
  
    
    
  
  21. 
  
    
    
  
  22.  //4.用户初次始化
    23. 
  
    
    
  
  23.  }
    24. 
  
    
    
  
  24.  }
    25. 
  
    
    
  
  25.  }
    26. 
  
    
    
  
  26.  return lazy;
    27. 
  
    
    
  
  27.  }
    28. 
  
    
    
  
  28. }
    29.

内部类实现单例模式（线程安全）

 
   
   
 
    
  
    
    
  
  1. public class LazyInnerClassSington {
    2. 
  
    
    
  

    3. 
  
    
    
  
  3.  //虽然构造方法有了，但是逃不过反射的法眼
    4. 
  
    
    
  
  4.  private LazyInnerClassSington() { 
    5. 
  
    
    
  
  5.  }
    6. 
  
    
    
  
  6.  //懒汉式单例
    7. 
  
    
    
  
  7.  //LazyHolder里面的逻辑需要等到外部方法调用时才执行
    8. 
  
    
    
  
  8.  //巧妙利用了内部类的特性
    9. 
  
    
    
  
  9.  //JVM底层执行逻辑，完美的避免了线程安全问题
    10. 
  
    
    
  
  10.  public static final LazyInnerClassSington getInstance(){
    11. 
  
    
    
  
  11.  return LazyHolder.lazy;
    12. 
  
    
    
  
  12.  }
    13. 
  
    
    
  
  13.  private static class LazyHolder{
    14. 
  
    
    
  
  14.  private static final LazyInnerClassSington lazy = new LazyInnerClassSington();
    15. 
  
    
    
  
  15.  }
    16. 
  
    
    
  
  16. }
    17.

暴力破解单例

反射暴力破解

 
   
   
 
    
  
    
    
  
  1. public class LazyInnerClassSingtonTest {
    2. 
  
    
    
  
  2.  public static void main(String[] args) {
    3. 
  
    
    
  
  3.  try {
    4. 
  
    
    
  
  4.  //反射，破坏了单例
    5. 
  
    
    
  
  5.  Class<?> clazz = LazyInnerClassSington.class;
    6. 
  
    
    
  
  6.  Constructor<?> c = clazz.getDeclaredConstructor(null);
    7. 
  
    
    
  
  7.  c.setAccessible(true);
    8. 
  
    
    
  
  8.  Object o = c.newInstance();
    9. 
  
    
    
  
  9.  Object o2 = c.newInstance();
    10. 
  
    
    
  
  10.  System.out.println(o == o2);
    11. 
  
    
    
  
  11.  }catch (Exception e){
    12. 
  
    
    
  
  12.  e.printStackTrace();
    13. 
  
    
    
  
  13.  }
    14. 
  
    
    
  
  14.  }
    15. 
  
    
    
  
  15. }
    16.

单例模式的多种玩法

解决方式：

在构造函数内部添加判断

 
   
   
 
    
  
    
    
  
  1. //虽然构造方法有了，但是逃不过反射的法眼
    2. 
  
    
    
  
  2.  private LazyInnerClassSington() {
    3. 
  
    
    
  
  3.  if (LazyHolder.lazy != null){
    4. 
  
    
    
  
  4.  throw new RuntimeException("不允许构建多个实例");
    5. 
  
    
    
  
  5.  }
    6. 
  
    
    
  
  6.  }
    7.

测试:单例模式的多种玩法完整代码：

 
   
   
 
    
  
    
    
  
  1. public class LazyInnerClassSington {
    2. 
  
    
    
  

    3. 
  
    
    
  
  3.  //虽然构造方法有了，但是逃不过反射的法眼
    4. 
  
    
    
  
  4.  private LazyInnerClassSington() {
    5. 
  
    
    
  
  5.  if (LazyHolder.lazy != null){
    6. 
  
    
    
  
  6.  throw new RuntimeException("不允许构建多个实例");
    7. 
  
    
    
  
  7.  }
    8. 
  
    
    
  
  8.  }
    9. 
  
    
    
  
  9.  //懒汉式单例
    10. 
  
    
    
  
  10.  //LazyHolder里面的逻辑需要等到外部方法调用时才执行
    11. 
  
    
    
  
  11.  //巧妙利用了内部类的特性
    12. 
  
    
    
  
  12.  //JVM底层执行逻辑，完美的避免了线程安全问题
    13. 
  
    
    
  
  13.  public static final LazyInnerClassSington getInstance(){
    14. 
  
    
    
  
  14.  return LazyHolder.lazy;
    15. 
  
    
    
  
  15.  }
    16. 
  
    
    
  
  16.  private static class LazyHolder{
    17. 
  
    
    
  
  17.  private static final LazyInnerClassSington lazy = new LazyInnerClassSington();
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19. }
    20.

序列化和反序列化暴力破解

来个饿汉单例

 
   
   
 
    
  
    
    
  
  1. //反序列化时导致单例破坏
    2. 
  
    
    
  
  2. public class SeriableSingleton implements Serializable {
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  //序列化就是说把内存中的状态通过转换成字节码的形式
    5. 
  
    
    
  
  5.  //从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
    6. 
  
    
    
  
  6.  //内存中状态给永久保存下来了
    7. 
  
    
    
  

    8. 
  
    
    
  
  8.  //反序列化
    9. 
  
    
    
  
  9.  //讲已经持久化的字节码内容，转换为IO流
    10. 
  
    
    
  
  10.  //通过IO流的读取，进而将读取的内容转换为Java对象
    11. 
  
    
    
  
  11.  //在转换过程中会重新创建对象new
    12. 
  
    
    
  

    13. 
  
    
    
  
  13.  public final static SeriableSingleton INSTANCE = new SeriableSingleton();
    14. 
  
    
    
  
  14.  private SeriableSingleton(){}
    15. 
  
    
    
  

    16. 
  
    
    
  
  16.  public static SeriableSingleton getInstance(){
    17. 
  
    
    
  
  17.  return INSTANCE;
    18. 
  
    
    
  
  18.  }
    19.

破解

 
   
   
 
    
  
    
    
  
  1. public class SeriableSingletonTest {
    2. 
  
    
    
  
  2.  public static void main(String[] args) {
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  SeriableSingleton s1 = null;
    5. 
  
    
    
  
  5.  SeriableSingleton s2 = SeriableSingleton.getInstance();
    6. 
  
    
    
  

    7. 
  
    
    
  
  7.  FileOutputStream fos = null;
    8. 
  
    
    
  
  8.  try {
    9. 
  
    
    
  
  9.  fos = new FileOutputStream("SeriableSingleton.obj");
    10. 
  
    
    
  
  10.  ObjectOutputStream oos = new ObjectOutputStream(fos);
    11. 
  
    
    
  
  11.  oos.writeObject(s2);
    12. 
  
    
    
  
  12.  oos.flush();
    13. 
  
    
    
  
  13.  oos.close();
    14. 
  
    
    
  

    15. 
  
    
    
  

    16. 
  
    
    
  
  16.  FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
    17. 
  
    
    
  
  17.  ObjectInputStream ois = new ObjectInputStream(fis);
    18. 
  
    
    
  
  18.  s1 = (SeriableSingleton)ois.readObject();
    19. 
  
    
    
  
  19.  ois.close();
    20. 
  
    
    
  

    21. 
  
    
    
  
  21.  System.out.println(s1);
    22. 
  
    
    
  
  22.  System.out.println(s2);
    23. 
  
    
    
  
  23.  System.out.println(s1 == s2);
    24. 
  
    
    
  

    25. 
  
    
    
  
  25.  } catch (Exception e) {
    26. 
  
    
    
  
  26.  e.printStackTrace();
    27. 
  
    
    
  
  27.  }
    28. 
  
    
    
  
  28.  }
    29. 
  
    
    
  
  29. }
    30.

解决方式resolve方法

加个方法:

 
   
   
 
    
  
    
    
  
  1.  //序列化解决单例问题的方式
    2. 
  
    
    
  
  2.  //重写readResolve方法，只不过是覆盖了反序列化出来的对象
    3. 
  
    
    
  
  3.  //还是创建了两次，发生在JVM层面，相对来说比较安全
    4. 
  
    
    
  
  4.  //之前反序列化出来的对象会被GC回收
    5. 
  
    
    
  
  5.  private Object readResolve(){
    6. 
  
    
    
  
  6.  return INSTANCE;
    7. 
  
    
    
  
  7.  }
    8.

完整代码:

 
   
   
 
    
  
    
    
  
  1. public class SeriableSingletonTest {
    2. 
  
    
    
  
  2.  public static void main(String[] args) {
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  SeriableSingleton s1 = null;
    5. 
  
    
    
  
  5.  SeriableSingleton s2 = SeriableSingleton.getInstance();
    6. 
  
    
    
  

    7. 
  
    
    
  
  7.  FileOutputStream fos = null;
    8. 
  
    
    
  
  8.  try {
    9. 
  
    
    
  
  9.  fos = new FileOutputStream("SeriableSingleton.obj");
    10. 
  
    
    
  
  10.  ObjectOutputStream oos = new ObjectOutputStream(fos);
    11. 
  
    
    
  
  11.  oos.writeObject(s2);
    12. 
  
    
    
  
  12.  oos.flush();
    13. 
  
    
    
  
  13.  oos.close();
    14. 
  
    
    
  

    15. 
  
    
    
  

    16. 
  
    
    
  
  16.  FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
    17. 
  
    
    
  
  17.  ObjectInputStream ois = new ObjectInputStream(fis);
    18. 
  
    
    
  
  18.  s1 = (SeriableSingleton)ois.readObject();
    19. 
  
    
    
  
  19.  ois.close();
    20. 
  
    
    
  

    21. 
  
    
    
  
  21.  System.out.println(s1);
    22. 
  
    
    
  
  22.  System.out.println(s2);
    23. 
  
    
    
  
  23.  System.out.println(s1 == s2);
    24. 
  
    
    
  

    25. 
  
    
    
  
  25.  } catch (Exception e) {
    26. 
  
    
    
  
  26.  e.printStackTrace();
    27. 
  
    
    
  
  27.  }
    28. 
  
    
    
  
  28.  }
    29. 
  
    
    
  
  29. }
    30.

注册类单例

枚举实现单例(推荐)

可以同时实现防止反射和序列化反序列化暴力破解

 
   
   
 
    
  
    
    
  
  1. public enum EnumSingleton {
    2. 
  
    
    
  
  2.  INSTANCE;
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  private String name;
    5. 
  
    
    
  

    6. 
  
    
    
  
  6.  public String getData() {
    7. 
  
    
    
  
  7.  return name;
    8. 
  
    
    
  
  8.  }
    9. 
  
    
    
  

    10. 
  
    
    
  
  10.  public void setData(String data) {
    11. 
  
    
    
  
  11.  this.name = data;
    12. 
  
    
    
  
  12.  }
    13. 
  
    
    
  

    14. 
  
    
    
  
  14.  public static EnumSingleton getInstance(){
    15. 
  
    
    
  
  15.  return INSTANCE;
    16. 
  
    
    
  
  16.  }
    17. 
  
    
    
  
  17. }
    18.

使用jad工具查看枚举类的反编译代码

单例模式的多种玩法单例模式的多种玩法反编译代码:

 
   
   
 
    
  
    
    
  
  1. // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
    2. 
  
    
    
  
  2. // Jad home page: http://www.kpdus.com/jad.html
    3. 
  
    
    
  
  3. // Decompiler options: packimports(3)
    4. 
  
    
    
  
  4. // Source File Name: EnumSingleton.java
    5. 
  
    
    
  

    6. 
  
    
    
  
  6. package com.example.sington.register;
    7. 
  
    
    
  

    8. 
  
    
    
  

    9. 
  
    
    
  
  9. public final class EnumSingleton extends Enum
    10. 
  
    
    
  
  10. {
    11. 
  
    
    
  

    12. 
  
    
    
  
  12.  public static EnumSingleton[] values()
    13. 
  
    
    
  
  13.  {
    14. 
  
    
    
  
  14.  return (EnumSingleton[])$VALUES.clone();
    15. 
  
    
    
  
  15.  }
    16. 
  
    
    
  

    17. 
  
    
    
  
  17.  public static EnumSingleton valueOf(String name)
    18. 
  
    
    
  
  18.  {
    19. 
  
    
    
  
  19.  return (EnumSingleton)Enum.valueOf(com/example/sington/register/EnumSingleton, name);
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  

    22. 
  
    
    
  
  22.  private EnumSingleton(String s, int i)
    23. 
  
    
    
  
  23.  {
    24. 
  
    
    
  
  24.  super(s, i);
    25. 
  
    
    
  
  25.  }
    26. 
  
    
    
  

    27. 
  
    
    
  
  27.  public Object getData()
    28. 
  
    
    
  
  28.  {
    29. 
  
    
    
  
  29.  return data;
    30. 
  
    
    
  
  30.  }
    31. 
  
    
    
  

    32. 
  
    
    
  
  32.  public void setData(Object data)
    33. 
  
    
    
  
  33.  {
    34. 
  
    
    
  
  34.  this.data = data;
    35. 
  
    
    
  
  35.  }
    36. 
  
    
    
  

    37. 
  
    
    
  
  37.  public static EnumSingleton getInstance()
    38. 
  
    
    
  
  38.  {
    39. 
  
    
    
  
  39.  return INSTANCE;
    40. 
  
    
    
  
  40.  }
    41. 
  
    
    
  

    42. 
  
    
    
  
  42.  public static final EnumSingleton INSTANCE;
    43. 
  
    
    
  
  43.  private Object data;
    44. 
  
    
    
  
  44.  private static final EnumSingleton $VALUES[];
    45. 
  
    
    
  

    46. 
  
    
    
  
  46.  static 
    47. 
  
    
    
  
  47.  {
    48. 
  
    
    
  
  48.  INSTANCE = new EnumSingleton("INSTANCE", 0);
    49. 
  
    
    
  
  49.  $VALUES = (new EnumSingleton[] {
    50. 
  
    
    
  
  50.  INSTANCE
    51. 
  
    
    
  
  51.  });
    52. 
  
    
    
  
  52.  }
    53. 
  
    
    
  
  53. }
    54.

容器实现单例

 
   
   
 
    
  
    
    
  
  1. public class ContainerSingleton {
    2. 
  
    
    
  

    3. 
  
    
    
  
  3.  private ContainerSingleton() {
    4. 
  
    
    
  
  4.  }
    5. 
  
    
    
  

    6. 
  
    
    
  
  6.  private static Map<String, Object> ioc = new ConcurrentHashMap<>();
    7. 
  
    
    
  

    8. 
  
    
    
  
  8.  public static Object getBean(String className) {
    9. 
  
    
    
  
  9.  synchronized (ioc){
    10. 
  
    
    
  
  10.  if (!ioc.containsKey(className)) {
    11. 
  
    
    
  
  11.  Object obj = null;
    12. 
  
    
    
  
  12.  try {
    13. 
  
    
    
  
  13.  obj = Class.forName(className).getInterfaces();
    14. 
  
    
    
  
  14.  ioc.put(className, obj);
    15. 
  
    
    
  
  15.  } catch (Exception e) {
    16. 
  
    
    
  
  16.  e.printStackTrace();
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19.  return ioc.get(className);
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21.  }
    22. 
  
    
    
  
  22. }
    23. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public class Pojo {
    2. 
  
    
    
  
  2. }
    3. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public class ContainerSingletonTest {
    2. 
  
    
    
  
  2.  public static void main(String[] args) {
    3. 
  
    
    
  

    4. 
  
    
    
  

    5. 
  
    
    
  
  5.  try {
    6. 
  
    
    
  
  6.  long start = System.currentTimeMillis();
    7. 
  
    
    
  
  7.  ConcurrentExecutor.execute(new ConcurrentExecutor.RunHandler() {
    8. 
  
    
    
  
  8.  public void handler() {
    9. 
  
    
    
  
  9.  Object obj = ContainerSingleton.getBean("com.example.Pojo");
    10. 
  
    
    
  
  10.  System.out.println(System.currentTimeMillis() + ": " + obj);
    11. 
  
    
    
  
  11.  }
    12. 
  
    
    
  
  12.  }, 10,6);
    13. 
  
    
    
  
  13.  long end = System.currentTimeMillis();
    14. 
  
    
    
  
  14.  System.out.println("总耗时：" + (end - start) + " ms.");
    15. 
  
    
    
  
  15.  }catch (Exception e){
    16. 
  
    
    
  
  16.  e.printStackTrace();
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  

    19. 
  
    
    
  
  19.  }
    20. 
  
    
    
  
  20. }
    21.

单例模式的多种玩法

线程间实现单例ThreadLocal

 
   
   
 
    
  
    
    
  
  1. public class ThreadLocalSingleton {
    2. 
  
    
    
  

    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =
    5. 
  
    
    
  
  5.  new ThreadLocal<ThreadLocalSingleton>() {
    6. 
  
    
    
  
  6.  @Override
    7. 
  
    
    
  
  7.  protected ThreadLocalSingleton initialValue() {
    8. 
  
    
    
  
  8.  return new ThreadLocalSingleton();
    9. 
  
    
    
  
  9.  }
    10. 
  
    
    
  
  10.  };
    11. 
  
    
    
  

    12. 
  
    
    
  
  12.  private ThreadLocalSingleton() {
    13. 
  
    
    
  
  13.  }
    14. 
  
    
    
  

    15. 
  
    
    
  
  15.  public static ThreadLocalSingleton getInstance() {
    16. 
  
    
    
  
  16.  return threadLocalInstance.get();
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18. }
    19. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public class ExectorThread implements Runnable {
    2. 
  
    
    
  
  2.  @Override
    3. 
  
    
    
  
  3.  public void run() {
    4. 
  
    
    
  
  4. // LazySimplySington instance = LazySimplySington.getInstance();
    5. 
  
    
    
  
  5. // LazyDoubleCheckSington instance = LazyDoubleCheckSington.getInstance();
    6. 
  
    
    
  
  6.  ThreadLocalSingleton instance = ThreadLocalSingleton.getInstance();
    7. 
  
    
    
  
  7.  System.out.println(Thread.currentThread().getName()+" ---"+instance);
    8. 
  
    
    
  
  8.  ThreadLocalSingleton instance2 = ThreadLocalSingleton.getInstance();
    9. 
  
    
    
  
  9.  System.out.println(Thread.currentThread().getName()+" ---"+instance2);
    10. 
  
    
    
  
  10.  ThreadLocalSingleton instance3 = ThreadLocalSingleton.getInstance();
    11. 
  
    
    
  
  11.  System.out.println(Thread.currentThread().getName()+" ---"+instance3);
    12. 
  
    
    
  
  12.  ThreadLocalSingleton instance4 = ThreadLocalSingleton.getInstance();
    13. 
  
    
    
  
  13.  System.out.println(Thread.currentThread().getName()+" ---"+instance4);
    14. 
  
    
    
  
  14.  ThreadLocalSingleton instance5 = ThreadLocalSingleton.getInstance();
    15. 
  
    
    
  
  15.  System.out.println(Thread.currentThread().getName()+" ---"+instance5);
    16. 
  
    
    
  

    17. 
  
    
    
  
  17.  System.out.println(Thread.currentThread().getName()+" ---"+instance);
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19. }
    20. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public class ThreadLocalSingletonTest {
    2. 
  
    
    
  
  2.  public static void main(String[] args) {
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  System.out.println(ThreadLocalSingleton.getInstance());
    5. 
  
    
    
  
  5.  System.out.println(ThreadLocalSingleton.getInstance());
    6. 
  
    
    
  
  6.  System.out.println(ThreadLocalSingleton.getInstance());
    7. 
  
    
    
  
  7.  System.out.println(ThreadLocalSingleton.getInstance());
    8. 
  
    
    
  
  8.  System.out.println(ThreadLocalSingleton.getInstance());
    9. 
  
    
    
  

    10. 
  
    
    
  
  10.  Thread t1 = new Thread(new ExectorThread());
    11. 
  
    
    
  
  11.  Thread t2 = new Thread(new ExectorThread());
    12. 
  
    
    
  
  12.  t1.start();
    13. 
  
    
    
  
  13.  t2.start();
    14. 
  
    
    
  
  14.  System.out.println("End");
    15. 
  
    
    
  

    16. 
  
    
    
  
  16.  }
    17. 
  
    
    
  
  17. }
    18.

单例模式的多种玩法可以看到线程间是单例的。

单例模式的本质

本质:控制实例数目。（研磨设计模式）。

笔记和代码地址

代码:https://github.com/hufanglei/pattern-learn/tree/master/src/main/java/com/example/sington

笔记https://blog.csdn.net/baidu_21349635/article/details/106067581

微信订阅号:搜索：怒放de每一天

个人微信公号,搜索：i69032866

不定时推送相关文章，期待和大家一起成长！！

完


以上是关于单例模式的多种玩法的主要内容，如果未能解决你的问题，请参考以下文章

实现单例设计模式的多种方式

单例模式的多种实现

Java单例模式 多种实现方式

java学习-单例模式的多种实现方式

聊聊“单例模式”的多种实现方式。

单例模式的多种写法