设计模式之单例模式

_AndyLau

已于 2024-10-06 22:34:57 修改

阅读量266

点赞数 9

文章标签：设计模式 javascript 开发语言

于 2024-10-06 22:30:59 首次发布

本文链接：https://blog.csdn.net/andyliu198571/article/details/142732959

版权

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

单例模式分为懒汉式和饿汉式

饿汉式

所谓饿汉式是指，无论在程序运行期间是否需要该对象，都会提前创建一个单例对象。该方式存在的缺点，创建的对象可能在程序运行期间没有被使用过，占用了堆内存空间。

package com.xxx.sigleton;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 10:06
 * @email 115176513@qq.com
 * @description: TODO
 */

public class HungrySingleton {
    private static HungrySingleton singleton = new HungrySingleton();
    private HungrySingleton(){

    }
    public static HungrySingleton getInstance(){
        return singleton;
    }

    public static void main(String[] args) {
        HungrySingleton instance = HungrySingleton.getInstance();
        HungrySingleton instance2 = HungrySingleton.getInstance();
        System.out.println(instance==instance2);
    }
}

原理

采用private构造，通过静态成员变量只能加载一次的原理，实现单例模式。

线程安全测试

package com.xxx.sigleton;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 10:09
 * @email 115176513@qq.com
 * @description: TODO
 */

public class TestHungrySingleton {
    public static void main(String[] args) throws Exception {
        ExecutorService service = Executors.newFixedThreadPool(3);
        Future<HungrySingleton> submit = service.submit(new HungryCallable());
        Future<HungrySingleton> submit2 = service.submit(new HungryCallable());

        HungrySingleton hungrySingleton = submit.get();
        HungrySingleton hungrySingleton2 = submit2.get();
        System.out.println(hungrySingleton==hungrySingleton2);
    }
    static class HungryCallable implements Callable<HungrySingleton>{
        @Override
        public HungrySingleton call() throws Exception {
            return HungrySingleton.getInstance();
        }
    }
}

枚举

package com.xxx.sigleton;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 15:20
 * @email 115176513@qq.com
 * @description: TODO
 */

public enum EnumSingleton {
    INSTANCE

}

懒汉式

私有构造方式

package com.xxx.sigleton;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 10:21
 * @email 115176513@qq.com
 * @description: TODO
 */

public class SingletonObject {
    private static SingletonObject instance;
    private SingletonObject(){

    }
    public static SingletonObject getInstance(){
        if(instance==null){
            instance = new SingletonObject();
        }
        return instance;
    }

    public static void main(String[] args) {
        SingletonObject object = SingletonObject.getInstance();
        SingletonObject object2 = SingletonObject.getInstance();
        System.out.println(object==object2);
    }
}

多线程测试

package com.xxx.sigleton;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 10:21
 * @email 115176513@qq.com
 * @description: TODO
 */

public class SingletonObject {
    private static SingletonObject instance;
    private SingletonObject(){

    }
    public static SingletonObject getInstance(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(instance!=null){

        }else{
            instance = new SingletonObject();

        }
        return instance;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread = new Thread(() -> {
            SingletonObject instance = SingletonObject.getInstance();
            System.out.println(Thread.currentThread().getName() + ":" + instance.hashCode());
        });
        Thread thread2 = new Thread(() -> {
            SingletonObject instance = SingletonObject.getInstance();
            System.out.println(Thread.currentThread().getName() + ":" + instance.hashCode());
        });
        thread.start();
        thread2.start();

    }
}

Thread-0:786680875
Thread-1:641158370

Process finished with exit code 0

同步锁

package com.xxx.sigleton;

import java.util.concurrent.ExecutionException;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 10:21
 * @email 115176513@qq.com
 * @description: TODO
 */

public class SingletonObject2 {
    private static SingletonObject2 instance;
    private SingletonObject2(){

    }
    public static synchronized SingletonObject2 getInstance(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(instance!=null){

        }else{
            instance = new SingletonObject2();

        }
        return instance;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread = new Thread(() -> {
            SingletonObject2 instance = SingletonObject2.getInstance();
            System.out.println(Thread.currentThread().getName() + ":" + instance.hashCode());
        });
        Thread thread2 = new Thread(() -> {
            SingletonObject2 instance = SingletonObject2.getInstance();
            System.out.println(Thread.currentThread().getName() + ":" + instance.hashCode());
        });
        thread.start();
        thread2.start();

    }
}

双重检查锁

package com.xxx.sigleton;

import java.util.concurrent.ExecutionException;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 10:21
 * @email 115176513@qq.com
 * @description: TODO
 */

public class SingletonObject2 {
    private static volatile SingletonObject2 instance;
    private SingletonObject2(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static  SingletonObject2 getInstance(){
        if(instance==null){
            synchronized (SingletonObject2.class){
                if(instance==null){
                    // 不是原子操作
                    instance = new SingletonObject2();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread = new Thread(() -> {
            SingletonObject2 instance = SingletonObject2.getInstance();
            System.out.println(Thread.currentThread().getName() + ":" + instance.hashCode());
        });
        Thread thread2 = new Thread(() -> {
            SingletonObject2 instance = SingletonObject2.getInstance();
            System.out.println(Thread.currentThread().getName() + ":" + instance.hashCode());
        });
        thread.start();
        thread2.start();

    }
}

静态内部类

package com.xxx.sigleton;

/**
 * @packageName: com.xxx.sigleton
 * @user: andyliu
 * @date: 2023/4/15 15:06
 * @email 115176513@qq.com
 * @description: TODO
 */

public class SingletonObject3 {

    private SingletonObject3(){

    }
    static class InnerClass{
        private static SingletonObject3 instance=new SingletonObject3();
        public static SingletonObject3 getInstance(){
            return InnerClass.instance;
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            SingletonObject3 obj = SingletonObject3.InnerClass.getInstance();
            System.out.println(Thread.currentThread().getName()+":"+obj.hashCode());
        });
        Thread t2 = new Thread(()->{
            SingletonObject3 obj = SingletonObject3.InnerClass.getInstance();
            System.out.println(Thread.currentThread().getName()+":"+obj.hashCode());
        });
        t1.start();
        t2.start();
    }
}