所学技术知识记录分享，主要是JavaScript技术总结，欢迎交流，感谢补充纠正。...
Java单例模式常用的3种实现方式
单例模式的实现由很多种，都是为了保证在运行环境中只有该类的一个实例存在，为其他对象提供服务。
比如：工具类，配置类，线程池等。
常见的实现由两种，
// 懒汉式（延迟加载模式），初始时没有创建对象的实例，只有在调用getInstance方法时，才创建实例。
public class Single{
//声明私有该类的实例，并且为静态
private static S
//私有默认构造函数，外部无法直接构造该对象
private Single(){}
//对外提供获取实例的静态方法, （该方法是线程不安全的，可加synchronized锁使线程安全）。
public static Single getInstance(){
//实例为空时，创建该类的实例
if(instance == null){
instance = new Single();
// 饿汉式，初始时即创建静态实例
public class Single{
//创建私有的该类静态实例
private static Single instance = new Single();
//私有构造函数
private Single(){}
//对外提供获取实例的静态方法
public static Single setInstance(){
第三种：静态内部类获取方式
public class Single{
//私有构造函数
private Single(){}
//内部类持有该对象的实例
private static class SingletonHolder(){
static Single instance = new Single();
// 公有获取实例的静态方法
public static Single getInstance(){
reuturn SingletonHolder.
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！你真的会写Java单例么？
java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
　　单例模式有一下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。
　　正是由于这个特 点，单例对象通常作为程序中的存放配置信息的载体，因为它能保证其他对象读到一致的信息。例如在某个服务器程序中，该服务器的配置信息可能存放在数据库或 文件中，这些配置数据由某个单例对象统一读取，服务进程中的其他对象如果要获取这些配置信息，只需访问该单例对象即可。这种方式极大地简化了在复杂环境 下，尤其是多线程环境下的配置管理，但是随着应用场景的不同，也可能带来一些同步问题。下面看看具体的单例代码实现。
　1.饿汉式单例类
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton {
//私有的默认构造子
private Singleton() {}
//已经自行实例化
private static final Singleton single = new Singleton();
//静态工厂方法
public static Singleton getInstance() {
这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，因为导致类装载的原因有很多种，在单例模式中虽然大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，比如只是调用这个单例中的某个静态成员变量或方法，这时候都会初始化instance显然没有达到lazy
loading的效果。还有如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。
2.饿汉式单例类（变种）
public class Singleton {
private Singleton instance =
instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return this.
表面上看起来与第一种差别挺大，其实实现方式差不多，都是在类初始化即实例化instance。
注意一个类(class)要被使用必须经过装载，连接，初始化这样的过程。
在装载阶段，类装载器(Bootstrap ClassLoader 或者用户自定义的ClassLoader) 把编译形成的class文件载入内存，创建类相关的Class对象，这个Class对象封装了我们要使用的类的类型信息，类最基本的加载规则是按需加载，即需要的时候才加载。
连接阶段又可以分为三个子步骤：验证、准备和解析。
1）验证就是要确保java类型数据格式 的正确性，并适于JVM使用。
2）准备阶段，JVM为静态变量分配内存空间，并设置默认值，注意，这里是设置默认值，比如说int型的变量会被赋予默认值0 。在这个阶段，JVM
可能还会为一些数据结构分配内存，目的 是提高运行程序的性能，比如说方法表。
3）解析过程就是在类型的常量池中寻找类、接口、字段和方法的符号引用，把这些符号引用替换成直接引用。这个阶段也可以被推迟到初始化之
后，当程序运行的过程中真正使用某个符号引用的时候 再去解析它。
类会在首次被“主动使用”时执行初始化，为类（静态）变量赋予正确的初始值。在Java代码中，一个正确的初始值是通过类变量初始化语句或者静态初始化块给出的。而我们这里所说的主动使用包括：
1） 创建类的实例
2） 调用类的静态方法
3） 使用类的非常量静态字段
4） 调用Java API中的某些反射方法
5） 初始化某个类的子类
6） 含有main()方法的类启动时
注：访问静态常量（static final 修饰的）会存入调用类的常量池【这里说的是调用类main函数所在的类的常量池】，调用的时候本质上没有引用到
定义常量的类，而是直接访问了自己的常量池。所以，这里调用常量静态字段的时候，不会初始化定义类。
初始化一个类包括两个步骤：
如果类存在直接父类的话，且直接父类还没有被初始化，则先初始化其直接父类
如果类存在一个初始化方法，就执行此方法
注：初始化接口并不需要初始化它的父接口。
懒汉式单例类
//懒汉式单例类.在第一次调用的时候实例化
public class Singleton {
//私有的默认构造子
private Singleton() {}
//注意，这里没有final
private static Singleton single=
//静态工厂方法
public synchronized
static Singleton getInstance() {
if (single == null) {
single = new Singleton();
}这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下它不需要同步，因为每次getInstace()时它都需要同步。
懒汉式双重校验锁（DCL）
public class Singleton {
private volatile static S
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
这个是第三种方式的升级版，俗称双重检查锁定(DCL)。注意这里对singleton == null 有两次判空操作，为什么要这样呢，我们分析下：
假设线程A执行到singleton = new Singleton 这语句，这里看起来是一条代码，但是它实际上不是一个原子操作，这句代码会被编程成多条汇编指令，它大致做了下面三件事件：
1）给Singleton的实例分配内存；
2）调用Singleton的构造函数，初始化成员字段；
3）将singleton变量指向分配的内存空间（此时singleton就不是null了）。
但是由于java编译器允许处理器乱序执行，以及JDK1.5之前JMM(java memory model 即java内存模式)中Cache,寄存器到主内存回写顺序的规定，上面2,3步的执行顺序是无法保证的，也就是说，执行顺序有可能是
1 - 2 - 3 也有可能是1 - 3 - 2 。 如果是后者，并且在A线程执行完第3步后，2未执行之前，被切换到线程B上，这时候singleton变量因为A线程已经执行了第三步，singleton就不为空了，所以B线程就会直接取走singleton变量，再使用时就会出错，这就是DCL失效问题。
在JDK1.5后，SUN官方已经注意到这个问题，调整了JMM，具体化了volatile关键字，JDK1.5或之后的版本，只需要将singleton的定义时加上volatile关键字，可以保证singleton对象每次都从主内存中读取（不加volatile的话每个线程可以自己缓存变量），volatile关键字也可以保证“有序性”，即对一个变量的写操作先行发生于后面对这个变量的读操作。
DCL的优点是：资源利用率高，只有在使用getSingleton才会实例化对象，效率高。
静态内部类单例模式：
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
这种方式同样利用了classloader的机制来保证初始化instance时只有一个线程，它跟前面两种饿汉式不同的是（很细微的差别）：前面两种只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy
loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，这个时候，这种方式相比前面的两种饿汉式方式就显得很合理。这里也不会有上面DCL的问题，所以是推荐使用的单例模式实现方式。
public enum Singleton {
public void whateverMethod() {
这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，（注：序列化可以将一个单例的实例对象写到磁盘，然后再读回来，从而有效地获得一个实例对象。即使是构造函数是私有的，反序列化时依然可以）不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。
.登记式单例模式，使用容器实现
public class SingletonManager {
private static Map&String,Object& objectMap = new HashMap&&();
private SingletonManager(){}
public static void registerSingleton(String key,Object instance){
if(!objectMap.containsKey(key)){
objectMap.put(key,instance);
public static Object getInstance(String key){
return objectMap.get(key);
在程序的初始，将多种单例类型注入到一个统一的管理类中，使用时根据Key获取对应对象。这种方式使得我们可以管理多种类型单例。并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
有两个问题需要注意：
1、如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类
装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。
2、如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。
对第一个问题修复的办法是：
private static Class getClass(String classname)
throws ClassNotFoundException {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
if(classLoader == null){
classLoader = Singleton.class.getClassLoader();
return (classLoader.loadClass(classname));
对第二个问题修复的办法是：
public class Singleton implements java.io.Serializable {
public static Singleton INSTANCE = new Singleton();
protected Singleton() { }
private Object readResolve() {
return INSTANCE;
更多精彩Android技术可以关注我们的微信公众号，扫一扫下方的二维码或搜索关注公共号： Android老鸟
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！Java设计模式之单例模式及在Android中的重要使用
　　之前在开发中老用到一些设计模式可是呢又不是很懂，于是狠下心来琢磨一番。下面是我琢磨后总结的，希望对您有用。如果发现了问题，请帮忙指正。
一、单例模式是什么？
　　单例模式最初的定义出现于《设计模式》：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”
　　Java中单例模式定义；“一个类有且仅有一个实例，并且自行实例化向整个系统提供该实例。”
二、为什么用单例模式？
　　对于系统中的某些类来说，只有一个实例很重要。例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只有有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID生成器。如在Windows OS 中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着某一瞬间系统有多个状态，与实际不符，也会为用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例是非常重要的。
　　如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。
三、单例模式特点
单例模式特点有三个
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给其他对象（整个系统）提供这一实例。
　从具体实现角度分析，一是单例模式的类只提供私有的(private)构造函数，二是类定义中含有一个该类的静态私有(private static)对象，三是该类提供了一个静态的（static）公有的(public)函数用于创建或获取它本身的静态私有对象。
四、Java中几种常见单例模式写法
　　通过上面的介绍你是不是对单例模式有了一个总的概念？没有，那接下来继续给你们放大招。
　　基于单例模式特点，单例对象通常作为程序中存放配置信息的载体（想想Android中的Application经常在里面做一些配置的初始化），因为它能够保证其他对象读取到一致的信息。例如在某个服务器程序中，该服务器的配置信息可能存放在数据库或 文件中，这些配置数据由某个单例对象统一读取，服务进程中的其他对象如果要获取这些配置信息，只需访问该单例对象即可。这种方式极大地简化了在复杂环境 下，尤其是多线程环境下的配置管理，但是随着应用场景的不同，也可能带来一些同步问题。
1、饿汉式单例
public class Singleton {
private Singleton() {}
private static final Singleton single = new Singleton();
public static Singleton getInstance() {
　　上面例子中，在这个类被加载时，静态变量single会被初始化，此时类的私有构造子会被调用。这时单例类的唯一实例就被构造出来了。
　　饿汉式其实是一种比较形象的称谓。既然饿，那么在创建对象实例的时候就比较着急，饿了嘛，于是在装载类的时候就创建对象实例—&
private static final Singleton single = new Singleton();
　　饿汉式是典型的空间换时间，当类装载时就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。
2、懒汉式单例
public class Singleton {
private Singleton() {}
private static Singleton single=null;
public static synchronized Singleton getInstance() {
if (single == null) {
single = new Singleton();
　　上面的懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。
　　懒汉式其实是一种比较形象的称谓。既然懒，那么在创建对象实例的时候就不着急。会一直等到马上要使用对象实例
的时候才会被创建，懒人嘛，总是推脱不开的时候才会真正执行工作，因此在装载对象的时候不创建对象实例。
private static Singleton single=null;
　　懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间
　　由于懒汉式的实现是线程安全的，这样会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式实现呢？
3、双重检查加锁
　　可以使用“双重检查加锁”的方式来实现，就可以达到实现线程安全，又能使性能不受很大影响。
　　双重检查加锁：并不是每次进入getInstance()都需要同步，而是先不同步，进入方法后，先检查单例对象是否存在，如果不存在才进行下面的同步块，这是第一重检查，进入同步块后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例（单例对象）,这是第二重检查。这样就只需要同步一次，从而减轻了多次在同步情况下进行判断所浪费的时间。
　　“双重检查加锁”机制的实现会使用关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。不清楚volatile的看过来
代码实例：
public class Singleton {
private volatile static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null){
synchronized (Singleton.class) {
if(instance == null){
instance = new Singleton();
　　这种实现方式既可以实现线程安全地创建实例，而又不会对性能造成太大的影响。它只是第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。
　　提示：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高。因此一般建议，没有特别的需要，不要使用。也就是说，虽然可以使用“双重检查加锁”机制来实现线程安全的单例，但并不建议大量采用，可以根据情况来选用。
　　根据上面的分析，常见的两种单例实现方式都存在小小的缺陷，那么有没有一种方案，既能实现延迟加载，又能实现线程安全呢？那就是下面一种方法，放大招了，接着呦。
4、静态内部类
public class Singleton {
private Singleton(){}
类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
private static class SingletonHolder{
* 静态初始化器，由JVM来保证线程安全
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return SingletonHolder.
当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。
5、单例和枚举
public enum Singleton {
* 定义一个枚举的元素，它就代表了Singleton的一个实例。
* 单例可以有自己的操作
public void singletonOperation(){
按照《高效Java 第二版》中的说法：单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单，只需要编写一个包含单个元素的枚举类型即可。
　　对我来说，我比较喜欢第一种和第四种方式，简单易懂。而且在JVM层实现了线程安全（如果不是多个类加载器环境）。一般的情况下，我会使用第一种方式，只有在要明确实现lazy loading效果时才会使用第四种方式
五、Android中典型的单例模式Application类
1、Application是什么？
　　Application和Activity,Service一样,是android框架的一个系统组件，当android程序启动时系统会创建一个 application对象，用来存储系统的一些信息。通常我们是不需要指定一个Application的，这时系统会自动帮我们创建，如果需要创建自己 的Application，也很简单创建一个类继承 Application并在manifest的application标签中进行注册(只需要给Application标签增加个name属性把自己的 Application的名字定入即可)。
　　android系统会为每个程序运行时创建一个Application类的对象且仅创建一个，所以Application可以说是单例 (singleton)模式的一个类.且application对象的生命周期是整个程序中最长的，它的生命周期就等于这个程序的生命周期。因为它是全局 的单例的，所以在不同的Activity,Service中获得的对象都是同一个对象。所以通过Application来进行一些，数据传递，数据共享 等,数据缓存等操作。
2、巧妙运用单例模式特点，通过Application来传递数据
　　假如有一个Activity A, 跳转到 Activity B ,并需要推荐一些数据，通常的作法是Intent.putExtra() 让Intent携带，或者有一个Bundle把信息加入Bundle让Intent推荐Bundle对象，实现传递。但这样作有一个问题在 于，Intent和Bundle所能携带的数据类型都是一些基本的数据类型，如果想实现复杂的数据传递就比较麻烦了，通常需要实现 Serializable或者Parcellable接口。这其实是Android的一种IPC数据传递的方法。如果我们的两个Activity在同一个 进程当中为什么还要这么麻烦呢，只要把需要传递的对象的引用传递过去就可以了。
基本思路是这样的。在Application中创建一个HashMap ，以字符串为索引，Object为value这样我们的HashMap就可以存储任何类型的对象了。在Activity A中把需要传递的对象放入这个HashMap，然后通过Intent或者其它途经再把这索引的字符串传递给Activity B ,Activity B 就可以根据这个字符串在HashMap中取出这个对象了。只要再向下转个型 ，就实现了对象的传递。
经过网上的爬文终于了解了什么是单例模式，在这里感谢
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！Java中为什么要使用单例模式
1.什么是单例？
一个类在整个系统中只有一个实例，而且这个实例是在类的内部通过一个private的构造方法构造的，外部不能调用其构造方法，只能获取它的实例。
2.单例的类是怎样的？外部如何使用？
public class SingleInstance {
private static class InstanceHolder {
public static final SingleInstance instance = new SingleInstance();
public static SingleInstance getInstance() {
return InstanceHolder.
使用方法，获取一个单例（通过调用genInstance()方法来获取instance实例，而不是new一个对象。整个系统只允许存在一个实例）：
Singleton obj = Singleton.getInstance();
注：这里使用静态内部类有一个好处，用到单例的时候才去创建，节省空间。
3.在哪里用到单例：
1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~
2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。
4. 应用程序的日志应用，一般都用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为用单例模式来维护，就可以大大降低这种损耗。
7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
9. HttpApplication 也是单例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.
4.为什么要用单例：
（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。
（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！java 单例设计模式使用场景
单例设计模式是23种设计模式中最常见，也是最容易理解的设计模式，之前有很多人写过单例模式，千篇一律，各抒己见…
我们都知道：一个类的内在加载分解过程为：
new出来的对象在堆中。
全局变量存储在全局数据区中。
局部变量存储在栈区。
普通方法存在方法区。
static修饰的方法则在静态方法区中。
静态方法的加载优先于普通方法加载。
静态方法并且可以通过类名点方法名（class.method）调用，普通方法必须先new对象才能调用。
全局变量的范围要大于局部变量的使用范围。
而单例模式，其构造方法是私有的，对象自己先new自己于堆中，其所有的普通方法都是在方法区中。
单例模式常用有两种形式：懒汉式和饿汉式，
其中要考虑的是这两种单例形式是事否在多线程下使用:
如果是在多线程下使用，那么就使用饿汉式。
为什么呢(小沈阳的疑问)?
在多线程的情况下,例如两个线程下使用懒汉式,第一线程刚创建完准备要返回就被第二线程抢到了又重新创建了一遍,这时就有两个对象存在了,那就不符合单例的原则了,所以才有了饿汉式单例,无论是一线程还是二线程抢到使用,对象都只有一个…
1.懒汉式：需要时才创建于堆中，多线程情况下不能保证唯一性
* Created by bob on .单例之懒汉式
public class Singleton {
private static String TAG = "Singleton";
private static Singleton singleton = null;
private Singleton() {
public static Singleton getInstance() {
if (null == singleton) {
singleton = new Singleton();
public void printStr() {
Log.i(TAG, "初始化后调用了...");
2.饿汉式：一使用就创建,并且唯一
* Created by bob on .单例之饿汉式
public class Singleton {
private static String TAG = "Singleton";
private static Singleton singleton = new Singleton();
private Singleton() {
public static Singleton getInstance() {
public void printStr() {
Log.i(TAG, "初始化后调用了...");
那么我们常用单例模式做什么操作呢?
1.封装一些常用的工具类，保证整个应用常用的数据统一
2.保存一些共享数据在内存中，其他类随时可以读取。
其次是单例使用的优缺点：
1、提供了对唯一实例的受控访问。
2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
3、允许可变数目的实例。
1、由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
2、单例类的职责过重，在一定程度上违背了“单一职责原则”。
3、滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。
好了，单例就写到这里，有什么错误的地方请留言，觉得帮助到你的话请点个赞就是对作者的鼓励…
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！}