使用同步解决懒汉式的线程安全问题

最新推荐文章于 2024-10-31 18:26:46 发布

渣瓦攻城狮

最新推荐文章于 2024-10-31 18:26:46 发布

阅读量76

点赞数

分类专栏： Java基础文章标签： java Powered by 金山文档

本文链接：https://blog.csdn.net/m0_63445035/article/details/129073080

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章展示了在Java中，未使用同步机制时，多线程环境下可能导致单例模式失效，输出的Account对象地址不同。而引入同步后，确保了线程安全，两个线程获取到的是同一单例对象。

摘要由CSDN通过智能技术生成

未使用同步解决线程安全问题，并不是单例的，输出的两对象地址不相同

public class SingleTon {
    public static void main(String[] args) {
        CallableImpl callable = new CallableImpl();
        CallableImpl callable1 = new CallableImpl();
        FutureTask<Account> task = new FutureTask<Account>(callable);
        FutureTask<Account> task1 = new FutureTask<Account>(callable1);
        Thread thread = new Thread(task,"线程一");
        Thread thread1 = new Thread(task1,"线程二");
        thread.start();
        thread1.start();
        try {
            Account account = task.get();
            System.out.println("线程一返回结果："+account);
            Account account1 = task1.get();
            System.out.println("线程二返回结果："+account1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class Account{
    private Account(){

    }
    private static Account instance = null;
    public static Account getInstance(){
//        if(instance == null){
//            synchronized (Account.class){
                if(instance == null){
                    instance = new Account();
                }
//            }
//        }
        return instance;
    }
}
class CallableImpl implements Callable<Account> {

    @Override
    public Account call() throws Exception {
        return Account.getInstance();
    }
}

这是输出结果：

使用同步解决线程安全问题后，是单例的，输出的两对象地址相同

public class SingleTon {
    public static void main(String[] args) {
        CallableImpl callable = new CallableImpl();
        CallableImpl callable1 = new CallableImpl();
        FutureTask<Account> task = new FutureTask<Account>(callable);
        FutureTask<Account> task1 = new FutureTask<Account>(callable1);
        Thread thread = new Thread(task,"线程一");
        Thread thread1 = new Thread(task1,"线程二");
        thread.start();
        thread1.start();
        try {
            Account account = task.get();
            System.out.println("线程一返回结果："+account);
            Account account1 = task1.get();
            System.out.println("线程二返回结果："+account1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class Account{
    private Account(){

    }
    private static Account instance = null;
    public static Account getInstance(){
        if(instance == null){
            synchronized (Account.class){
                if(instance == null){
                    instance = new Account();
                }
            }
        }
        return instance;
    }
}
class CallableImpl implements Callable<Account> {

    @Override
    public Account call() throws Exception {
        return Account.getInstance();
    }
}

输出结果：