设计模式-单例

最新推荐文章于 2021-08-19 17:23:50 发布
最新推荐文章于 2021-08-19 17:23:50 发布
阅读量187 收藏
点赞数 1
分类专栏： 设计模式 java 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010659671/article/details/114374446
版权

特点

  • 系统内有且只有一个实例对象；
  • 单例类的构造方法为私有的，自己持有自己的一个实例对象；
  • 开放获取实例对象的方法；

分类

单例模式主要可分为饿汉式、饱汉式、枚举式、内部类、容器式；测试代码均采用多线程测试方式。

饿汉式

在类加载时，创建一个实例，当外部获取时，直接返回创建的实例。这种方式占用了一定的内存空间、节约了在使用时创建对象的时间和资源消耗。也不用担心线程安全的问题。

public class HungrySingleton {

    private HungrySingleton(){}

    private static final HungrySingleton INSTANCE = new HungrySingleton();

    public HungrySingleton getInstance(){
        return INSTANCE;
    }
}

测试代码

	@Test
    public void testHungrySingleton() throws InterruptedException {
		ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() ->{
                HungrySingleton instance = HungrySingleton.getInstance();
                log.info("线程 {} 获取到的实例: {}",Thread.currentThread().getName(),instance);
            });
        }
    }

说明：创建10个线程分别获取HungrySingleton实例，进而知晓获取到的10个实例对象的内存地址：

2021-03-04 13:24:16.717  INFO 8428 --- [pool-1-thread-4] org.example.singleton.SingletonTest      : 线程 pool-1-thread-4 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.714  INFO 8428 --- [pool-1-thread-1] org.example.singleton.SingletonTest      : 线程 pool-1-thread-1 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.714  INFO 8428 --- [pool-1-thread-5] org.example.singleton.SingletonTest      : 线程 pool-1-thread-5 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.714  INFO 8428 --- [pool-1-thread-3] org.example.singleton.SingletonTest      : 线程 pool-1-thread-3 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.716  INFO 8428 --- [pool-1-thread-2] org.example.singleton.SingletonTest      : 线程 pool-1-thread-2 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.716  INFO 8428 --- [ool-1-thread-10] org.example.singleton.SingletonTest      : 线程 pool-1-thread-10 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.716  INFO 8428 --- [pool-1-thread-9] org.example.singleton.SingletonTest      : 线程 pool-1-thread-9 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.717  INFO 8428 --- [pool-1-thread-8] org.example.singleton.SingletonTest      : 线程 pool-1-thread-8 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.716  INFO 8428 --- [pool-1-thread-7] org.example.singleton.SingletonTest      : 线程 pool-1-thread-7 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc
2021-03-04 13:24:16.714  INFO 8428 --- [pool-1-thread-6] org.example.singleton.SingletonTest      : 线程 pool-1-thread-6 获取到的实例: org.example.singleton.HungrySingleton@1479e6cc

获取的10个实例对象内存地址相同。

懒汉式

也叫延迟加载方式，当系统需要使用时，创建实例。这种方式在类加载时，只是声明了一个空间，但并为创建实例对象，当进程内首次获取对象时，会先创建一个实例，然后返回，后续则返回第一次创建的实例。但是这种模式是线程不安全的，当出现并发时，可能会创建多个实例对象，所以需要引入锁机制来保证线程安全，本文的处理方式是 加入常用的双重检验锁。

public class LazySingleton {

    private LazySingleton(){}

    private static LazySingleton lazySingleton;

