java单例模式

单例模式： 确保某一个类，只能产生一个实例。

设计思路这样的；

① 将构造函数私有化。确保外部类，确保外部类不能使用new关键字自行创建对象。

②在类的内部实例化一个对象，并通过静态方法返回。

class Singleton{

private Singleton(){
System.out.println("单例模式");
    }
}

　

 

单例模式有以下5种；

饿汉式单例模式

优点；饿汉单例模式线程是安全的。

缺点；正在一加载时，就实例化对象，提前占用系统资源。

 

class Singleton{

 private static Singleton sing = new Singleton();
 public static Singleton getInstance() {
  return sing;
　　}

}

饿汉式单例模式　

优点： 解决了饿汉式单例，一加载就提前占用资源的问题。

缺点： 线程不安全。

class Singleton{
private static Singleton sing = null;
	public static Singleton getInstance() {
	if(sing == null){
	sing = new Singleton();
            }
	return sing;
	}

}    

使用synchronized同步块，对方法进行加锁。 确保 懒汉式单例，可以线程安全。　　

缺点：  每次都需要锁住方法，只允许一个线程访问，效率低下。

synchronized：将一个方法或者是代码块进行加锁，同一时间只允许一个线程访问。

class Singleton{
     private static Singleton sing = null;
     public static synchronized Singleton getInstance() {
      if(sing == null){
       sing = new Singleton();
              }
        return sing;
        }

}                

双重加锁的懒汉模式： 只有第一个sing为null的时候，才进行线程锁。　　

当后续sing不为null时，就无需线程锁 ，可以允许多个线程同时拿走sing。

class Singleton{
    private static Singleton sing = null;
    public static Singleton getInstance() {
        if(sing == null){
        synchronized(Singleton.class){ // 锁住那个类的对象
            if(sing == null){
                sing = new Singleton();
                }
           }
      }
    return sing;
    }
}                        

静态内部类实现单例

解决了饿汉式提前占用资源的问题，解决了懒汉式线程不安全的问题。

class Singleton{
    private static class Singletion1{
    private static Singleton sing = new Singleton();
        }
    public static Singleton getInstance() {
    return Singletion1.sing;
    }
}