面试官说这个单例模式有问题

周三去面试，其中是有个写单例模式的例子，我写了如下，面试官叫我看清楚点有无什么问题。。。
public class A{
  private static A a=new A();
  public static A getInstance(){
         return a;
  }
}


这个单例模式的例子有问题吗？？？他说要加上synchronized..我晕，不是他回家复习就是我回家复习啦。。。大家指教下

应该是他有问题。。。

1 可能是你论坛发帖没写全……要private构造器

2 你确定他说的不是Serializable序列化，而是synchronized？单例要考虑序列化之后反序列化的问题。

高端点的做法是使用enum来写单例，这样写出来你可以装一把。
public enum A
{
   INSTANCE;

   public void method(){ ... }
}
自动免疫序列化以及反射的问题。
而且简洁……

上面的说的是正确的。

只不过还要添加一个final，表示这个对象的地址不可改变，这个变量a就是固定的了，如果没有final，那该类的另外一个方法可以改变它。顺便付上饿汉和懒汉单例：

饿汉式单例：
public class EagerSingleton
{
  private static final EagerSingleton eagerSingleton = new EagerSingleton();

  private EagerSingleton(){}

  public static EagerSingleton getInstance()
  {
   return eagerSingleton;
  }

}



懒汉室单例：

public class LazeSingleton
{
  private static LazeSingleton lazeSingleton = null;
  
   private LazeSingleton(){}

  public static LazeSingleton getInstance()
  {
   if(lazeSingleton == null){
      lazeSingleton = new LazeSingleton();
   }
      return lazeSingleton;
  }

}

懒汉的少了一个synchronized.

更正为：

懒汉室单例：

public class LazeSingleton
{
  private static LazeSingleton lazeSingleton = null;
  
   private LazeSingleton(){}

  synchronized public static LazeSingleton getInstance()
  {
   if(lazeSingleton == null){
      lazeSingleton = new LazeSingleton();
   }
      return lazeSingleton;
  }

}

周三去面试，其中是有个写单例模式的例子，我写了如下，面试官叫我看清楚点有无什么问题。。。
public class A{
  private static A a=new A();
  public static A getInstance(){
         return a;
  }
}


这个单例模式的例子有问题吗？？？他说要加上synchronized..我晕，不是他回家复习就是我回家复习啦。。。大家指教下

怎么没看到你的构造方法？？？？默认的，默认的可是public的啊

的确，木有私有的构造方法，而且一般单例多用在并发里，最好用synchronized控制。
不过在懒汉式的多线程情况下，可以使用Double-Check Locking：
Java代码  
public class Singleton { // 懒汉式单例   
  
    private static Singleton singleton = null;   
  
    private Singleton() {   
    }   
  
    public static Singleton getInstance() {   
        if (singleton == null) {   
            synchronized (Singleton.class) {   
                            if(singleton == null) {   
                singleton = new Singleton();   
                             }   
            }   
        }   
        return singleton;   
    }   
}  

public class Singleton { // 懒汉式单例

        private static Singleton singleton = null;

        private Singleton() {
        }

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

因此在多线程中，如果每次都要去判断线程中时候时候有实例，很耗性能，这里只要在开始判断即可，如有有了实例就无需进入同步中...

楼上的正解

的确，木有私有的构造方法，而且一般单例多用在并发里，最好用synchronized控制。
不过在懒汉式的多线程情况下，可以使用Double-Check Locking：
Java代码  
public class Singleton { // 懒汉式单例   
  
    private static Singleton singleton = null;   
  
    private Singleton() {   
    }   
  
    public static Singleton getInstance() {   
        if (singleton == null) {   
            synchronized (Singleton.class) {   
                            if(singleton == null) {   
                singleton = new Singleton();   
                             }   
            }   
        }   
        return singleton;   
    }   
}  

public class Singleton { // 懒汉式单例

        private static Singleton singleton = null;

        private Singleton() {
        }

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

因此在多线程中，如果每次都要去判断线程中时候时候有实例，很耗性能，这里只要在开始判断即可，如有有了实例就无需进入同步中...


这个是正解。一般单例是用在实例比较耗资源的场景。一般情况下，饿汉模式已经可以了。

没有把构造函数私有化