    public static LazySingleton getInstance (){
        if (lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

测试代码

	@Test
    public void testLazyWithNoDoubleLockSingleton() throws InterruptedException {
        CountDownLatch cdl = new CountDownLatch(10);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() ->{
                try {
                    //等待
                    cdl.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                LazySingleton instance = LazySingleton.getInstance();
                log.info("线程 {} 获取到的实例: {}",Thread.currentThread().getName(),instance);
            });
            //计数器-1
            cdl.countDown();
        }

        executorService.awaitTermination(5, TimeUnit.SECONDS);
        executorService.shutdown();
    }

说明：

2021-03-04 13:41:00.361  INFO 14632 --- [pool-1-thread-2] org.example.singleton.SingletonTest      : 线程 pool-1-thread-2 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.362  INFO 14632 --- [ool-1-thread-10] org.example.singleton.SingletonTest      : 线程 pool-1-thread-10 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.363  INFO 14632 --- [pool-1-thread-1] org.example.singleton.SingletonTest      : 线程 pool-1-thread-1 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.363  INFO 14632 --- [pool-1-thread-8] org.example.singleton.SingletonTest      : 线程 pool-1-thread-8 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.362  INFO 14632 --- [pool-1-thread-7] org.example.singleton.SingletonTest      : 线程 pool-1-thread-7 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.362  INFO 14632 --- [pool-1-thread-3] org.example.singleton.SingletonTest      : 线程 pool-1-thread-3 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.362  INFO 14632 --- [pool-1-thread-4] org.example.singleton.SingletonTest      : 线程 pool-1-thread-4 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.362  INFO 14632 --- [pool-1-thread-9] org.example.singleton.SingletonTest      : 线程 pool-1-thread-9 获取到的实例: org.example.singleton.LazySingleton@447e4749
2021-03-04 13:41:00.362  INFO 14632 --- [pool-1-thread-5] org.example.singleton.SingletonTest      : 线程 pool-1-thread-5 获取到的实例: org.example.singleton.LazySingleton@1bf38d27
2021-03-04 13:41:00.362  INFO 14632 --- [pool-1-thread-6] org.example.singleton.SingletonTest      : 线程 pool-1-thread-6 获取到的实例: org.example.singleton.LazySingleton@447e4749

由日志信息可知：pool-1-thread-5获取到的实例的地址与其他线程不相同，说明此种单例模式，线程不安全。

为了提升线程安全性，需要对代码进行改造，代码中引入了双重检验锁

public class LazyWithDoubleLockSingleton {

    private LazyWithDoubleLockSingleton(){}

    private static LazyWithDoubleLockSingleton lazySingleton;

    public static LazyWithDoubleLockSingleton getInstance (){
        if (lazySingleton == null){
            synchronized (LazyWithDoubleLockSingleton.class){
                if (lazySingleton == null){
                    lazySingleton = new LazyWithDoubleLockSingleton();
                }
            }
        }
        return lazySingleton;
    }
}

测试代码

    @Test
    public void testLazyWithDoubleLockSingleton() throws InterruptedException {
        CountDownLatch cdl = new CountDownLatch(20);
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        for (int i = 0; i < 20; i++) {
            executorService.submit(() ->{
                try {
                    cdl.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                LazyWithDoubleLockSingleton instance = LazyWithDoubleLockSingleton.getInstance();
                log.info("线程 {} 获取到的实例: {}",Thread.currentThread().getName(),instance);
            });
            cdl.countDown();
        }

        executorService.awaitTermination(5, TimeUnit.SECONDS);
        executorService.shutdown();
    }

说明：开启20个线程，获取实例日志信息：

2021-03-04 14:14:45.560  INFO 11008 --- [ool-1-thread-11] org.example.singleton.SingletonTest      : 线程 pool-1-thread-11 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.561  INFO 11008 --- [ool-1-thread-20] org.example.singleton.SingletonTest      : 线程 pool-1-thread-20 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.560  INFO 11008 --- [ool-1-thread-15] org.example.singleton.SingletonTest      : 线程 pool-1-thread-15 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.560  INFO 11008 --- [pool-1-thread-2] org.example.singleton.SingletonTest      : 线程 pool-1-thread-2 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.560  INFO 11008 --- [pool-1-thread-4] org.example.singleton.SingletonTest      : 线程 pool-1-thread-4 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.562  INFO 11008 --- [pool-1-thread-8] org.example.singleton.SingletonTest      : 线程 pool-1-thread-8 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.559  INFO 11008 --- [pool-1-thread-5] org.example.singleton.SingletonTest      : 线程 pool-1-thread-5 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.559  INFO 11008 --- [pool-1-thread-6] org.example.singleton.SingletonTest      : 线程 pool-1-thread-6 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.559  INFO 11008 --- [pool-1-thread-3] org.example.singleton.SingletonTest      : 线程 pool-1-thread-3 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.559  INFO 11008 --- [ool-1-thread-18] org.example.singleton.SingletonTest      : 线程 pool-1-thread-18 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.559  INFO 11008 --- [ool-1-thread-19] org.example.singleton.SingletonTest      : 线程 pool-1-thread-19 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.559  INFO 11008 --- [pool-1-thread-7] org.example.singleton.SingletonTest      : 线程 pool-1-thread-7 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.564  INFO 11008 --- [ool-1-thread-17] org.example.singleton.SingletonTest      : 线程 pool-1-thread-17 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.558  INFO 11008 --- [ool-1-thread-12] org.example.singleton.SingletonTest      : 线程 pool-1-thread-12 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.564  INFO 11008 --- [pool-1-thread-1] org.example.singleton.SingletonTest      : 线程 pool-1-thread-1 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.564  INFO 11008 --- [ool-1-thread-10] org.example.singleton.SingletonTest      : 线程 pool-1-thread-10 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.564  INFO 11008 --- [ool-1-thread-14] org.example.singleton.SingletonTest      : 线程 pool-1-thread-14 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.560  INFO 11008 --- [pool-1-thread-9] org.example.singleton.SingletonTest      : 线程 pool-1-thread-9 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.560  INFO 11008 --- [ool-1-thread-16] org.example.singleton.SingletonTest      : 线程 pool-1-thread-16 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446
2021-03-04 14:14:45.560  INFO 11008 --- [ool-1-thread-13] org.example.singleton.SingletonTest      : 线程 pool-1-thread-13 获取到的实例: org.example.singleton.LazyWithDoubleLockSingleton@2bde9446

由以上日志信息可知，加了双重检验锁后，20个线程获取的实例均相同。

枚举式

枚举式单例，线程安全

  1. 定义一个类Person
public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
}
  1. 定义枚举
@Getter
public enum  EnumSingleton {

    PERSON(new Person("befory"));

    private Person person;

    EnumSingleton(Person person) {
        this.person = person;
    }
}

测试代码

    @Test
    public void testEnumSingleton() throws InterruptedException {
        CountDownLatch cdl = new CountDownLatch(10);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() ->{
                try {
                    cdl.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Person instance = EnumSingleton.PERSON.getPerson();
                log.info("线程 {} 获取到的实例: {}",Thread.currentThread().getName(),instance);
            });
            cdl.countDown();
        }

        executorService.awaitTermination(5, TimeUnit.SECONDS);
        executorService.shutdown();
    }

运行日志信息：

2021-03-04 14:17:10.939  INFO 11688 --- [pool-1-thread-3] org.example.singleton.SingletonTest      : 线程 pool-1-thread-3 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.938  INFO 11688 --- [pool-1-thread-1] org.example.singleton.SingletonTest      : 线程 pool-1-thread-1 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.939  INFO 11688 --- [pool-1-thread-8] org.example.singleton.SingletonTest      : 线程 pool-1-thread-8 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.939  INFO 11688 --- [pool-1-thread-5] org.example.singleton.SingletonTest      : 线程 pool-1-thread-5 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.940  INFO 11688 --- [pool-1-thread-6] org.example.singleton.SingletonTest      : 线程 pool-1-thread-6 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.939  INFO 11688 --- [pool-1-thread-9] org.example.singleton.SingletonTest      : 线程 pool-1-thread-9 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.939  INFO 11688 --- [pool-1-thread-7] org.example.singleton.SingletonTest      : 线程 pool-1-thread-7 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.938  INFO 11688 --- [ool-1-thread-10] org.example.singleton.SingletonTest      : 线程 pool-1-thread-10 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.938  INFO 11688 --- [pool-1-thread-4] org.example.singleton.SingletonTest      : 线程 pool-1-thread-4 获取到的实例: org.example.singleton.Person@34f864c5
2021-03-04 14:17:10.938  INFO 11688 --- [pool-1-thread-2] org.example.singleton.SingletonTest      : 线程 pool-1-thread-2 获取到的实例: org.example.singleton.Person@34f864c5

结论：地址相同

内部类

也叫登记式，类部拥有一个静态内部类，静态内部类中拥有一个实例化的对象，一个类中可以拥有多个静态内部类，它可以实现多种策略的单例模式，由于静态内部类加载机制，这种方式属于延迟加载（在使用时加载），但同时它又保证了线程安全。

public class InnerSingleton {

