singleton_singletons - CSDN
  • 编写一个Singleton示例

    2019-11-01 16:08:54
    Singleton:在java中指单例设计模式,软件开发中最常用的设计模式之一。 单例设计模式:即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。 例如JVM运行环境的Runtime类。 编写要点: 一、这个类...

    Singleton:在java中指单例设计模式,软件开发中最常用的设计模式之一。

    单例设计模式:即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。

    例如JVM运行环境的Runtime类。

    编写要点:

    一、这个类只能有一个实例

    ​ 构造器私有化

    二、它必须自行创建这个实例

    ​ 含有一个该类的静态变量来保存这个唯一的实例

    三、必须自行向整个系统提供这个实例。

    ​ 对外提供获取该实例对象的方法

    ​ 1.直接暴露。2.用静态变量的get方法获取。

    几种常见形式:

    饿汉式:直接创建对象,不存在线程安全问题

    1.直接实例化饿汉式(简介直观)

    ``

    //JDK1.5之前
    //饿汉式:
    //在类初始化时直接创建实例对象,不管是否需要这个对象都会创建
    public class Singleton1 {
        //3.向外提供这个实例public static Singleton1 instance=new Singleton1();
        //2.自行创建,并且用静态变量保存 static Singleton1 instance=new Singleton1();
        public static final Singleton1 INSTANCE=new Singleton1();
        //1.构造器私有化private Singleton1(){}
        private Singleton1(){
    
        }
        //4.强调这是一个单例,可用final修饰public static final Singleton1 instance=new Singleton1();
    }
    

    2.枚举式(最简洁)

    ``

    //JDK1.5之后
    /*枚举类型:表示该类型的对象是有限的几个
    限定为一个就成了单例。
    * */
    public enum  Singleton2 {
        INSTANCE
    }
    

    3.静态代码块饿汉式(适合复杂实例化)

    ``

    //饿汉式
    //静态代码块饿汉式(适合复杂实例化)
    public class Singleton3 {
        public static final Singleton3 INSTANCE;
        static {
            INSTANCE=new Singleton3();
        }
        private Singleton3(){
    
        }
    }
    

    懒汉式:延迟创建对象

    1.线程不安全(适用于单线程)

    ``

    /*懒汉式:延迟创建对象
    *1.构造器私有化
    * 2.用静态变量保存这个唯一实例
    * 3.提供一个静态方法获取实例对象
    * */
    public class Singleton4 {
        private static Singleton4 instance;
        private Singleton4(){
        }
        public static Singleton4 getInstance(){
            if (instance==null){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance = new Singleton4();
            }
            return instance;
        }
    }
    

    2.线程安全(适用于多线程)

    ``

    /*懒汉式:延迟创建对象
     *1.构造器私有化
     * 2.用静态变量保存这个唯一实例
     * 3.提供一个静态方法获取实例对象
     * */
    public class Singleton5 {
        private static Singleton5 instance;
        private Singleton5(){
        }
        public static Singleton5 getInstance(){
            synchronized (Singleton5.class){
                if (instance==null){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Singleton5();
                }
    
            }
            return instance;
    
        }
    }
    

    3.静态内部类形式(适用于多线程)

    ``

    /*在内部类被加载和初始化时,才创建INSTANE实例对象。
    静态内部类不会自动随着外部类的加载和初始化而舒适化,它是要单独去加载和初始化的。
    因为是在内部类加载和初始化时创建的,因此线程安全。
    * */
    public class Singleton6 {
        private Singleton6(){
    
        }
        private static class Inner{
            private static final Singleton6 INSTANCE=new Singleton6();
        }
        public static Singleton6 getInstance(){
            return Inner.INSTANCE;
        }
    }
    

    饿汉式:枚举形式最简单。懒汉式:静态内部类形式。

    展开全文
  • 设计模式之单例模式介绍。几种单例模式浅析。

    1 单例模式核心

    • 单例模式的核心是一个类在其整个生命周期中只有一个实例对象

    2 饿汉式

    • 优点:简单明了,运行时速度快
    • 缺点:在第一次加载类到内存中时就会初始化,不管有没有使用,可能会造成资源浪费
    public class Teacher {
        private String name;
        private Integer age;
        //防止通过构造器初始化
        private Teacher() {}
        private Teacher(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
        private static final Teacher YU_QIAN = new Teacher("于谦",54);
        public Teacher getYuQian() {
            return YU_QIAN;
        }
    }
    static ExecutorService executor = Executors.newFixedThreadPool(6);
    @Test
    public void test() throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10000; i++) {
            Future f1 =executor.submit(()->{
                Teacher.getYuQian();
            });
            Future f2 =executor.submit(()->{
                Teacher.getYuQian();
            });
            Teacher t1 =(Teacher) f1.get();
            Teacher t2 =(Teacher) f2.get();
            Assert.assertTrue(t1 == t2);
        }
    }
    

    3 双重检验锁

    • 优点:为懒加载模式,可能节约资源
    • 缺点:代码较为复杂,有锁消耗,依赖 JDK 版本
    // Java 5 以前的 JMM (Java 内存模型)是存在缺陷的,即时将变量声明成 volatile 也不能完全避免重排序
    //主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复,所以在这之后才可以放心使用 volatile
    public class TeacherDoubleCheck {
        private String name;
        private Integer age;
        private TeacherDoubleCheck() {}
        private TeacherDoubleCheck(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
        private volatile static TeacherDoubleCheck YU_QIAN;
        public static TeacherDoubleCheck getTeacher() {
            if (YU_QIAN == null) {                         //Single Checked
                synchronized (Teacher.class) {
                    if (YU_QIAN == null) {                 //Double Checked
                        YU_QIAN = new TeacherDoubleCheck("于谦",54);
                    }
                }
            }
            return YU_QIAN ;
        }
    }
    

    4 静态内部类

    • 优点:静态内部类只有在第一次调用它的时候才初始化,比双重检验锁代码简单
    • 缺点:和双重检验锁一样,初始化静态内部类时会加锁,后面调用时就不会在初始化了,所以也有锁开销
    public class TeacherStaticNested {
        private String name;
        private Integer age;
        private TeacherStaticNested() {}
        private TeacherStaticNested(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
        //定义一个静态内部类
        private static class TeacherHolder {
            private static final TeacherStaticNested YU_QIAN = new TeacherStaticNested("于谦",54);
        }
        public static final TeacherStaticNested getYuQian() {
            return TeacherHolder.YU_QIAN;
        }
    }
    

    5 枚举

    • 优点:第一次调用任意一个枚举实例时,初始化所有的枚举实例,代码简单,序列化安全等
    • 缺点:单元素的枚举类型已经成为实现Singleton的最佳方法 ——《Effective Java》
    public enum Pool {
        ORACLE_POOL("oracle",DataSourceBuilder.create().type(HikariDataSource.class).build()),
        JVM_POOL("jvm",DataSourceBuilder.create().type(ComboPooledDataSource.class).build()),
        MYSQL_POOL("mysql",DataSourceBuilder.create().type(DruidDataSource.class).build());
        private String name;
        private DataSource dataSource;
        Pool (String name,DataSource dataSource) {
            this.name = name;
            this.dataSource = dataSource;
        }
        public DataSource getDataSource() {
            return dataSource;
        }
    }
    static ExecutorService executor = Executors.newFixedThreadPool(6);
    @Test
    public void test() throws ExecutionException, InterruptedException {
       Teacher t0 = null;
       for (int i = 0; i < 10000; i++) {
           Future f1 =executor.submit(()->{
               Pool.ORACLE_POOL.getDataSource();//第一次调用的时候才初始化,构造器加锁
           });
           Future f2 =executor.submit(()->{
               Pool.ORACLE_POOL.getDataSource();
           });
    
           Teacher t1 =(Teacher) f1.get();
           Teacher t2 =(Teacher) f2.get();
           Assert.assertTrue(t1 == t2);
           if (i == 9999) t0 = t1;
       }
       Assert.assertFalse(t0 == Pool.JVM_POOL.getDataSource());
    }
    

    参考

    为什么要用枚举实现单例模式(避免反射、序列化问题)
    单例模式有五种写法
    java枚举类型的实现原理
    枚举实现单例原理
    Java 利用枚举实现单例模式
    为什么我墙裂建议大家使用枚举来实现单例
    github 源码地址

    展开全文
  • 设计模式-Singleton模式

    2019-05-27 15:33:15
    Singleton模式是什么? Singleton字面意思,单例,那也就是说无论如何这个类只有一个实例对象,你没有办法new出多个这个类的实例。 应用场景 想确保任何情况下都绝对只有1个实例 想在程序上表现出“只存在一个实例...

    Singleton模式是什么?

    Singleton字面意思,单例,那也就是说无论如何这个类只有一个实例对象,你没有办法new出多个这个类的实例。

    应用场景

    • 想确保任何情况下都绝对只有1个实例
    • 想在程序上表现出“只存在一个实例”

    比如在写Javaweb程序时候,使用框架设置的一些全局配置。你要保证在任何地方调用这个配置都是一样的,是同一个,而不是各个地方调用的都是不一样的,那样的话,全局配置相当于无效,就会导致程序混乱,很难找出错误。
    当然你也可以不使用Singleton模式,但是你必须时刻小心翼翼,防止自己new出了多个对象。所以还是使用设计模式比较省心。

    Singleton模式-UML图

    在这里插入图片描述

    这个UML图的意思就是在这个Singleton类中,声明一个静态私有变量singleton.
    然后将构造方法声明为私有的,这样你就没办法在类外部new出一个新的类了。
    外部类要获取该类的实例只能通过getInstance获取类中的static变量singleton。
    具体代码如下:

    代码实现

    public class Singleton{
    //静态私有变量
    private static Singleton singleton = new Singleton();
    //私有构造方法
    private Singleton(){ 
    System.out.println("生成了一个实例!!!");
    }
    //外部类通过Singleton.getInstance()获取这个类的对象。
    public static Singleton getInstance(){
    return singleton;}
    }
    

    然后可以通过Main函数测试一下对不对:

    public class Main{
    	public static void main(String[] args)
    	{
    		System.out.println("Strat.");
    		Singleton s1 = Singleton.getInstance();
    		Singleton s2 = Singleton.getInstance();
    		if(s1==s2)
    		System.out.println("true");
    		else
    		System.out.println("false");
    		System.out.println("End.");
    	}
    }
    
    展开全文
  • Singleton

    2019-09-05 10:00:37
    #include <iostream> using namespace std;...class Singleton{ public: static Singleton * Instance(); void operate(){ cout<<"One Operate"<<endl; } private: //私有化构造函数 Si...
    #include <iostream>
    
    using namespace std;
    
    class Singleton{
    public:
        static Singleton * Instance();
        void operate(){ cout<<"One Operate"<<endl; }
    private:
        //私有化构造函数
        Singleton(){}
        //私有化拷贝构造函数
        Singleton(const Singleton &) = delete;
        //私有化赋值运算符
        Singleton & operator=(const Singleton &) = delete;
        static Singleton * _instance;
    
    };
    
    Singleton * Singleton::_instance = new Singleton();
    
    Singleton * Singleton::Instance()
    {
        return  _instance;
    }
    
    
    int main()
    {
        cout << "Hello World!" << endl;
    
        Singleton   * instance = Singleton::Instance();
        instance->operate();
        return 0;
    }
    

     

    展开全文
  • public sealed class Singleton1 { private Singleton1(){} private static Singleton1 instance = null; public static Singleton1 Instance { get { if(instance == null) ...
  • 单例模式,即
  • singleton

    2019-05-04 15:06:33
    Singleton类被称为单例类,通过使用private的构造函数确保了在一个应用只产生一个实例. ----设计模式之禅 使用场景 在一个系统中,要求一个类有且仅有一个对象,如果出现多个对象就会出现"不良反应",可以采用单例模式...
  • Singleton 设计模式

    2017-02-28 12:20:17
    本文为转载 原文内容...  引子  “请写一个Singleton。”面试官微笑着和我说。  “这可真简单。”我心里想着,并在白板上写下了下面的Singleton实现: 1 class Singleton 2 { 3 public:
  • C#的5种Singleton写法

    2018-01-22 20:27:26
    单例模式是二十多种设计模式中最为常见且简单的模式(没有之一),也有面试时要求考察单例模式,虽然简单,但也有不少地 ...public sealed class Singleton1  {  private Singleton1()  {  
  •  Singleton(单例)是设计模式的一种,为了保证一个类仅有一个实例,并提供一个访问它的全局访问点。   2.主要特点:   1)单例类确保自己只有一个实例(构造函数私有:不被外部实例化,也不被继承)。 ...
  • Python实现Singleton模式

    2016-07-14 16:50:45
    Singleton模式即单例对象必须必须保证只有一个实例存在。可以说Singleton是设计模式中最基本一种设计模式,在学习设计模式时一般都会先了解该模式。在Python中实现单例模式有很多方法,下面简单总结以下,可以根据...
  • Java设计模式透析之 —— 单例(Singleton) 写软件的时候经常需要用到打印日志功能,可以帮助你调试和定位问题,项目上线后还可以帮助你分析数据,但是Ruby原生带有的puts方法却很少在真正的项目开发中使用。 为什么...
  • 单例(Singleton)模式 也叫单态模式 概述:单例(Singleton)模式要求一个类有且仅有一个实例,并且提供了一个全局的访问点。这就提出了一个问题:如何绕过常规的构造器,提供一种机制来保证一个类只有一个实例?客户...
  • 深入浅出单实例Singleton设计模式陈皓前序单实例Singleton设计模式可能是被讨论和使用的最广泛的一个设计模式了,这可能也是面试中问得最多的一个设计模式了。这个设计模式主要目的是想在整个系统中只能出现一个类的...
  • @Singleton能保证单例吗

    2019-05-26 12:08:18
    scope里有个@Singleton,它能保证单例吗? 答案是不完全能(或者是说是有条件的能) 当你不使用@Singleton时,在同一个宿主类里,注入两次同一个类的对象你会发现,两个对象的地址不一样 当你使用了@Singleton,...
  • Singleton模式称作单件模式或单例模式。它的作用是确保一个类在整个工程中有且只有一个实例。可以在多个不同的类中很方便的所需要的类的方法。 原理: 它的构造函数是私有的,你不能去new它。该单例类里面已经实例...
  • 单例模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。... private static Singleton in...
  • 转自:我想有个长长的名字的博客,剑指offer 面试题2 Singleton模式 C++实现题目:实现Singleton模式​ 以下内容是我在看《剑指offer》的面试题2时,遇到的问题,因为书中使用C#实现,所以想用C++重新实现一下,Test...
  • 前言 ...单例模式(Singleton Pattern)是设计模式中最简单的模式之一,属于创建型模式。这种设计模式主要是类的对象只有一个实例,不需要每次new 创造。而我们要做的的就是确保这个对象创建的唯一...
  • 个人认为 Singleton模式是所有设计试中最简单,最常见,也是最容易实现的,因此,设计模式就先从Singleton模式开始说起吧!对于开发人员来说也是最应该熟悉和把握的模式。因此,此模式在招聘的现场上出现的概率是极...
1 2 3 4 5 ... 20
收藏数 177,845
精华内容 71,138
关键字:

singleton