单例模式的一点研究

最新推荐文章于 2026-01-02 21:21:45 发布
原创 最新推荐文章于 2026-01-02 21:21:45 发布 · 362 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#string #class #null #thread #多线程 #jvm

单例模式(singleton)是常用的设计模式，它只允许一个类被实例化1次。实现机制，定义或声明一个本类类型的静态域用来保存本类的实例，将构造方法私有化，提供一个公有的静态方法用来返回本类的实例。

单例模式有多重实现方法。

例1，饿汉式

/**
 * 单线程下饿汉单例模式
 */
package pattern.singleton.singleThread.hunger;

public class HungerSingleton {

    private static HungerSingleton instance = new HungerSingleton();

    private HungerSingleton() {
        System.out.println("正在实例化HungerSingleton");
    }

    public static HungerSingleton getInstance() {
        return instance;
    }

    public static void print() {
        System.out.println("aaa");
    }

}

此例中HungerSingleton保存了一个本类实例的引用。并提供一个静态方法返回此实例getInstance()。

主函数：

/**
 * 单例模式实验
 */
package pattern.singleton;

import pattern.singleton.singleThread.hunger.HungerSingleton;

public class SingletonTest {

    public static void main(String[] args) {
        HungerSingleton singleton1;
        System.out.println("声明了一个HungerSingleton");
        HungerSingleton.print();
        for (int i = 0; i < 10; i++) {
            singleton1 = HungerSingleton.getInstance();
            System.out.println("singleton1--" + i + " 是 " + singleton1);
        }
    }
}

运行结果：

------------------------------------Console--------------------------------------

声明了一个HungerSingleton
正在实例化HungerSingleton
aaa
singleton1--0 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--1 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--2 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--3 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--4 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--5 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--6 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--7 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--8 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d
singleton1--9 是 pattern.singleton.singleThread.hunger.HungerSingleton@4f1d0d

--------------------------------------------------------------------------------------

从结果上可以看到HungerSingleton的构造方法只被调用了一次。for循环中得到的所有的HungerSingleton的实例的地址都是相同的，也就是HungerSingleton只有一个实例。

#################################################

例2：懒汉式

/**
 * 单线程下懒汉单例模式
 */
package pattern.singleton.singleThread.lazy;

public class LazySingleton {

    private static LazySingleton instance = null;

    private LazySingleton() {
        System.out.println("正在实例化LazySingleton");
    }

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

    public static void print() {
        System.out.println("aaa");
    }

}

此例中静态域instance的初始值是null。在调用getInstance()中判断instance是否引用一个实例。否则构造一个实例。这样可以保证类在需要实例化时才构造这个实例。而不是在加载这个类时就实例化这个类。

主函数：

/**
 * 单例模式实验
 */
package pattern.singleton;

import pattern.singleton.singleThread.lazy.LazySingleton;

public class SingletonTest {

    public static void main(String[] args) {
        LazySingleton singleton1;
        System.out.println("声明了一个LazySingleton");
        LazySingleton.print();
        for (int i = 0; i < 10; i++) {
            singleton1 = LazySingleton.getInstance();
            System.out.println("singleton1--" + i + " 是 " + singleton1);
        }
    }
}

运行结果：

------------------------------------Console--------------------------------------

声明了一个LazySingleton
aaa
正在实例化LazySingleton
singleton1--0 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--1 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--2 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--3 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--4 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--5 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--6 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--7 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--8 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d
singleton1--9 是 pattern.singleton.singleThread.lazy.LazySingleton@4f1d0d

--------------------------------------------------------------------------------------

跟例1比较，可以看出在调用静态方法print()时。LazySingleton类并没有构造实例，而是在for循环中第一次构造。并且仍能保证单实例。

#################################################

多线程下的单例问题

改造一下例1：

/**
 * 多线程下饿汉单例
 */
package pattern.singleton.multiThread.hunger;

public class HungerSingletonT {

    private static HungerSingletonT instance = new HungerSingletonT();