    private InnerSingleton(){}

    public static class Holder{
        public static  InnerSingleton INSTANCE = new InnerSingleton();
    }
}

测试代码

    @Test
    public void testInnerSingleton() throws InterruptedException {
        CountDownLatch cdl = new CountDownLatch(10);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() ->{
                try {
                    cdl.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                InnerSingleton instance = InnerSingleton.Holder.INSTANCE;
                log.info("线程 {} 获取到的实例: {}",Thread.currentThread().getName(),instance);
            });
            cdl.countDown();
        }

        executorService.awaitTermination(5, TimeUnit.SECONDS);
        executorService.shutdown();
    }

运行日志

2021-03-04 14:24:59.135  INFO 14160 --- [pool-1-thread-8] org.example.singleton.SingletonTest      : 线程 pool-1-thread-8 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.134  INFO 14160 --- [pool-1-thread-1] org.example.singleton.SingletonTest      : 线程 pool-1-thread-1 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.135  INFO 14160 --- [pool-1-thread-3] org.example.singleton.SingletonTest      : 线程 pool-1-thread-3 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.135  INFO 14160 --- [pool-1-thread-2] org.example.singleton.SingletonTest      : 线程 pool-1-thread-2 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.136  INFO 14160 --- [pool-1-thread-9] org.example.singleton.SingletonTest      : 线程 pool-1-thread-9 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.135  INFO 14160 --- [pool-1-thread-5] org.example.singleton.SingletonTest      : 线程 pool-1-thread-5 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.135  INFO 14160 --- [pool-1-thread-6] org.example.singleton.SingletonTest      : 线程 pool-1-thread-6 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.135  INFO 14160 --- [pool-1-thread-7] org.example.singleton.SingletonTest      : 线程 pool-1-thread-7 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.135  INFO 14160 --- [pool-1-thread-4] org.example.singleton.SingletonTest      : 线程 pool-1-thread-4 获取到的实例: org.example.singleton.InnerSingleton@5c1be49
2021-03-04 14:24:59.135  INFO 14160 --- [ool-1-thread-10] org.example.singleton.SingletonTest      : 线程 pool-1-thread-10 获取到的实例: org.example.singleton.InnerSingleton@5c1be49

