单例模式

一、单例模式应用场景 单例模式（Single Pattern）是指 确保一个类在任何情况下绝对只是一个实例，并提供一个全局的访问点。 单例模式在现实生活中的应用也很广泛。例如国家总统、公司CEO、部门经理等。在java标准中，ServletContext、ServletContextConfig等；在Spring框架中ApplicationCotext；数据库对应的连接池也都是单例形势的。 二、单例模式分类 2.1 饿汉式单例 饿汉式单例是在类加载的时候就立即初始化了，并且创建了单例对象。绝对的线程安全，在线程还没出现以前就实例化了，不可能存在访问安全问题。 优点：没有加任何的锁，执行效率高，在用户体验上，比懒汉式更好。 缺点：类加载的时候就初始化了，不管用与不用都占空间，浪费了内存，有可能占着茅坑不拉屎。 Spring中的IOC容器ApplicationContext 本身就是典型的饿汉式单例。案例代码： public class HungrySingleton { /** * 先静态后动态 * 先属性后方法 * 先上后下 */ private static final HungrySingleton hungrySingleton = new HungrySingleton(); private HungrySingleton() { } public static

静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性来实现单例设计模式。 public class MyObject { private static MyObject instance = null; public MyObject() { } static { instance = new MyObject(); } public static MyObject getInstance(){ return instance; } } public class MyThread extends Thread{ @Override public void run() { System.out.println(MyObject.getInstance().hashCode()); } } public class Run { public static void main(String[] args) { MyThread myThread = new MyThread(); MyThread myThread1 = new MyThread(); MyThread myThread2 = new MyThread(); myThread.start(); myThread1.start(); myThread2.start(); } } 下一节:

静态内置类可以达到线程安全的问题，但如果遇到序列化对象时，使用默认的方式运行得到的结果还是多例的。 import java.io.Serializable; public class MyObject implements Serializable { private static final long serialVersionUID = 888L; private static class MyObjectHandler{ private static final MyObject myObject = new MyObject(); } public MyObject() { } public static MyObject getInstance(){ return MyObjectHandler.myObject; } protected Object readResolve(){ System.out.println("调用了readResolve方法!"); return MyObjectHandler.myObject; } } import java.io.*; public class SaveAndRead { public static void main(String[] args) { try { MyObject myObject = MyObject

一、前言 1.单例模式 保证一个类只有一个实例。 常见的应用场景：线程池，方便对池中的线程进行管理 2.单例优缺点： 优点 ： ①在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例 ②单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。 ③提供了对唯一实例的受控访问。 ④由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。 ⑤允许可变数目的实例。 ⑥避免对共享资源的多重占用。 缺点： ①不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。 ②由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。 ③单例类的职责过重，在一定程度上违背了“单一职责原则”。 ④滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢 二、饿汉式单例 --立即加载 /** * 饿汉式单例 * 初始化时就已经实例化对象了 * 缺点：一初始化就会实例静态变量，JVM方法区就会为变量分配内存

单例模式 核心作用 保证一个类只有一个实例，并且 提供一个访问该实例的全局访问点 优点 由于单例模式只生成一个实例，减少了系统性能开销 单例模式可以在系统设置全局的访问点，优化共享资源访问 常见的五种单例模式实现方式 饿汉式：（线程安全，调用效率高，不能延时加载） 懒汉式：（线程安全，调用效率不高，可以延时加载） DCL懒汉式：（由于JVM底层内部模型原因，偶尔会出现问题，不建议使用） 饿汉式改进：静态内部类式（线程安全，调用效率高，可以延时加载） 枚举单例：（线程安全，调用效率高，不能延时加载） 饿汉式 /** * 饿汉式单例 */ public class SingletonDemo01 { // 私有化构造器 private SingletonDemo01 ( ) { } // 类初始化时就加载该对象 private static SingletonDemo01 instance = new SingletonDemo01 ( ) ; // 提供获取该对象的方法，没有synchronized，效率高 public static SingletonDemo01 getInstance ( ) { return instance ; } } class SingletonDemo01Test { public static void main ( String [ ] args

一：什么是Java单例模式？ 单例模式主要是为了避免因为创建了多个实例造成资源的浪费，且多个实例由于多次调用容易导致结果出现错误， 有时候我们只需要某个类同时保留一个对象，不希望有更多的对象。适于使用java单例模式。 二：单例模式的特点： 1.单例模式只能有一个实例 2.单例类必须创建自己的一个唯一实例 3.单例类必须向其他类提供这个实例。 其实，就是要保证对象的唯一性。 三：那么如何保证对象的唯一性呢？需要三步就可以保证对象的唯一性。 (1)不允许其他程序用new对象。 因为new就是开辟新的空间，在这里更改数据只是更改的所创建的对象的数据，如果可以new的话，每一次new都产生一个对象，这样肯定保证不了对象的唯一性。 (2)在该类中创建对象 因为不允许其他程序new对象，所以这里的对象需要在本类中new出来 (3)对外提供一个可以让其他程序获取该对象的方法 因为对象是在本类中创建的，所以需要提供一个方法让其它的类获取这个对象。 那么这三步怎么用代码实现呢？将上述三步转换成代码描述是这样的 (1)私有化该类的构造函数 (2)通过new在本类中创建一个本类对象 (3)定义一个公有的方法，将在该类中所创建的对象返回 三：懒汉模式（即懒加载） 1.在调用 getInstance()的时候才去创建对象 public class Singleton { private static

一. 反射 反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射） 四个可以实现自省的函数 下列方法适用于类和对象（一切皆对象，类本身也是一个对象） class Foo: f = '类的静态变量' def __init__(self,name,age): self.name=name self.age=age def say_hi(self): print('hi,%s'%self.name) obj=Foo('egon',73) #检测是否含有某属性 print(hasattr(obj,'name')) print(hasattr(obj,'say_hi')) #获取属性 n=getattr(obj,'name') print(n) func=getattr(obj,'say_hi') func() print(getattr(obj,'aaaaaaaa','不存在啊')) #报错 #设置属性 setattr(obj,'sb',True) setattr(obj,'show

使用静态内置类同样可以达到线程安全的目的。 public class MyObject { private static class MyObjectHandler{ private static MyObject myObject = new MyObject(); } public MyObject() { } public static MyObject getInstance(){ return MyObjectHandler.myObject; } } public class MyThread extends Thread{ @Override public void run() { System.out.println(MyObject.getInstance().hashCode()); } } public class Run { public static void main(String[] args) { MyThread myThread0 = new MyThread(); MyThread myThread1 = new MyThread(); MyThread myThread2 = new MyThread(); myThread0.start(); myThread1.start(); myThread2.start(); } } 下一节:

单例模式中，只能创建一个类对象，可以用在多次电机按钮只弹出一个窗体 //单例模式编写的步骤： 第一步，将类的构造函数的访问修饰符改成private,这样外部就不能创建该类的对象了 第二步：在该类中增加一个public访问修饰符的静态方法。 通过以上两步，就实现了，外部不能通过new关键字调用该类的构造函数来创建类的对象，要创建对象必须通过调用该静态函数CreateInstance()来创建对象。这样就可以在CreateInstance()方法中控制创建对象的过程 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 单例模式 { class Program { static void Main(string[] args) { #region 1 //// Person p = new Person(); //Person p1 = Person.CreateInstance(); //Person p2 = Person.CreateInstance(); //单例模式第一步，将类的构造函数的访问修饰符改成private,这样外部就不能创建该类的对象了 //第二部：在该类中增加一个public访问修饰符的静态方法。 //通过以上两步，就实现了

所谓单例模式就是只能有一个实例。如何只有一个实例呢？就是不能创建更多的实例，所以构造函数一般私有化，不能new一个新的对象，提供一个访问方法，只能通过这个访问点获取到唯一的对象实例。 常见实现方式有两种：懒汉模式和饿汉模式。 懒汉模式：就是很懒咯，不是一开始就装载好，而是你要用的时候我再创建。 eg： /** * 单例模式：懒汉模式 * * @author yannic * */ public class SingleInstance { //volatile修饰，禁止指令重拍 private static volatile SingleInstance singleInstance; // 私有化构造器,防止外部的类调用创建新对象 private SingleInstance() { } public static SingleInstance getInstance() { //double-check：双重检查 if (singleInstance == null) { synchronized (SingleInstance.class) { if (singleInstance == null) { singleInstance = new SingleInstance(); } } } return singleInstance; } } 饿汉模式：就是很急迫嘛