    private HungerSingletonT() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("正在实例化HungerSingletonT");
    }

    public static HungerSingletonT getInstance() {
        return instance;
    }

    public static void print(String threadName) {
        System.out.println(threadName + " aaa");
    }

}

在构造方法中增加一个睡眠。

测试类：

package pattern.singleton.multiThread;

import pattern.singleton.multiThread.hunger.HungerSingletonT;

public class MultiThreadTest {

    public static void main(String[] args) {
        SingletonUser s1 = new SingletonUser("s1");
        SingletonUser s2 = new SingletonUser("s2");
    }

}

class SingletonUser implements Runnable {

    private String threadName;

    public SingletonUser(String threadName) {
        this.threadName = threadName;
        Thread t = new Thread(this, threadName);
        t.start();
    }

    @Override
    public void run() {
        HungerSingletonT singleton;
        System.out.println("线程 " + threadName + " 声明了一个singleton");
        HungerSingletonT.print(threadName);
        for (int i = 0; i < 10; i++) {
            singleton = HungerSingletonT.getInstance();
            System.out.println(threadName + " : singleton--" + i + " 是 " + singleton);
        }
    }

}

运行结果：

------------------------------------Console--------------------------------------

线程 s2 声明了一个singleton
线程 s1 声明了一个singleton
正在实例化HungerSingletonT
s2 aaa
s2 : singleton--0 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--1 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--2 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--3 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--4 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--5 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--6 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--7 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 aaa
s1 : singleton--0 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--8 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s2 : singleton--9 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--1 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--2 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--3 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--4 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--5 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--6 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--7 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--8 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7
s1 : singleton--9 是 pattern.singleton.multiThread.hunger.HungerSingletonT@10b30a7

--------------------------------------------------------------------------------------

JVM的运行机制可以保证一个类在被加载的过程中是线程互斥的。饿汉的先行加载使得HungerSingletonT在第一次加载时实例化已完成。所以饿汉式单例是线程安全的。

#################################################

多线程下懒汉式单例问题。

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
设有线程t1和t2，t1在判断完instance==null之后进入到实例化LazySingleton，此时t2也执行到这里，判断instance==null。由于t1的实例化尚未完成，此时instance==null仍为true。所以t2顺利进行new LazySingleton()。于是LazySingleton被实例化了两次。所以懒汉式单例在多线程下是不安全的。

如下例所示：

/**
 * 多线程下的懒汉式单例
 */
package pattern.singleton.multiThread.lazy;

public class LazySingletonT {

    private static LazySingletonT instance = null;

    private LazySingletonT(String str) {
        System.out.println(str + " 正在实例化LazySingletonT");
    }

    public static LazySingletonT getInstance(String str) {
        if (instance == null) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new LazySingletonT(str);
        }
        return instance;
    }

    public static void print(String str) {
        System.out.println(str + " aaa");
    }

}

测试类： 

package pattern.singleton.multiThread;

import pattern.singleton.multiThread.lazy.LazySingletonT;

public class MultiThreadTest {

    public static void main(String[] args) {
        SingletonUser s1 = new SingletonUser("s1");
        SingletonUser s2 = new SingletonUser("s2");
    }

}

class SingletonUser implements Runnable {

    private String threadName;

    public SingletonUser(String threadName) {
        this.threadName = threadName;
        Thread t = new Thread(this, threadName);
        t.start();
    }

    @Override
    public void run() {
        LazySingletonT singleton;
        System.out.println("线程 " + threadName + " 声明了一个singleton");
        LazySingletonT.print(threadName);
        for (int i = 0; i < 10; i++) {
            singleton = LazySingletonT.getInstance(threadName);
            System.out.println(threadName + " : singleton--" + i + " 是 " + singleton);
        }
    }

}

运行结果：

------------------------------------Console--------------------------------------