日志信息显示 内存地址相同

容器式

容器式单例与其他几种类型单例不同，容器式单例需要先创建一个容器的实例，容器是单例。这种方式也是springIOC容器实现的一种方式

public class ContainerSingleton {

    // 定义容器
    private static final ConcurrentHashMap<String,Person> CONTAINER =  new ConcurrentHashMap<>();

    public static Person getInstance(String name){
        if (CONTAINER.containsKey(name)){
            return CONTAINER.get(name);
        }
        Person person = new Person("befory");
        CONTAINER.put(name,person);
        return person;
    }
}

测试代码

    @Test
    public void testContainerSingleton() throws InterruptedException {
        CountDownLatch cdl = new CountDownLatch(10);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() ->{
                try {
                    cdl.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Person instance = ContainerSingleton.getInstance("befory");
                log.info("线程 {} 获取到的实例: {}",Thread.currentThread().getName(),instance);
            });
            cdl.countDown();
        }

        executorService.awaitTermination(5, TimeUnit.SECONDS);
        executorService.shutdown();
    }

日志信息

2021-03-04 17:05:39.718  INFO 15456 --- [pool-1-thread-7] org.example.singleton.SingletonTest      : 线程 pool-1-thread-7 获取到的实例: org.example.singleton.Person@4d914f9d
2021-03-04 17:05:39.717  INFO 15456 --- [pool-1-thread-4] org.example.singleton.SingletonTest      : 线程 pool-1-thread-4 获取到的实例: org.example.singleton.Person@4df33374
2021-03-04 17:05:39.718  INFO 15456 --- [pool-1-thread-3] org.example.singleton.SingletonTest      : 线程 pool-1-thread-3 获取到的实例: org.example.singleton.Person@22230c
2021-03-04 17:05:39.718  INFO 15456 --- [pool-1-thread-8] org.example.singleton.SingletonTest      : 线程 pool-1-thread-8 获取到的实例: org.example.singleton.Person@56e930d4
2021-03-04 17:05:39.717  INFO 15456 --- [ool-1-thread-10] org.example.singleton.SingletonTest      : 线程 pool-1-thread-10 获取到的实例: org.example.singleton.Person@539d2805
2021-03-04 17:05:39.717  INFO 15456 --- [pool-1-thread-2] org.example.singleton.SingletonTest      : 线程 pool-1-thread-2 获取到的实例: org.example.singleton.Person@5b1cf141
2021-03-04 17:05:39.719  INFO 15456 --- [pool-1-thread-9] org.example.singleton.SingletonTest      : 线程 pool-1-thread-9 获取到的实例: org.example.singleton.Person@1244b7e5
2021-03-04 17:05:39.720  INFO 15456 --- [pool-1-thread-6] org.example.singleton.SingletonTest      : 线程 pool-1-thread-6 获取到的实例: org.example.singleton.Person@1244b7e5
2021-03-04 17:05:39.717  INFO 15456 --- [pool-1-thread-5] org.example.singleton.SingletonTest      : 线程 pool-1-thread-5 获取到的实例: org.example.singleton.Person@72896df6
2021-03-04 17:05:39.720  INFO 15456 --- [pool-1-thread-1] org.example.singleton.SingletonTest      : 线程 pool-1-thread-1 获取到的实例: org.example.singleton.Person@1244b7e5

