简要说明
1、单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使
用单例模式可以提高系统性能
2、当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
3、单例模式 使用的场景：需要 频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、 工具类对象、频繁访问数据库或文件的对象(比如 数据源、session 工厂等)
1、饿汉式单例模式
package singleton;
/**
* 饿汉式单例模式
*/
public class Singleton {
//方法区静态常量池初始化对象
private static final Singleton singleton = new Singleton();
//构造方法私有化，不让外部new
private Singleton(){
}
public static Singleton getInstance(){
return singleton;
}
public void m(){
System.out.println("m");
}
public static void main(String Args[]){
Singleton p1 = Singleton.getInstance();
Singleton p2 = Singleton.getInstance();
System.out.println(p1 == p2);
}
}
饿汉式在类进行初始化的时候就将类实例创建好，不管是否使用。而在使用时直接调用就行，不需要进行判断，同时需要花费大量的空间，典型的空间换时间。
2、懒汉式单例模式
必须加锁，如果不加锁，使用懒汉式的多线程不安全
1,在对象之间加锁，缺点是每个对象都需要进行等待和判断，效率低
package singleton;
/**
* 懒汉式：用的时候进行初始化
*/
public class Singleton2 {
//不需要final，在加final时需要初始化
private static Singleton2 singleton2;
private Singleton2(){
}
public static synchronized Singleton2 getInstance(){
//在此区间可能出现线程不安全
//因此需要加锁使得线程同步，缺点是效率降低
if(singleton2 == null){
try{
Thread.sleep(10);
}catch(Exception e){
e.printStackTrace();
}
singleton2 = new Singleton2();
}
return singleton2;
}
public void m(){
System.out.println("m");
}
public static void main(String[] args) throws Exception{
for (int i = 0; i < 100; i++) {
new Thread(()->{
//从打印区间看看对象的hash码是否相同
System.out.println(Singleton2.getInstance().hashCode());
}).start();
}
}
}
2，改进，使用双重检查
package singleton;
public class Singleton3 {
//不需要final，在加final时需要初始化
private static Singleton3 singleton3;
private Singleton3(){
}
public static Singleton3 getInstance(){
//在此区间可能出现线程不安全
//因此需要加锁使得线程同步，缺点是效率降低
if(singleton3 == null){
//因此需要双重检查
synchronized (Singleton3.class){
if(singleton3 == null){
try{
Thread.sleep(10);
}catch(Exception e){
e.printStackTrace();
}
singleton3 = new Singleton3();
}
}
}
return singleton3;
}
public void m(){
System.out.println("m");
}
public static void main(String[] args) throws Exception{
for (int i = 0; i < 100; i++) {
new Thread(()->{
//从打印区间看看对象的hash码是否相同
System.out.println(Singleton3.getInstance().hashCode());
}).start();
}
}
}
3,使用比较完美的静态内部类实现单例模式
package singleton;
/**
* 完美的写法
*/
public class Singleton4 {
private Singleton4(){
}
//使用静态内部类
private static class Singleton4Hold{
private final static Singleton4 singleton4 = new Singleton4();
}
public static Singleton4 getInstance(){
return Singleton4.getInstance();
}
public void m(){
System.out.println("m");
}
public static void main(String[] args) throws Exception{
for (int i = 0; i < 100; i++) {
new Thread(()->{
//从打印区间看看对象的hash码是否相同
System.out.println(Singleton4.getInstance().hashCode());
}).start();
}
}
}
4，枚举实现单例模式
简单高效，不仅可以解决线程同步的问题，还可以防止被序列化
防止被序列化的原因是因为枚举内部没有构造方法
package singleton;
public enum Singleton5 {
INSTANCE;
public void m(){
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->{
System.out.println(Singleton5.INSTANCE.hashCode());
}).start();
}
}
}
5、总结
-单例对象 占用资源少，不需要延时加载，枚举 好于 饿汉
-单例对象 占用资源多，需要延时加载，静态内部类 好于 懒汉式