所谓的分布式单例对象是指在分布式系统中，多个分布式节点共享一个对象实例，也就是说在系统的任意给定时刻只能有一个节点持有该对象的唯一的实例对象，在分布式场景中想要实现一个分布式单例对象其核心关键点就是在于如何保证分布式锁和对象的高可用性。下面我们就来看看如何设计一个分布式单例对象的实现。

设计思路

分布式锁

在分布式场景下，我们可以通过分布式锁机制确保在多节点并发环境下，只有一个节点能实例化单例对象。而我们比较常见的分布式锁技术包括Redis、Zookeeper、Etcd等。

实例化控制

在分布式锁的保护下要确保所有节点中，只有一个节点执行实例化代码，其它节点在需要时访问已经生成的实例。

高可用

当然，如果生成单例对象的节点失效，这个时候就需要保证有其他节点接管并重新创建单例对象。所以需要一种“领导者”选举机制，使得当当前持有对象的节点失效时，其他节点能够发现并重新初始化单例对象。

缓存

通过本地缓存机制缓存该对象的引用，减少不必要的分布式锁开销，提高访问性能。

使用Spring Boot实现

下面，我们通过使用Redis实现分布式锁，并结合Spring Boot来实现分布式单实例实现。

首先，我们需要在Spring Boot项目中引入Redis依赖和Spring Boot Starter依赖配置，如下所示。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

在application.yml中配置Redis连接信息

spring:
  redis:
    host: localhost
    port: 6379
    password: ""

实现分布式锁

Redis分布式锁可以通过SETNX命令实现，如下所示，我们可以在Spring中通过StringRedisTemplate来操作Redis，实现分布式锁操作。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class RedisLock {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    public boolean tryLock(String key, String value, long timeout, TimeUnit timeUnit) {
        return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(key, value, timeout, timeUnit));
    }
    
    public void unlock(String key, String value) {
        String currentValue = redisTemplate.opsForValue().get(key);
        if (value.equals(currentValue)) {
            redisTemplate.delete(key);
        }
    }
}

• tryLock：通过setIfAbsent方法尝试获取锁，若获取成功返回true，否则返回false。
• unlock：通过比对锁的唯一值，确保锁是由当前节点持有时才进行释放，避免误删其他节点的锁。

在锁的创建过程中，需要考虑到由于网络波动等原因，可能导致锁失效。所以可以在锁里面加入自动续约机制，保证在锁持有期间不会因锁过期而释放。为了避免Redis单点问题，可以引入Redis集群来解决高可用的问题。或者可以引入Zookeeper或Etcd来简化锁管理和Leader选举，这两种工具的“临时节点”特性天然支持分布式单例实现。

单例对象实现

接下来，就是创建单例对象的过程，创建一个分布式单例类DistributedSingleton，其初始化会使用RedisLock来确保只在一个节点上创建，如下所示。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;

@Component
public class DistributedSingleton {

    private static volatile DistributedSingleton instance;
    private static final String LOCK_KEY = "distributed_singleton_lock";
    private static final String LOCK_VALUE = "singleton_instance_lock";

    @Autowired
    private RedisLock redisLock;

    private DistributedSingleton() {
        // 私有构造函数确保不能直接创建实例
    }

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

    @PostConstruct
    public void init() {
        if (instance == null) {
            boolean lockAcquired = redisLock.tryLock(LOCK_KEY, LOCK_VALUE, 30, TimeUnit.SECONDS);
            if (lockAcquired) {
                try {
                    instance = new DistributedSingleton();
                    System.out.println("Singleton instance created by " + Thread.currentThread().getName());
                } finally {
                    redisLock.unlock(LOCK_KEY, LOCK_VALUE);
                }
            }
        }
    }

    public void performAction() {
        System.out.println("Performing action in singleton instance: " + instance);
    }
}

getInstance方法中使用双重检查锁（DCL）来确保单例的线程安全性。@PostConstruct注解的init方法在实例创建后会尝试获取分布式锁，成功获取后进行实例化。

接下来，我们可以在Controller中测试分布式单例对象的创建，如下所示。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SingletonController {

    @Autowired
    private DistributedSingleton distributedSingleton;

    @GetMapping("/test-singleton")
    public String testSingleton() {
        distributedSingleton.performAction();
        return "Singleton tested!";
    }
}

在多台机器上运行应用或者在单台机器上启动多个端口。访问/test-singleton接口，观察控制台日志，确保只有一个实例会输出创建日志。如果该实例宕机，其他实例可根据Redis锁自动接管并重新生成单例对象。

总结

这种基于Redis分布式锁的单例实现方式适合在分布式系统中保证对象唯一性。结合Spring Boot，实现了系统级别的分布式单例，适用于需要跨节点共享的状态控制和管理场景。