由上面日志信息可知，发现创建了多个Person实例对象。所以需要对其进行改造，改造代码如下：

public class ContainerSingleton {

    // 定义容器
    private static final ConcurrentHashMap<String,Person> CONTAINER =  new ConcurrentHashMap<>();

    public static Person getInstance(String name){
        if (!CONTAINER.containsKey(name)){
            synchronized (ContainerSingleton.class){
                if (!CONTAINER.containsKey(name)){
                    Person person = new Person("befory");
                    CONTAINER.put(name,person);
                }
            }
        }
        return CONTAINER.get(name);
    }
}

类似懒汉式单例中加强线程安全做法，加了检验机制，获取到的日志信息如下：

2021-03-04 17:12:36.987  INFO 15480 --- [pool-1-thread-8] org.example.singleton.SingletonTest      : 线程 pool-1-thread-8 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.987  INFO 15480 --- [pool-1-thread-1] org.example.singleton.SingletonTest      : 线程 pool-1-thread-1 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.989  INFO 15480 --- [pool-1-thread-5] org.example.singleton.SingletonTest      : 线程 pool-1-thread-5 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.987  INFO 15480 --- [pool-1-thread-9] org.example.singleton.SingletonTest      : 线程 pool-1-thread-9 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.990  INFO 15480 --- [pool-1-thread-6] org.example.singleton.SingletonTest      : 线程 pool-1-thread-6 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.990  INFO 15480 --- [ool-1-thread-10] org.example.singleton.SingletonTest      : 线程 pool-1-thread-10 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.988  INFO 15480 --- [pool-1-thread-3] org.example.singleton.SingletonTest      : 线程 pool-1-thread-3 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.990  INFO 15480 --- [pool-1-thread-4] org.example.singleton.SingletonTest      : 线程 pool-1-thread-4 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.991  INFO 15480 --- [pool-1-thread-2] org.example.singleton.SingletonTest      : 线程 pool-1-thread-2 获取到的实例: org.example.singleton.Person@25fa0461
2021-03-04 17:12:36.987  INFO 15480 --- [pool-1-thread-7] org.example.singleton.SingletonTest      : 线程 pool-1-thread-7 获取到的实例: org.example.singleton.Person@25fa0461

