Как получать Singleton типа А

# Как получать Singleton типа А

Singleton - это паттерн, который гарантирует что класс имеет только один экземпляр и предоставляет глобальную точку доступа к нему. Есть множество способов его реализовать, от простых до потокобезопасных.

1. Простой Singleton (небезопасный для многопоточности)

public class Logger {
    private static Logger instance;
    
    // Приватный конструктор - нельзя создать через new
    private Logger() {}
    
    // Глобальная точка доступа
    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
}

// Использование
public static void main(String[] args) {
    Logger logger = Logger.getInstance();
    logger.log("Message");
}

Проблема

// ❌ Race condition!
// В многопоточной среде две нити могут создать два экземпляра:
Thread t1: instance == null? YES → создаю instance
Thread t2: instance == null? YES → создаю instance (конкурирует с t1)
// Результат: два разных объекта Logger

2. Синхронизированный Singleton (потокобезопасный, но медленный)

public class DatabaseConnection {
    private static DatabaseConnection instance;
    
    private DatabaseConnection() {}
    
    // synchronized блокирует весь метод
    public synchronized static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

// Использование
DatabaseConnection db = DatabaseConnection.getInstance();

Проблема

// Каждый вызов getInstance() ждет lock
// Даже после первого создания экземпляра!
// Очень медленно в многопоточной среде

3. Double-Checked Locking (оптимизированный синхронизированный)

public class ConfigManager {
    private static volatile ConfigManager instance;
    
    private ConfigManager() {}
    
    public static ConfigManager getInstance() {
        // Первая проверка БЕЗ lock (быстро)
        if (instance == null) {
            synchronized (ConfigManager.class) {
                // Вторая проверка С lock (безопасно)
                if (instance == null) {
                    instance = new ConfigManager();
                }
            }
        }
        return instance;
    }
}

// Использование
ConfigManager config = ConfigManager.getInstance();
String apiKey = config.getApiKey();

Как это работает

Первый вызов:
1. if (instance == null)? ДА → вход в synchronized
2. if (instance == null)? ДА → создаю instance
3. Выход из synchronized

Последующие вызовы:
1. if (instance == null)? НЕТ → return instance (БЕЗ lock)
Очень быстро!

Этот способ почти никогда не используют в production
потому что есть более простой...

4. Lazy Initialization Holder (рекомендуется) ⭐

public class ServiceManager {
    // Приватный конструктор
    private ServiceManager() {}
    
    // Вспомогательный класс-holder
    // Загружается только при первом обращении
    private static class ServiceManagerHolder {
        static final ServiceManager INSTANCE = new ServiceManager();
    }
    
    // Простой и чистый getInstance
    public static ServiceManager getInstance() {
        return ServiceManagerHolder.INSTANCE;
    }
}

// Использование
ServiceManager manager = ServiceManager.getInstance();
manager.startService();

Почему это лучше

✅ Потокобезопасно (гарантировано JVM)
✅ Ленивая инициализация (создается только при первом обращении)
✅ Нет synchronized (очень быстро)
✅ Простой и понятный код
✅ Невозможно нарушить через reflection (частично)

Это стандартный способ в Java!

5. Enum Singleton (самый защищенный) ⭐⭐

public enum DatabasePool {
    INSTANCE;
    
    private Connection[] connections;
    
    // Конструктор для инициализации
    DatabasePool() {
        this.connections = initializeConnections();
    }
    
    private Connection[] initializeConnections() {
        // Инициализация пула соединений
        return new Connection[10];
    }
    
    public Connection getConnection() {
        return connections[0];
    }
    
    private Connection[] initializeConnections() {
        System.out.println("Инициализация пула");
        // Реальная инициализация
        return new Connection[10];
    }
}

// Использование - очень просто!
Connection conn = DatabasePool.INSTANCE.getConnection();

Преимущества Enum Singleton

✅ Потокобезопасно (гарантировано JVM)
✅ Защищено от Reflection атак
✅ Защищено от десериализации
✅ Простейший синтаксис
✅ Сериализуется автоматически

❌ Минусы:
- Нельзя наследовать от других классов
- Выглядит необычно для неопытных

6. Spring Dependency Injection (для enterprise)

// Класс БЕЗ Singleton логики
@Service
public class UserService {
    @Autowired
    private UserRepository repository;
    
    public User findUser(Long id) {
        return repository.findById(id).orElse(null);
    }
}

// Spring сам создает Singleton и управляет им
@Component
public class MyApp {
    @Autowired
    private UserService userService; // Spring инжектит singleton
    
    public void run() {
        User user = userService.findUser(1L);
    }
}

// Конфигурация
@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService(); // Spring кэширует этот объект
    }
}

Как использовать

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class);
        
        // Получить singleton bean из контейнера
        UserService service = context.getBean(UserService.class);
        service.findUser(1L);
    }
}

7. Сравнение всех способов

8. Как нарушить Singleton и защита

Проблема 1: Reflection

// ❌ Reflection может создать новый экземпляр
Logger logger1 = Logger.getInstance();

Constructor<Logger> constructor = Logger.class.getDeclaredConstructor();
constructor.setAccessible(true);
Logger logger2 = constructor.newInstance(); // Новый экземпляр!

// logger1 != logger2 ❌

Решение: Проверка в конструкторе

public class SecureLogger {
    private static SecureLogger instance;
    
    private SecureLogger() {
        // Защита от Reflection
        if (instance != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }
    
    public static synchronized SecureLogger getInstance() {
        if (instance == null) {
            instance = new SecureLogger();
        }
        return instance;
    }
}

Проблема 2: Сериализация

// ❌ Десериализация создает новый объект
Logger logger1 = Logger.getInstance();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("logger.ser"));
oos.writeObject(logger1);

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("logger.ser"));
Logger logger2 = (Logger) ois.readObject(); // Новый экземпляр!

Решение: readResolve метод

public class SerializableLogger implements Serializable {
    private static SerializableLogger instance = new SerializableLogger();
    
    private SerializableLogger() {}
    
    public static SerializableLogger getInstance() {
        return instance;
    }
    
    // Этот метод вызывается при десериализации
    protected Object readResolve() {
        return getInstance();
    }
}

9. Когда использовать Singleton

✅ Используй Singleton для:

• Логгеры
• Конфигурация приложения
• Пулы соединений
• Кэши
• Статические ресурсы (очень дорогие для создания)

❌ НЕ используй Singleton для:

• Объекты состояния (пользователя, сессии)
• Объекты, которые часто меняются
• Тестируемые компоненты (сложно мокировать)
• Когда нужна гибкость (несколько экземпляров)

10. Лучшая практика

// ✅ В modern Java (2025) выбирай в таком порядке:

// 1. Spring @Service/@Component (если есть контейнер)
@Service
public class UserService { }

// 2. Enum (если нет Spring, нужна защита)
public enum Logger {
    INSTANCE;
}

// 3. Holder pattern (если Enum не подходит)
public class Config {
    private static class ConfigHolder {
        static final Config INSTANCE = new Config();
    }
    public static Config getInstance() {
        return ConfigHolder.INSTANCE;
    }
}

// 4. Никогда больше не используй synchronized или Double-Checked

Вывод: Enum Singleton и Holder Pattern - это современные стандарты. В Spring приложениях используй инъекцию зависимостей. Избегай Singleton где возможно - часто есть лучшие альтернативы.