Паттерны Singleton и Multiton в Java: когда и какой лучше?

Привет, Хабр!

Паттерн Singleton гарантирует существование лишь одного экземпляра класса и предоставляет к нему глобальную точку доступа. Этот паттерн стал почти синонимом чистоты кода в многих сценариях работы с Java, где требуется строго один экземпляр объекта. Но не менее интересный и гибкий паттерн - это Multiton. Менее известный, но не менее мощный, он позволяет создавать множество экземпляров класса и контролировать их число и жизненный цикл через предопределенные ключи.

В этой статье мы рассмотрим эти паттерны и их различия.

Singleton

Суть Singleton заключается не просто в ограничении инстанцирования класса одним объектом, но и в предоставлении универсальной точки доступа к этому экземпляру.

Пн помогает контролировать доступ к ресурсам, которые по своей природе должны быть уникальными. Т.е: доступ к БД, файловой системе или какому-либо общему ресурсу, который требует строгого контроля над своим состоянием и доступностью.

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

С точки зрения реализации, основными моментами Singleton являются:

• Приватный конструктор, который предотвращает прямое создание объекта класса.

• Статическая переменная, которая хранит экземпляр Singleton класса.

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

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

Примеры кода

Рассмотрим пять классических вариантов:

Самый базовый вариант Singleton включает в себя приватный конструктор и статический метод для получения экземпляра:

public class ClassicSingleton {
    private static ClassicSingleton instance;

    private ClassicSingleton() {}

    public static ClassicSingleton getInstance() {
        if (instance == null) {
            instance = new ClassicSingleton();
        }
        return instance;
    }
}

Для обеспечения потокобезопасности в многопоточной среде используется синхронизация:

public class ThreadSafeSingleton {
    private static ThreadSafeSingleton instance;

    private ThreadSafeSingleton() {}

    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

Lazy Holder использует вложенный статический класс для отложенной инициализации экземпляра:

public class LazyHolderSingleton {
    private LazyHolderSingleton() {}

    private static class LazyHolder {
        static final LazyHolderSingleton INSTANCE = new LazyHolderSingleton();
    }

    public static LazyHolderSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

Использование перечислений для реализации Singleton гарантирует противодействие проблемам сериализации:

public enum EnumSingleton {
    INSTANCE;

    public void someMethod() {
        // Реализация метода
        System.out.println("Log message: " + message);
    }
}

Double-checked locking для ленивой инициализации уменьшает затраты на синхронизацию, проверяя экземпляр дважды:

public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {}

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

Реализуем логирование и управление подключением к БД

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

public class LoggerSingleton {
    private static LoggerSingleton instance;
    private LoggerSingleton() {}

    public static synchronized LoggerSingleton getInstance() {
        if (instance == null) {
            instance = new LoggerSingleton();
        }
        return instance;
    }

    public void log(String message) {
        // примитивная реализация записи сообщения в лог
        System.out.println(System.currentTimeMillis() + ": " + message);
    }
}

Singleton также часто используется для управления подключениями к БД, гарантируя, что вся система использует единственное подключение, или управляет пулом подключений через олин экземпляр:

public class DatabaseConnectionSingleton {
    private static DatabaseConnectionSingleton instance;
    private Connection connection;

    private DatabaseConnectionSingleton() {
        try {
            // инициализация подключения к БД
            this.connection = DriverManager.getConnection("jdbc:example:database:url", "user", "password");
        } catch (SQLException e) {
            // обработка исключения
        }
    }

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

    public Connection getConnection() {
        return connection;
    }
}

Multiton

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

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

Примеры

Пул подключения к БД:

public class DatabaseConnection {
    private static final Map<String, DatabaseConnection> instances = new HashMap<>();

    private DatabaseConnection() {
        // инициализация подключения к базе данных
    }

    public static synchronized DatabaseConnection getInstance(String dbName) {
        if (!instances.containsKey(dbName)) {
            instances.put(dbName, new DatabaseConnection());
        }
        return instances.get(dbName);
    }
}

Кэширование объекта:

public class ObjectCache {
    private static final Map<String, Object> cache = new HashMap<>();

    private ObjectCache() {
        // инициализация кэша
    }

    public static synchronized Object getInstance(String key) {
        if (!cache.containsKey(key)) {
            cache.put(key, new Object());
        }
        return cache.get(key);
    }
}

Лог разных модулей приложения:

public class Logger {
    private static final Map<String, Logger> loggers = new HashMap<>();
    private String moduleName;

    private Logger(String moduleName) {
        this.moduleName = moduleName;
        // инициализация логгера
    }

    public static synchronized Logger getInstance(String moduleName) {
        if (!loggers.containsKey(moduleName)) {
            loggers.put(moduleName, new Logger(moduleName));
        }
        return loggers.get(moduleName);
    }

    public void log(String message) {
        System.out.println("[" + moduleName + "] " + message);
    }

Сравним эти паттерны

Singleton:

1. Описание: гарантирует, что для класса существует только один экземпляр, и предоставляет глобальную точку доступа к нему.

2. Управление экземпляром: один экземпляр класса.

3. Ограничение: нет возможности создавать несколько экземпляров класса.

4. Идентификация: единственный экземпляр идентифицируется по статическому методу или переменной.

5. Применение: используется для доступа к общим ресурсам, кэширования объектов, логирования и т.д.

Multiton:

1. Описание: похож на Singleton, но позволяет создавать и управлять множеством экземпляров класса с уникальными ключами.

2. Управление экземпляром: множество экземпляров класса, каждый из которых идентифицируется уникальным ключом.

3. Ограничение: ограниченное кол-воэкземпляров, определенных по ключам.

4. Идентификация: каждый экземпляр идентифицируется уникальным ключом.

5. Применение: спользуется для управления пулами ресурсов, кэширования с ограниченным размером, управления соединениями к БД и т.д.

Для наглядности сделал табличку:

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

В завершение хочу пригласить вас на бесплатный вебинар, где вы узнаете, что такое дамп памяти, как его собрать и какие инструменты существуют для этих целей. Далее вы познакомитесь с инструментом Eclipse Memory Analyzer, с помощью которого можно исследовать дампы памяти, особенно, если у вас возникает OutOfMemory.

• Зарегистрироваться на бесплатный вебинар