线程 s2 声明了一个singleton
线程 s1 声明了一个singleton
s2 aaa
s1 aaa
s1 正在实例化LazySingletonT
s1 : singleton--0 是 pattern.singleton.multiThread.lazy.LazySingletonT@10b30a7
s1 : singleton--1 是 pattern.singleton.multiThread.lazy.LazySingletonT@10b30a7
s2 正在实例化LazySingletonT
s2 : singleton--0 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--2 是 pattern.singleton.multiThread.lazy.LazySingletonT@10b30a7
s1 : singleton--3 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--1 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--2 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--3 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--4 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--5 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--6 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--7 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--8 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--9 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--4 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--5 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--6 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--7 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--8 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--9 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb

--------------------------------------------------------------------------------------

不难看出s1和s2分别实例化了一次LazySingletonT。

多线程下如何实现单例模式的延迟加载。我们先来改进一下懒汉式单例，给他增加一个锁synchronized。

例3：

public static synchronized LazySingletonT getInstance(String str) {
        if (instance == null) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new LazySingletonT(str);
        }
        return instance;
    }

运行结果：

------------------------------------Console--------------------------------------

线程 s2 声明了一个singleton
线程 s1 声明了一个singleton
s2 aaa
s1 aaa
s2 正在实例化LazySingletonT
s2 : singleton--0 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--1 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--2 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--3 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--4 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--5 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--6 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--7 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--8 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s2 : singleton--9 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--0 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--1 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--2 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--3 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--4 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--5 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--6 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--7 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--8 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb
s1 : singleton--9 是 pattern.singleton.multiThread.lazy.LazySingletonT@1a758cb

--------------------------------------------------------------------------------------

看样子问题得到解决了。但新的问题是每一次调用getInstance都必须得到LazySingletonT的锁才行。而事实上只有第一次实例化时才需要锁住LazySingletonT，其他的时候getInstance只是返回已存在的LazySingletonT实例的引用，没必要获得锁。此例虽然解决了单例的互斥问题，但却影响了性能。

#################################################

整个方法需要获得对象锁会影响性能，那么只把实例化的部分放到同步块中会如何呢。

例4：双检锁

/**
 * 双检锁单例模式
 */
package pattern.singleton.multiThread.lazy;

public class DCLSingleton {

    private static DCLSingleton instance = null;

    private DCLSingleton(String str) {
        System.out.println("线程 " + str + " 正在实例化DCLSingleton");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void print(String str) {
        System.out.println(str + " aaa");
    }

    public static DCLSingleton getInstance(String str) {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null) {
                    instance = new DCLSingleton(str);
                }
            }
        }
        return instance;
    }

}

这里很多帖子这样写synchronized(instance)，这会抛出空指针异常(NullPointerException)。因为此时instance是空。线程无法获得对象锁。

测试类：

package pattern.singleton.multiThread;

import pattern.singleton.multiThread.lazy.DCLSingleton;

public class MultiThreadTest {

    public static void main(String[] args) {
        SingletonUser s1 = new SingletonUser("s1");
        SingletonUser s2 = new SingletonUser("s2");
    }

}

class SingletonUser implements Runnable {

    private String threadName;

    public SingletonUser(String threadName) {
        this.threadName = threadName;
        Thread t = new Thread(this, threadName);
        t.start();
    }

