实现单例模式,实现单例模式的三个要点
spring的单例模式如何实现?
1.spring主要运用那些设计模式:
单例，工厂
2.单例模式实现:
核心是私有构造子
通过该类的静态方法 获取唯一的对象
其中主要是2种:
a.饿汉式
class Singleton {
private static Singleton instance=new Singleton();
private Singleton(){}
static Singleton getInstance() {
return instance;
}
}
b.懒汉式
class Singleton {
private static Singleton instance=null;
private Singleton(){}
static Singleton getInstance() {
if(instance==null)
instance=new Singleton();
return instance;
}
}
设计模式 之 单例模式
1. 定义
单例模式指的是一个类，在全局范围内（整个系统中）有且只能有一个实例存在。即该类本身负责提供一种访问其唯一对象的方式，不对外提供公共的构造函数（禁用默认公共构造函数），对于该类的实例化由它自己在类的内部进行维护！
2. 优缺点
- 优点
1. 最大程度的减少了对象的创建和销毁的次数，从而降低的垃圾回收的次数
2. 节约了系统资源，尤其是内存资源
- 缺点
1. 不能继承，不能被外部实例化
2. 类干预了外部类的使用（外部实用类不能随意实例化），而不再仅仅专注于内部的逻辑（与单一职责模式有矛盾）
3. 使用场景
- 有频繁的实例化后又销毁的情况，适合考虑使用单例模式，如记录日志的log对象
- 创建对象需要消耗过多的系统资源，但又经常用到的资源，如数据库连接
4. 框架中的应用
5. 实现方式
单例模式有多种实现方式，要考虑到多线程下的安全性，其每种实现方式如下所示：
以上方式，如果存在多个线程同时访问getInstance()时，由于没有锁机制，会导致实例化出现两个实例的情况，因此，在多线程环境下时不安全的。
如上代码所示，在getInstance()方法上添加了同步锁。但是该方法虽然解决了线程安全的问题，但却也带来了另外的一个问题，就是每次获取对象时，都要先获取锁，并发性能很差，还需要继续优化！
该方法将方法上的锁去掉了，避免了每次调用该方法都要获取锁的操作，从而提升了并发性能，同时在方法内部使用锁，进而解决了并发的问题，从而解决了上面**并发安全+性能低效**的问题，是个不错的实现单例的方式。
该方式虽然简单也安全，但是会造成再不需要实例时，产生垃圾对象，造成资源狼粪，因此，一般不使用。
这种方式可以达到跟** 双重校验锁 **一样的效果，但只适用于静态域的情况，双重校验锁可在实例域需要延迟初始化时使用
这是实现单例模式的最佳方法，更加简洁，自动支持序列化，防止多次实例化，非常高效！ （强烈推荐使用）
6.引用
如何写一个简单的单例模式？
一、基本的实现思路:
单例的实现主要是通过以下两个步骤：
1、将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；
2、在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。
二、示范如下：
1、枚举实现单例：
2、懒汉式线程不安全：
3、懒汉式线程安全：
4、饿汉式：
5、双重校验锁：
6、静态内部类：
扩展资料:
一、单列模式简介：
单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。
二、懒汉与饿汉：
1、懒汉方式：指全局的单例实例在第一次被使用时构建。
2、饿汉方式：指全局的单例实例在类装载时构建。
三、单例模式的三要点：
1、某个类只能有一个实例。
2、它必须自行创建这个实例。
3、它必须自行向整个系统提供这个实例。
四、优缺点：
1、优点：
①实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
②灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。
2、缺点：
①开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
②可能的开发混淆：使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
③对象生存期：不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。
参考资料：百度百科单列模式
如何实现单例模式？
这个模式保护类的创建过程来确保只有一个实例被创建，它通过设置类的构造方法为私有来达到这个目的。要获得类的实例，单例类可以提供一个方法，如getInstance，来返回类的实例。该方法是唯一可以访问类来创建实例的方法。下面是单例的一个例子：Java代码publicclassSingletonPattern{privatestaticSingletonPatterninstance;privateSingletonPattern(){}publicstaticsynchronizedSingletonPatterngetInstance(){if(instance==null){instance=newSingletonPattern();}returninstance;}}当我们要实现单例的时候，有如下的规则需要遵循：从上面的示例代码中可以看出，一个单例类有一个静态的属性来保存它唯一的实例需要将类的构造方法设置为private。这样你不允许其他任何类来创建单例类的实例，因为它们不能访问单例类的构造方法。
如何在Java中实现单例模式？
单例模式大致有五种写法，分别为懒汉，恶汉，静态内部类，枚举和双重校验锁。
1、懒汉写法，常用写法
class?LazySingleton{
????private?static?LazySingleton?singleton;
????private?LazySingleton(){
????}
????public?static?LazySingleton?getInstance(){
????????if(singleton==null){
????????????singleton=new?LazySingleton();
????????}
????????return?singleton;
????}???
}
2、恶汉写法，缺点是没有达到lazy loading的效果
class?HungrySingleton{
????private?static?HungrySingleton?singleton=new?HungrySingleton();
????private?HungrySingleton(){}
????public?static?HungrySingleton?getInstance(){
????????return?singleton;
????}
}
3、静态内部类，优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading
class?InternalSingleton{
????private?static?class?SingletonHolder{
????????private?final?static??InternalSingleton?INSTANCE=new?InternalSingleton();
????}???
????private?InternalSingleton(){}
????public?static?InternalSingleton?getInstance(){
????????return?SingletonHolder.INSTANCE;
????}
}
4、枚举，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
enum?EnumSingleton{
????INSTANCE;
????public?void?doSomeThing(){
????}
}
5、双重校验锁，在当前的内存模型中无效
class?LockSingleton{
????private?volatile?static?LockSingleton?singleton;
????private?LockSingleton(){}
?????
????//详见：
????public?static?LockSingleton?getInstance(){
????????if(singleton==null){
????????????synchronized(LockSingleton.class){
????????????????if(singleton==null){
????????????????????singleton=new?LockSingleton();
????????????????}
????????????}
????????}
????????return?singleton;
????}
}
参考自：
什么叫单例模式，如何实现，有什么作用？
就是只有一个实例，最简单的单例模式可以用static来实现。
比如下面的_Context变量就是用了单利模式,下面的代码就是外面想调用_Context时，如果_Context已经实例化，那么直接返回，如果没实例化，就实例化它再返回。全局只有一个_Context
比如
public
class
EESGateway
{
private
static
EESDatabaseDataContext
_Context
=
null;
//EESDatabasDataContex
Instance
private
const
string
databaseName
=
"EESDatabase";
//Database
name
///
///
Return
EESDatabaseDataContext
instance.
///
///
EESDatabaseDataContext
instance
public
static
EESDatabaseDataContext
DataContext()
{
if
(_Context
==
null)
{
lock
(typeof(EESGateway))
{
//formate
a
new
string
to
store
the
connectionString
String
connectionString
=
ConfigurationManager.ConnectionStrings["EESDatabase"].ConnectionString;
//create
a
dataContext
using
the
connectionString
above
_Context
=
new
EESDatabaseDataContext(connectionString);
}
}
return
_Context;
}
}