android单例模式

A. android中什么是单例模式

单例模式（Singleton）
一、 什么是单例模式
单例模式，简单点来说就是设计一个类，使其在任何时候，最多只有一个实例，并提供一个访问这个实例的全局访问点。

二、 为什么要单例
在程序中的很多地方，只有一个实例是非常重要的。例如，在windows中，任务管理器只有一个，无论你点击多少次打开任务管理器，任务管理器也只会生成一个窗口。再例如，在一些软件中，工具箱是唯一的，无论你点击多少次打开工具箱，工具箱也只一个。

为什么要这样设计呢？因为像任务管理器或工具箱这样的程序，只要有一个就足够完成所有的工作了，多个程序只会白白消耗系统资源，而像任务管理器这类的程序还会引入多个任务管理器之间的同步问题，所以对些这些程序来说，只有一个实例或程序是必要的。

三、 为什么需要单例模式
上面讲到对于某些程序来说，保持其只有一个实例是必要的，但是如何保证一个程序或一个类只有一个实例呢？下面从类的角度来解说。

B. android之单例模式：懒汉式和饿汉式的区别

比较:
饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变。
懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的。

C. Android之什么场景该使用单例模式总结

我来补充下楼上: 进程关闭的时机是: 1.用Process.kill或者shell去杀死进程 2.系统通过memory策略来杀死后台进程。 说说第二种吧，当程序按Home键或者Back键退出后就变做后台进程。 另外，当程序启动了新的进程。而新的进程进入前台模式，此时程序也变成后台进程。 当前台进程退出，后台进程按照堆栈结构再次呈现时。很可能是个重启进程的过程，重启进程意味着单例对象也重新初始化了。这点要尤其谨慎

D. Android中单例模式和静态方法在效率上哪个好