    @Override
    public void run() {
        DCLSingleton singleton;
        System.out.println("线程 " + threadName + " 声明了一个singleton");
        DCLSingleton.print(threadName);
        for (int i = 0; i < 10; i++) {
            singleton = DCLSingleton.getInstance(threadName);
            System.out.println(threadName + " : singleton--" + i + " 是 " + singleton);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

运行结果：

------------------------------------Console--------------------------------------

线程 s1 声明了一个singleton
线程 s2 声明了一个singleton
s1 aaa
线程 s1 正在实例化DCLSingleton
s2 aaa
s2 : singleton--0 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--0 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--1 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--1 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--2 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--2 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--3 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--3 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--4 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--4 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--5 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--5 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--6 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--6 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--7 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--7 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--8 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--8 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s2 : singleton--9 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7
s1 : singleton--9 是 pattern.singleton.multiThread.lazy.DCLSingleton@10b30a7

--------------------------------------------------------------------------------------

s1，s2两个线程。s1第一次判断instance==null为true，获得对象锁。再次判断instance==null仍为true，开始实例化DCLSingleton。此时s2第一次判断instance==null，由于instance尚未实例化完成，结果仍是true，s2等待对象锁。直到线程s1执行实例化完成释放锁，此时instance不再是空。JVM不保证new语句和赋值语句的执行顺序，但都在同步块中，JVM可以保证这些语句都执行完毕才释放锁。所以，当s2获得对象锁时进行第二次判断instance==null，此时的结果为false。s2不再实例化DCLSingleton。双检锁机制可以实现单例模式。

#################################################

双检锁经过了多次判断，而且仍然有等待的时间。事实上饿汉式已经提供了一个互斥问题的解决方法。就是利用JVM本身的对于类加载过程是互斥的机制。将问题交给虚拟机来优化，提高性能。所要解决的就是延迟加载的问题。就是instance=new Singleton()的new操作只有在需要时才执行。可以把它放在一个类里，这个类在第一次加载时才会执行new操作。内部类可以胜任这个工作。

例5：

package pattern.singleton.multiThread.lazy;

public class ICSingleton {

    private ICSingleton() {
        System.out.println("正在实例化ICSingleton");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class InnerHandle {
        private static ICSingleton instance = new ICSingleton();
    }

    public static ICSingleton getInstance() {
        return InnerHandle.instance;
    }

    public static void print(String str) {
        System.out.println(str + " aaa");
    }

}

测试类： 

package pattern.singleton.multiThread;

import pattern.singleton.multiThread.lazy.ICSingleton;

public class MultiThreadTest {

    public static void main(String[] args) {
        SingletonUser s1 = new SingletonUser("s1");
        SingletonUser s2 = new SingletonUser("s2");
    }

}

class SingletonUser implements Runnable {

    private String threadName;

    public SingletonUser(String threadName) {
        this.threadName = threadName;
        Thread t = new Thread(this, threadName);
        t.start();
    }

    @Override
    public void run() {
        ICSingleton singleton;
        System.out.println("线程 " + threadName + " 声明了一个singleton");
        ICSingleton.print(threadName);
        for (int i = 0; i < 10; i++) {
            singleton = ICSingleton.getInstance();
            System.out.println(threadName + " : singleton--" + i + " 是 " + singleton);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

运行结果：

------------------------------------Console--------------------------------------

线程 s1 声明了一个singleton
线程 s2 声明了一个singleton
s1 aaa
正在实例化ICSingleton
s2 aaa
s1 : singleton--0 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--0 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--1 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--1 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--2 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--2 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--3 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--3 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--4 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--4 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--5 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--5 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--6 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--6 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--7 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--7 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--8 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--8 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s2 : singleton--9 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7
s1 : singleton--9 是 pattern.singleton.multiThread.lazy.ICSingleton@10b30a7

--------------------------------------------------------------------------------------

把instance放到一个内部类中。instance不会在ICSingleton加载时初始化。直到调用getInstance方法时，加载内部类InnerHandle才会初始化instance。类在加载时是线程互斥的。这样既保证了ICSingleton的单实例也可以实现延迟加载。

bxcube
关注
C#学习日记10——单例模式和窗体传值
weixin_44006686的博客
03-11 489
我们经常使用到的一些软件，一部分能够同时开两个窗口（比如qq），另一部分只能开一个窗口（比如网易云音乐），开一个窗口的这些软件模式我们称为单例模式。 用两个form窗体举例，先说创建一个单例模式的步骤吧 1）、将构造函数私有化 2）、提供一个静态方法，返回一个对象 3）、创建一个单例 首先创建两个窗体，在窗体一加一个按钮，让他每次点击都能够打开窗体二。 普通的代码是这样的，你会发现，运行成功后，每次点击这个按钮，都会打开一个新的form2窗口，这样不是我们想要的。 private void button
设计模式学习（五）：单例模式及其优化示例（C语言）
Rain_Mic的博客
02-24 641
一、前言 单例模式（Singleton Pattern）是最简单的设计模式之一，因此并不为其专门开一次研讨会，在闲余时间自行学习，接下来我们来看看该模式的具体内容。、 二、单例模式 单例模式即保证一个类仅有一个实例，并提供一个访问它的全局访问点 单例模式本质上就是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可 以被创建（通过截取创建新对象的请求），并且它可以提供一个访问该实例的方法。 由此可见，单例模式主要是用来避免 一个全局使用的类被频繁地创建与销毁 的情况，当我们想控制实例数目或者节省系统资
单例模式：为何继承无法保证子类的单例特性
李赛男
10-13 1411
当涉及到继承时，单例模式的行为可能会变得复杂，特别是当希望子类也保持单例特性时。本文将深入探讨单例模式在实现过程中必须遵循的规范边界，以及为何通过继承无法保证子类的单例特性。同时，还将探讨是否有替代方案，以实现代码复用和单例特性的结合。
Java设计模式之单例模式（多种实现方式）
cl617287的博客
03-21 2057
Java设计模式之单例模式（多种实现方式）
2024年最新Python实现单例模式的5种方式
2401_84584324的博客
05-02 594
看起来也没有问题，那是因为执行速度过快，如果在init方法中有一些IO操作，就会发现问题了，下面我们通过time.sleep模拟。采用这种方式的单例模式，以后实例化对象时，和平时实例化对象的方法一样 obj = Singleton()通过上面例子，我们可以知道，当我们实现单例时，为了保证线程安全需要在内部加入锁。寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式。我们知道，当我们实例化一个对象时，是先执行了类的。
设计模式之单例模式
LEO
08-25 891
从今天开始，我们正式进入到设计模式的学习。我们知道，经典的设计模式有 23 种。其 中，常用的并不是很多。据我的工作经验来看，常用的可能都不到一半。如果随便抓一个程 序员，让他说一说最熟悉的 3 种设计模式，那其中肯定会包含今天要讲的单例模式。 首先在学习之前 我们来搞清楚这几个问题： 为什么要使用单例？ 单例存在哪些问题？ 单例与静态类的区别？ 有何替代的解决方案？ 话不多说，让我们带着这些问题，正式开始今天的学习吧！ 为什么要使用单例？ 单例设计模式（Singleton Design Pattern）理
【设计模式】（1）单例模式
因为热爱，所以付出
03-11 487
通过以上内容，你可以全面掌握单例模式的核心思想、实现细节和实际应用场景。如果有具体问题或需要代码调试，欢迎随时提问！的详细教程，包含核心概念、应用场景、代码案例、常见问题和习题练习，帮助你全面掌握这一设计模式。为什么枚举实现的单例模式可以防止反射攻击？如何通过代码验证这一点？以下是单例模式的5种经典实现方式，按线程安全和效率排序。：控制实例化过程，避免重复创建对象，节省资源。用双重检查锁实现一个线程安全的缓存管理器。用饿汉式实现一个全局配置管理器。
Java Web 实战 07 - 多线程基础之单例模式
m0_53117341的博客
03-11 1412
单例模式中分为懒汉模式和饿汉模式 , 懒汉模式是需要用的到的时候才去创建实例 , 而饿汉模式是程序一启动就立刻创建实例
单例模式简介
wuyuanman的博客
10-20 452
单例模式是面试中问的最多的设计模式之一，同时它也是最基础的设计模式。说它基础，并不意味着简单，涉及到的延伸知识点非常多。如果要深究下去，可以把Java的基础知识问个遍。本文不作特别细致的讲解，抛砖引玉提几点比较重要的地方，以记录第一次在工作中的使用。 1、什么是单例模式？ 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 2、为什么要用单例模式？ 对啊，为什么要使用？其实我刚开始的时...
线程安全问题以及单例模式
2301_80785428的博客
10-22 1024
在这段代码中，Sc.next()是带有阻塞的操作等待用户在控制台输入，notify这里同样也是需要先拿到锁再进行notify（属于java给出的限制），wait操作必须搭配锁来进行因为wait需要释放锁，但是notify操作原则上说不涉及加锁的操作但是java也是强制要求notify搭配synchronized，线程、锁都是操作系统本身支持的特性，wait和notify在操作系统中也有原生的对应的api，原生api中wait必须搭配锁来使用notify则不需要。但是我们不是在单例模式下只能实例一次的吗？
用单例模式实现雪花算法
as576228266的博客
07-02 1000
雪花算法 雪花算法适用于生成全局唯一的编号，比如数据库主键id，订单编号等 至于为什么叫雪花算法，是因为科学家通过研究认为自然界中不存在两片完全相同的雪花，所以这种算法用雪花来命名也是强调它生成的编号不会重复吧 雪花算法生成的编号共有64bit，刚好是java中long的最大范围 雪花算法是用64位的二进制数字表示 在二进制中，第一位是符号位，表示正数或负数，正数是0，负数是1 因为生成唯一编号不需要负数，所以第一位永远是0，相当于没用 用41位表示时间戳，这个时间戳是当前时间和指定时间的毫秒差。 比如.
IOS单例模式调试代码
01-09
在iOS开发中，单例模式是一种常见的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。...通过研究这些代码，开发者可以更好地理解单例模式的工作原理，以及如何在实际项目中高效、安全地使用和调试单例。
C++设计模式：单例模式与pImpl模式深度解析
### C++设计模式：单例模式与pImpl模式深度解析 #### 1. 单例模式的线程安全与扩展 在多线程编程中使用单例模式时，线程安全是一个潜在的重要问题。例如，当运用多线程编程时，我们必须确保静态的`President::...
jvms Java 版本管理工具
最新发布
星空椰
01-02 355
本文介绍了JVMS（Java Version Manager）的安装和使用方法：1)从GitHub下载最新版JVMS；2)配置环境变量，将JVMS目录添加到系统Path并设为最高优先级；3)初始化JVMS并创建指定目录；4)通过jvms --version验证安装；5)添加本地JDK，需在JVMS目录下创建store文件夹存放JDK，并按版本号命名；6)使用jvms ls查看JDK列表，jvms switch切换版本，java -version验证切换结果。全文详细指导了JVMS的配置和JDK管理流程。
​《深入解析JVM》第四章：JVM 调优
断剑重铸之日 骑士归来之时
12-29 1013
本文系统介绍了JVM调优方法论与实践技巧。
【后端】【JAVA】JDK 21与JDK 7 JVM结构及GC算法深度解析：从永久代到元空间，从CMS到ZGC的演进
xiezhiyi007的专栏
01-02 737
本文解析JDK 7至JDK 21 JVM演进：JDK 7永久代（PermGen）易致OOM，GC暂停长（100-500ms）；JDK 21移除PermGen，元空间自动扩展避免溢出；GC默认G1（平衡吞吐），ZGC实现<10ms超低延迟。通过对比表格、ZGC着色指针源码及配置示例（如-XX:+UseZGC -XX:MaxGCPauseMillis=10），指导开发者：G1适配多数场景，ZGC专攻实时交易系统，显著提升应用性能与稳定性。
2601,链式调用
个人进步之路
01-01 227
2601,链式调用
SQLite02-安装
李宥的博客
12-31 746
点命令：（以开头，区别于SQL语句），适用于日常数据库管理与调试。Navicat 是一套功能全面的数据库管理工具，通过直观的图形用户界面，可对 MySQL、Redis、PostgreSQL、MongoDB、MariaDB、SQL Server、Oracle、Snowflake 和 SQLite 等多种数据库进行管理，有助于简化数据库操作并提升效率，超五成的《财富》世界 500 强企业每天都会使用它。
继承和线程
Hello_MyDream的博客
12-31 188
比如，在32为操作系统中，一个进程的虚拟内存为4GB，这就是一个进程。进程是一个资源容器+至少一个线程。因此线程切换比进程切换开销小，但并发安全问题更复杂。是 CPU 调度的最小单位，只保存执行上下文，（线程 = 共享资源的 task）。拥有独立的虚拟地址空间和系统资源；是资源分配与隔离的基本单位，多个线程共享进程的资源。
java单例模式
03-10
### Java 中单例模式的实现与最佳实践 #### 单例模式概述 单例模式限制类的实例化，并确保 JVM 中只存在该类的一个实例。此类必须提供一个全局访问点来获取唯一的实例[^1]。 #### 应用场景 单例模式广泛应用于日志记录、驱动程序对象管理、缓存机制、线程池配置等领域。此外，在某些设计模式（如抽象工厂、生成器、原型、外观）中也会应用到单例模式。值得注意的是，Java 的标准库中有多个内置组件采用了这种模式，比如 `java.lang.Runtime` 和 `java.awt.Desktop`。 #### 实现方式详解 ##### 1. 饿汉式 (Eager Initialization) 饿汉式的优点在于简单易懂，但在多线程环境下无需额外同步措施即可安全工作。然而，这种方式会在加载类时立即创建实例，即使从未调用过 getInstance 方法也不会改变这一点。 ```java public class Singleton { private static final Singleton instance = new Singleton(); // 私有构造函数防止外部实例化 private Singleton() {} public static Singleton getInstance() { return instance; } } ``` 此方法适用于那些初始化成本不高或者可以接受提前完成的情况[^2]。 ##### 2. 懒汉式 (Lazy Initialization) 懒汉式延迟了实例化的时机直到第一次真正需要它为止。为了保证线程安全性，通常会采用 synchronized 关键字修饰 getInstance 方法。 ```java public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` 虽然这种方法解决了按需加载的问题，但由于每次调用都需要加锁操作，性能上有所牺牲。 ##### 3. 双重检查锁定 (Double-Checked Locking) 通过引入 volatile 关键字并优化判断逻辑，可以在保持线程安全的同时减少不必要的同步开销。 ```java public class Singleton { private static volatile Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { // 第一次检查 synchronized (Singleton.class) { if (instance == null) { // 第二次检查 instance = new Singleton(); } } } return instance; } } ``` 这是目前较为推荐的一种做法，因为它既实现了懒加载又兼顾到了效率问题。 ##### 4. 静态内部类 (Static Inner Class) 利用静态内部类的特点——只有当首次被引用时才会触发其初始化过程，从而达到懒加载的效果；而且由于JVM本身的特性保障了线程安全性和唯一性。 ```java public class Singleton { private Singleton(){} private static class SingletonHolder{ private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance(){ return SingletonHolder.INSTANCE; } } ``` 这种方式不仅简洁明了，还具有良好的扩展性和维护性。 ##### 5. 枚举类型 (Enum Type) 枚举类型的天然优势使其成为最简单的单例实现方案之一。因为 Java 编译器会对 enum 进行特殊处理，自动提供了序列化支持和反序列化保护功能。 ```java public enum Singleton { INSTANCE; public void someMethod(){} } ``` 除了上述几种常见形式外，还有基于反射攻击防范的设计思路等高级技巧可供学习研究。 #### 最佳实践建议 - **私有化构造函数**：确保外界无法直接new出新的对象。 - **考虑线程安全**：对于可能并发访问的应用环境要特别注意同步控制策略的选择。 - **避免序列化破坏单例性质**：如果涉及到跨进程通信或持久化存储，则应采取适当手段阻止非法克隆行为的发生。 - **选择合适的加载时刻**：根据实际需求权衡是优先考虑资源占用还是响应速度等因素决定具体实施方案。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值