synchronized里面直接return跟在外面return有区别吗？

  • Z时代
  • 2024-03-02
  • 分类：IT

为什么最后的方法体里面直接returnSingle()跟single= new Single()的运行结果不一样呢？

public class SingleTest {
    public static void main(String[] args) {
        Single single1 = Single.getSingle();
        Single single12 = Single.getSingle();
        Single single3 = Single.getSingle();
        single1.setAge(23);
        single1.setName("金润");
        System.out.println(single1.getAge());
        single12.setAge(26);
        System.out.println(Single.getSingle().getAge());
        System.out.println(single1.getAge());
        single3.setName("dog");
        System.out.println(single1.getName());
    }
}
//线程安全的单例模式之懒汉式
class Single{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    /**
     * 私有的构造器，让外部无法创建对象
     */
    private Single() {
    }
    /**
     * 懒汉式一开始只声明，并没有new对象。
     *
     */
    private static Single single=null;
    /**
     * 静态的方法，只能通过类.方法获取对象
     * @return 返回new的对象
     */
    public static Single getSingle(){
        if (single==null){
            synchronized (Single.class) {
                single= new Single();
                //为什么不能写成？？
//                return new Single();
            }
        }
        return single;
    }
}

回答：

            synchronized (Single.class) {
                single= new Single();
                //为什么不能写成？？
                return new Single();
            }

你返回的 new Single() 跟存在下来的 single = new Single() 不是同一个啊。这样后面拿来的 return Single() 就跟第一个不一样了。

你里面不要 return new Single(); ，直接 return single; 就可以了。

另外 synchronized 里面其实应该再判断一次：

            synchronized (Single.class) {
                if (single == null) {
                    single = new Single();
                 }
            }

回答：

可以试试不用synchronized的

public class Single {
    private Single() {
        System.out.println("init");
    }
    public static Single getInstance() {
        return InnerSingle.INSTANCE;
    }
    static class InnerSingle {
        static final Single INSTANCE = new Single();
    }
    public static void main(String[] args) {
        final Single instance = Single.getInstance();
        System.out.println(instance);
    }
}

回答：

虽然跟问题无关, 不过懒汉模式可以了解一下如何用内部枚举实现, 这样可以不用两次判断

以上是 synchronized里面直接return跟在外面return有区别吗？ 的全部内容， 来源链接： utcz.com/p/944324.html

回到顶部