单例模式java
❶ java开发在什么情况下使用单例模式
使用原则如下：
1.单例模式：确保一个类只有一个实例，自行实例化并向系统提供这个实例
2.单例模式分类：饿单例模式（类加载时实例化一个对象给自己的引用），懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式）
❷ java中什么是单例模式
显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。举个例子windows回收站就是单例模式
❸ Java单例模式是什么意思
Java单例模式是确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例，在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例的模式；
Java单例模式分三种：懒汉式单例、饿汉式单例、登记式单例。
❹ 单例模式的作用及创建方法
单例模式作为常见的设计模式之一，在java的项目开发中会时常的用到。Java Singleton模式即保证在JVM运行时，一个类Class只有一个实例存在。
单例模式有什么好处呢？
最简单的一个例子就是网站计数器的设计了。当我们想要统计当前网站的在线人数时，一个显而易见的问题就是并发所带来的线程安全问题，当我们对这个计数器（网站人数）在同一时刻进行操作，再保存计数时就会造成数据的混乱，后者覆盖前者的结果。一种解决方案就是把这个计数器设置为唯一对象，所有人都必须共用同一份数据。
实现唯一对象最好的解决办法就是让类自己负责保存它的唯一实例，并且让这个类保证不会产生第二个实例，同时提供一个让外部对象访问该实例的方法。自己的事情自己办，而不是由别人代办，这非常符合面向对象的封装原则。
单例模式的三个特点：
只有在自身需要的时候才会行动，从来不知道及早做好准备。它在需要对象的时候，才判断是否已有对象，如果没有就立即创建一个对象，然后返回，如果已有对象就不再创建，立即返回。
该方法在多线程情况下有可能重复创建实例，以下是线程安全的懒汉模式
这种模式的缺点是加锁造成了效率下降，并且在绝大部分情况下是不需要同步的。使用双重检验锁（DCL），只在第一次初始化的时候进行同步加锁
该方式在类加载的时候就被实例化了。
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟饿汉不同的是（很细微的差别）：饿汉方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显式通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。
想象一下，如果实例化instance很消耗资源，我想让它延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式就显得很合理。
关于类加载情况下单例模式，如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类 装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。修复的办法是
❺ java 单例模式
System.out.println (Singleton.getInstance());
System.out.println (Singleton.getInstance());
main 函数中有这两句，一摸一样。
第一句执行的时候，第一次调用getInstance()，意思是要获取Singleton的一个对象实例。
而正常情况下，我们要获取对象的话是用 new Singleton()，这个方法的，但是这个方法在Singleton里面被声明为：private ，意思是外界不能调用。
不能调用，我怎么用你的对象？
Singleton里面实现了生成对象的方法，getInstance(),你要用他的对象就必须调用这个方法。
而这个方法里面你也看到了，如果
if(instance == null){
instance = new Singleton();
}
如果没有实例则创建一个新的，但是已经创建过的话，就返回已经存在的实例。
所以输出结果：
net.chelson.chapter5.Singleton@de6ced
net.chelson.chapter5.Singleton@de6ced
你两次调用的这个对象的内存地址都是相同的，也就是说，是同一个东西（对象）
这个总的来说就是：
类的构造方法私有化（防止外界构造新对象）
提供获取实例的方法（用于外界调用）
作用：用于提供只能有一个实例的对象。
❻ JAVA单例模式有哪些
一、懒汉式单例
在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。
public
class
LazySingleton
{
/**
*
私有静态对象,加载时候不做初始化
*/
private
static
LazySingleton
m_intance=null;
/**
*
私有构造方法,避免外部创建实例
*/
private
LazySingleton(){
}
/**
*
静态工厂方法,返回此类的唯一实例.
*
当发现实例没有初始化的时候,才初始化.
*/
synchronized
public
static
LazySingleton
getInstance(){
if(m_intance==null){
m_intance=new
LazySingleton();
}
return
m_intance;
}
}
二、饿汉式单例
在类被加载的时候，唯一实例已经被创建。
public
class
EagerSingleton
{
/**
*
私有的(private)唯一(static
final)实例成员,在类加载的时候就创建好了单例对象
*/
private
static
final
EagerSingleton
m_instance
=
new
EagerSingleton();
/**
*
私有构造方法,避免外部创建实例
*/
private
EagerSingleton()
{
}
/**
*
静态工厂方法,返回此类的唯一实例.
*
@return
EagerSingleton
*/
public
static
EagerSingleton
getInstance()
{
return
m_instance;
}
}
**************************************************************************************
懒汉方式，指全局的单例实例在第一次被使用时构建；
饿汉方式，指全局的单例实例在类装载时构建
**************************************************************************************
三、登记式单例
这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。
public
class
RegSingleton
{
/**
*
登记薄,用来存放所有登记的实例
*/
private
static
Map
m_registry
=
new
HashMap();
//在类加载的时候添加一个实例到登记薄
static
{
RegSingleton
x
=
new
RegSingleton();
m_registry.put(x.getClass().getName(),
x);
}
/**
*
受保护的默认构造方法
*/
protected
RegSingleton()
{
}
/**
*
静态工厂方法,返回指定登记对象的唯一实例;
*
对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回
*
@param
name
*
@return
RegSingleton
*/
public
static
RegSingleton
getInstance(String
name)
{
if
(name
==
null)
{
name
=
"RegSingleton";
}
if
(m_registry.get(name)
==
null)
{
try
{
m_registry.put(name,
(RegSingleton)
Class.forName(name).newInstance());
}
catch
(InstantiationException
e)
{
e.printStackTrace();
}
catch
(IllegalAccessException
e)
{
e.printStackTrace();
}
catch
(ClassNotFoundException
e)
{
e.printStackTrace();
}
}
return
m_registry.get(name);
}
/**
*
一个示意性的商业方法
*
@return
String
*/
public
String
about()
{
return
"Hello,I
am
RegSingleton!";
}
}
❼ JAVA单例模式有哪些
一、懒汉式单例x0dx0a在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。x0dx0a x0dx0apublic class LazySingleton {x0dx0a /**x0dx0a * 私有静态对象,加载时候不做初始化x0dx0a */x0dx0a private static LazySingleton m_intance=null;x0dx0a /**x0dx0a * 私有构造方法,避免外部创建实例x0dx0a */x0dx0a private LazySingleton(){x0dx0a }x0dx0a /**x0dx0a * 静态工厂方法,返回此类的唯一实例. x0dx0a * 当发现实例没有初始化的时候,才初始化.x0dx0a */x0dx0a synchronized public static LazySingleton getInstance(){x0dx0a if(m_intance==null){x0dx0a m_intance=new LazySingleton();x0dx0a }x0dx0a return m_intance;x0dx0a }x0dx0a}x0dx0ax0dx0a二、饿汉式单例x0dx0a在类被加载的时候，唯一实例已经被创建。x0dx0a x0dx0apublic class EagerSingleton {x0dx0a /**x0dx0a * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象x0dx0a */x0dx0a private static final EagerSingleton m_instance = new EagerSingleton();x0dx0a /**x0dx0a * 私有构造方法,避免外部创建实例x0dx0a */x0dx0a private EagerSingleton() {x0dx0a }x0dx0a /**x0dx0a * 静态工厂方法,返回此类的唯一实例.x0dx0a * @return EagerSingletonx0dx0a */x0dx0a public static EagerSingleton getInstance() {x0dx0a return m_instance;x0dx0a }x0dx0a}x0dx0a x0dx0a************************************************************************************** 懒汉方式，指全局的单例实例在第一次被使用时构建； x0dx0a饿汉方式，指全局的单例实例在类装载时构建 x0dx0a**************************************************************************************x0dx0ax0dx0a三、登记式单例x0dx0a这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。x0dx0apublic class RegSingleton {x0dx0a /**x0dx0a * 登记薄,用来存放所有登记的实例x0dx0a */x0dx0a private static Map
❽ 在java开发中，为什么要使用单例模式
java单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。
特点：
一个类只能有一个实例；
自己创建这个实例；
整个系统都要使用这个实例。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。一些资源管理器常常设计成单例模式。
外部资源：譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中管理这些通信端口，以避免一个通信端口被两个请求同时调用。
内部资源，譬如，大多数的软件都有一个（甚至多个）属性文件存放系统配置。这样的系统应当由一个对象来管理这些属性文件。
单例模式，能避免实例重复创建；
单例模式，应用于避免存在多个实例引起程序逻辑错误的场合；
单例模式，较节约内存。
❾ Java单例模式怎么用
java模式之单例模式：
单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。
特点：
1，一个类只能有一个实例
2，自己创建这个实例
3，整个系统都要使用这个实例
例: 在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。一些资源管理器常常设计成单例模式。
外部资源：譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中管理这些通信端口，以避免一个通信端口被两个请求同时调用。内部资源，譬如，大多数的软件都有一个（甚至多个）属性文件存放系统配置。这样的系统应当由一个对象来管理这些属性文件。
一个例子：Windows 回收站。
在整个视窗系统中，回收站只能有一个实例，整个系统都使用这个惟一的实例，而且回收站自行提供自己的实例。因此，回收站是单例模式的应用。
两种形式：
1，饿汉式单例类
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}