很多人包括我写单例的时候，第一想到的就是懒汉式publicclassSingleton{;privateSingleton(){}(){if(instance==null){instance=newSingleton();}returninstance;}}代码很简单，而且是懒加载，只有调用getInstance方法是才会初始化。但是这样是线程不安全的，即当多个线程并行调用getInstance的时候，就会创建多个实例，不能正常工作。所以这里就有了加锁方式，将整个getInstance方法设为同步，添加synchronized关键字。publicclassSingleton{;privateSingleton(){}(){if(instance==null){instance=newSingleton();}returninstance;}}这样简单粗暴的方式，虽然做到了线程安全，但导致了同一时间内只能有一个线程能够调用getInstance方法。其实我们仅仅需要对初始化的代码进行同步，这就有了双重检验锁方式。publicclassSingleton{;privateSingleton(){}(){if(instance==null){//第一次检查synchronized(Singleton.class){if(instance==null){//第二次检查instance=newSingleton();}}}returninstance;}}这里第二次检查，是因为如果有多个线程同时执行完了第一次检查，这时如果同步块内不进行第二次检查的话，会生成多个实例了。但是看了相关资料后，发现这样还是有点问题。引用资料中的介绍：由于instance=newSingleton()，这并非是一个原子操作，事实上在JVM中这句话大概做了下面3件事情。1.给instance分配内存2.调用Singleton的构造函数来初始化成员变量3.将instance对象指向分配的内存空间（执行完这步instance就为非null了）但是在JVM的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是1-2-3也可能是1-3-2。如果是后者，则在3执行完毕、2未执行之前，被线程二抢占了，这时instance已经是非null了（但却没有初始化），所以线程二会直接返回instance，然后使用，然后顺理成章地报错。我们只需要将instance变量声明成volatile就可以了。

E. android 几种单例模式的写法

先不论单例模式的写法，有些方面是相同的，比如都需要将唯一的对象设置为static的，都需要将构造方法private化，代码如下：
public class MyInstance { private static MyInstance instance; private MyInstance(){}
}
第一种：最原始的单例模式，代码如下：
public static MyInstance getInstance(){ if(instance==null){ instance=new MyInstance();
} return instance;
}
多线程并发时，可能会出现重复new对象的情况，因此不提倡使用。
第二种：将整个方法块进行加锁，保证线程安全。
public static synchronized MyInstance getInstance(){ if(instance==null){ instance=new MyInstance();
} return instance;
}

这种代码下，每条线程都会依次进入方法块内部，虽然实现了单例，但是影响了运行效率，可以使用但是也不怎么提倡。
第三种：进一步优化的方法。
public static MyInstance getsInstance(){ synchronized (MyInstance.class){ if(instance==null){ instance=new MyInstance(); return instance;
}else{ return instance;
}
}
}

这种方式只是第二种方法的一种优化，但是优化有限。
（以下的几种方法比较推荐使用）
第四种：双层判断加锁，效率影响小且保证了线程安全。
public static MyInstance getsInstance() { if (instance == null) { synchronized (MyInstance.class) { if(instance==null){ instance=new MyInstance();
}
}
} return instance;
}

这种方法是对第二种和第三种方法的进一步优化，比较推荐使用。
第五种：内部类实现单例，不用线程锁来实现效率的提升。
public class MyInstance { private MyInstance() {
} public static MyInstance getInstance(){ return MyInstanceHolder.instance;
} private static class MyInstanceHolder{ private static MyInstance instance=new MyInstance();
}
}

在内部类中new对象，再将内部类的对象返回，这种方法是使用了java中class加载时互斥的原理来实现了线程的安全。不加线程锁也使得运行效率不会受到较大的影响。比较提倡。

F. 结合Android 看看单例模式怎么写

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; } } 2，懒汉式单例类 public class Singleton { private static Singleton instance = null; public static synchronized Singleton getInstance() { //这个方法比上面有所改进，不用每次都进行生成对象，只是第一次 //使用时生成实例，提高了效率！ if (instance==null) instance＝new Singleton(); return instance; } } 第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。 注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。 一般来说第一种比较安全 我自己比较常用的方式： public class Singleton { private volatile static Singleton singleton; private Singleton(){} public static Singleton getInstance(){ if(singleton==null){ synchronized(Singleton.class){ if(singleton==null){ singleton=new Singleton(); } } } return singleton; } }

G. 如何完全退出单例模式下的android应用程序，非常好用

首先问题是这样的，比如：我刚进入应用时有一个欢迎页面(E)，随后进入主A，我从A->B->C->D,然后直接从D返回到A，在A中完全退出应用。对于android自带的1.5 - 2.1以及2.2之后完全退出应用的API我都试了，但还是实现不了，有的是能退出，但是欢迎页面就没有了，可能是我的原因。 后来我是这样实现的，当然有点老土，但还是能实现的。如下，同样也欢迎拍砖

public class ExitApplication extends Application {
//存储已打开的Activity集合
private List<Activity> list = new ArrayList<Activity>();

//单例的ExitApplication,目的是在任何的Activity中用的都是同一个集合
private static ExitApplication ea;

private ExitApplication(){

}
public static ExitApplication getInstance(){
if(null==ea){
ea = new ExitApplication();
}
return ea;
}

/**
* 添加Activity到集合中
*/
public void addActivity(Activity activity){
list.add(activity);
}

public void exit(Context context){

Dialog dialog = new AlertDialog.Builder(context).setTitle("确认退出")
.setMessage("确定退出该系统?")
.setPositiveButton("确定",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog,
int which) {
for(Activity activity:list){
activity.finish();
}
System.exit(0);
}
}).setNegativeButton("取消",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog,
int whichButton) {
}

}).create();
dialog.show();
}
}
我这个必须是单例的，因为我要确保把每个UI都加进一个集合中，所以...,至于对单例有疑问的，可以上网查询，
然后在每个Activity的onCreate方法中调用ExitApplication.getInstance().addActivity(this);，然后在处理退出请求中直接调用ExitApplication.getInstance().exit(this);即可。
转载

H. 如何使用android单例模式

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;

}

}

2，懒汉式单例类

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton
getInstance() {

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率！

if (instance==null)

instance＝new Singleton();

return instance; }

}

第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注意到lazy
initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。
一般来说第一种比较安全

我自己比较常用的方式：

public class Singleton {

private volatile static
Singleton singleton;

private Singleton(){}

public static Singleton getInstance(){

if(singleton==null){

synchronized(Singleton.class){

if(singleton==null){

singleton=new Singleton();

}

}

}

return singleton;

}

}

I. android开发时，怎么使项目中所有的activity都是栈内单例模式

android:launchMode="singleInstance"

J. android 单例singleton可否用于多进程

单例模式（Singleton） 一、 什么是单例模式 单例模式，简单点来说就是设计一个类，使其在任何时候，最多只有一个实例，并提供一个访问这个实例的全局访问点。 二、 为什么要单例 在程序中的很多地方，只有一个实例是非常重要的