经过多次运行查看，从日志信息显示，获取实例地址均相同。

结论

各种方式的单例，都有各自的缺点，本文只是对线程安全上进行了对比与验证，得出的诸多结论。

befory
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
Java设计模式-单例模式详解
11-24
Java设计模式-单例模式详解 单例模式是 Java 设计模式中的一种常用的设计模式，旨在保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式的目的是为了保证在一个进程中，某个类有且仅有一个实例。 ...
常见设计模式-单例模式
07-06
单例模式是设计模式中的一种，其主要目的是确保一个类只有一个实例，并且提供一个全局访问点来获取这个实例。在Java编程中，实现单例模式有多种方式，每种方式都有其优缺点。 1. **饿汉式**： 饿汉式在类加载时即...
java设计模式-单例.pdf
最新发布
05-16
设计模式 java设计模式-单例.pdf
c++设计模式-单例模式
06-03
**单例模式**是软件设计模式中的一种，属于创建型模式。在C++中，单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于管理共享资源，如数据库连接、日志系统或者配置文件等。单例模式的主要...
Feign异常捕获
befory
02-20 6259
说明 在分布式系统中，系统与系统之间通常使用FeignClient进行数据交互，但当被调用方需要抛出特定异常时，调用方不能捕获到异常信息进行业务处理，本文档对此种现象进行了说明，并提供一种解决方案。 准备 代码准备 client <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign&..
Springboot-Admin集成钉钉机器人推送通知
befory
03-11 982
Springboot-Admin集成钉钉机器人推送通知 参考文档 https://ding-doc.dingtalk.com/doc#/serverapi2/qf2nxq/e9d991e2 https://blog.csdn.net/u010433956/article/details/106350871/ 背景说明 之前尝试采用邮件推送通知，由于阿里云需要配置smtp邮件发送相关服务，才能发送邮件，另外邮件通知并不及时，平时办公也会使用钉钉，钉钉已经是工作中不可缺少的一部分，另外群机器人创建过程中
设计模式-工厂设计模式
befory
03-09 895
特点 工厂模式属于创建型，是生成创建复杂对象的一种设计模式。通常情况下，工厂模式被分为工厂模式和抽象工厂模式。其中工厂模式也被称为简单工厂模式，它的每一个工厂都是一个单例。抽象工厂模式即为将每个工厂的一些步骤抽象化，达到代码复用的目的。 工厂模式 假使存在一个制造手机的工厂，工厂存在2条生产线，一条制造MiPhone，1条制造HuaPhone；手机存在拨打电话和发送短信的功能。 手机功能接口类 public interface Phone { void call(); void se
springboot 全局配置时间格式化
befory
02-23 700
springboot 全局配置时间格式化 在web项目中，后台服务返回给前端的时间格式若未配置，则返回的数据可能是时间戳或者数组，例子如下： entity 类型LocalDateTime { "id": 5, "name": null, "age": null, "jsonStr": null, "ct": "2020-08-04T14:56:54.971" } entity 类型为Date,时间为时间戳 { "id": 5,
idea创建模板类和方法
befory
03-11 277
需求和背景 在很多时候，我们经常会在类和方法上面添加一些注释信息，例如： /** * @author bys * @version 1.0 * @description // TODO: 2021/3/10 * @since 2021/3/10 */ IDEA 提供了对操作的模板的设置方式； 在类上添加模板注释 打开settings找到 File | Settings | Editor | File and Code Templates ，然后找到Class，修改内容： #if (${PACKA
位运算操作整理
befory
08-19 160
在各种源码中，都会存在位运算的操作，总是不晓得它的意思，抽时间整理一下，在了解位操作运算符之前，需要能了解10进制和2进制之间如何转换； 十进制和二进制 十进制转二进制 无符号转换 例如将10转换为二进制就是0000 0000 0000 0000 0000 0000 0000 1010，原理如图: 不断将十进制数除以2，直至最后的值为0，然后将每步的余数按照箭头方向从高位到低位组合得到1010，但是int类型在java中是32位，所以需要将前面补0，最后则为0000 0000 0000 0000 0000
设计模式-原型模式
befory
03-11 128
特点 原型模式属于创建型。用于创建拷贝复杂对象，避免重复创建对象发生的资源损耗，在一定程度上提升了性能。原型模式主要被分为浅拷贝和深拷贝2种模式，它主要实现了接口Cloneable，重写Object类中的clone方法。 浅拷贝 浅拷贝只能对基本类型(long,double,float,int,short,byte,boolean,char)和String类型有效果，对复杂的类型只能不能有效果。 public class Car implements Cloneable{ private Stri
设计模式-过滤器模式
befory
03-15 127
特点 过滤器模式也叫标准模式，允许开发人员根据标准过滤一组对象，通过逻辑运算解耦应用程序。 程序代码 pojo 对象Person类 @Slf4j @Data @Accessors(chain = true) public class Person { private int age; private boolean married; private int sex; } 标准接口类 public interface Criterion { List<Per
备忘录设计模式
befory
03-05 114
特点 备忘录模式通常来讲有3个类，一个需要备忘存档的Memo类，一个发起者Initiator，还有一个管理Meno的类MenoManager。备忘录模式运用也比较广泛，如：撤销、回滚、悔棋、游戏存档等场景。备忘录模式解耦了Initiator和MomeManager、能查看到一定时期的历史数据、能防止误操作等优点，但同时也最大的缺点会产生大量的历史数据、会比较占用空间。本文将实现一个比较容易的存档和回滚到某个时间段的功能。 类图如下: 说明 : Memo 为一个pojo，拥有content和time字段；
代理模式-JDK动态代理
befory
03-26 110
特点 动态代理是AOP的核心技术，JDK的动态代理主要基于java.lang.reflect.InvocationHandler与java.lang.reflect.Proxy类，通过反射技术创建代理对象。 实现 创建一个@Before注解，在Sales接口上加上注解 public interface Sales { @Before void sale(Goods goods); } 创建一个InvocationHandler，实现invoke方法 @Slf4j public class
代理模式-静态代理
befory
03-26 109
特点 代理模式表示代理一个类的功能，主要关注点在于控制。属于结构性模式。一般分为静态代理和动态代理，其中静态代理在结构上与适配器模式、包装器模式非常相似。动态代理一般会被分为JDK动态代理和Cglib动态代理，前者只能代理接口，后者可代理具体类。 实现示例 静态代理需要代理对象与被代理对象都实现同一个接口，然后在代理对象内实现控制逻辑。 模拟商品代理的过程，当商品生产后，工厂售卖商品，代理商代理工厂也售卖商品，代理商售卖商品前需要对商品加价处理。 商品类 public class Goods {
设计模式-桥接模式
befory
03-12 92
特点 桥接模式属于结构型，它的主要特点在于，多维度接口都能独立变化，抽象和实现分离、然后聚合关联关系。 代码示例 先后定义一个画笔和形状，画笔有红色和绿色、形状有方形和圆形。当需要画图形时，就需要将画笔和形状链接。 画笔接口 public interface Brush { String color(); } 形状接口 public interface Shape { String shape(); } 画笔实现类 @Slf4j public class GreenBrush
设计模式-外观模式
befory
03-17 75
外观模式也叫门面模式，它只涉及单一的类，即对外提供一个接口类，适用方无须知道具体实现，通常封装的工具类、mvc模式的controller等都是门面模式的应用。该模式符合迪米特法则。属于结构型模式。 ...
聊聊设计模式-单例模式
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值