Цель синглтонского рисунка состоит в том, чтобы убедиться, что у класса есть только один экземпляр, а также обеспечивает для него глобальную точку доступа. Чтобы другие работники не создавали наш класс,
Вы можете создать уникальный конструктор для этого класса и установить видимый конструктор на частный. Стоит отметить, что если мы создадим другие не частные конструкторы, или мы вообще не упоминаем о классе
Для конструкторов, тогда другие люди все еще могут создать наше классы. Если мы не хотим заранее создавать объект Singleton, мы можем подождать, пока в первый раз, когда используем объект Singleton, то есть, то есть
Задержка инициализация. Есть две причины для отставания инициализации объектов Singleton:
1. Может быть, во время статической инициализации у вас не хватает информации о том, как инициализировать объект Singleton.
2. Целью выбора синглтона инициализации задержки может быть ожидание таких ресурсов, как подключения к базе данных, особенно в приложениях, где этот синглтон не требуется в определенных конкретных сеансах.
Если синглтон инициализируется в многопоточной среде, мы должны быть осторожны, чтобы предотвратить инициализацию нескольких потоков в одно и то же время.
Обычно шаблон Singleton построен на языке Java:
Lazy Way: относится к глобальному экземпляру Синглтона, который строится, когда он используется впервые. Задержка инициализации.
Метод голодного человека: относится к глобальному отдельному экземпляру, строящемуся во время загрузки класса. Срочная инициализация.
1. Голодный китайский синглтон
Public Class Singleton1 {private singleton1 () {} // определить свой собственный экземпляр внутри. // Обратите внимание, что это частное. Частный статический incestion1 ancement = new singleton1 (); /** * // ** * Вот статический метод для внешнего доступа к этому классу, который можно напрямую, обратно * @return */public static singleton1 getInstance () {return Encement; }}2. Lazy Singleton Class
открытый класс Singleton2 {Private Static Singleton2 Encament = null; /*** // *** Этот метод улучшен по сравнению с вышеизложенным. Он не требует генерирования объектов каждый раз, но в первый раз * генерирует экземпляры при использовании, что повышает эффективность! * @return */ public static singleton2 getInstance () {if (exaction == null) encement = new singleton2 (); вернуть экземпляр; }}Ниже приведены основные проблемы с многопоточным чтением. В Lazy Singletons нет проблем с отдельными потоками, но при многопоточном чтении может быть два или более экземпляров Singletion2.
Например: когда резьба 1 судьи, этот экземпляр == NULL является истинной, при сканировании новой операции, прежде чем выполнять новую операцию и после выполнения новой операции, поток 2 просто выполняет операцию суждения, а экземпляр все еще остается нулевым. Поэтому поток 2 также выполнит новую операцию. И так далее, под высокой параллельностью, может быть два или более экземпляров Singletion2. Очевидно, это неверно.
Поэтому измените код следующим образом:
открытый класс Singleton3 {private Static Singleton3 Encament = null; /*** // *** Этот метод улучшен по сравнению с вышеизложенным. Это не требует, чтобы объект генерировался каждый раз, но первый раз * генерирует случаи при использовании, что повышает эффективность! * Чтобы избежать ошибок в многопользовании, был добавлен флаг синхронизации * @return */ public static synchronized singleton3 getInstance () {if (exant == null) encement = new singleton3 (); вернуть экземпляр; }}Но это создает другую проблему. Методы синхронизируются каждый раз, когда экземпляр получен. Очевидно, что производительность очень затронута, поэтому продолжайте изменять код следующим образом:
летучая, заменить синхронизацию более низкой стоимостью
Почему летучие дешевле, чем синхронизация?
Стоимость синхронизации в основном определяется диапазоном покрытия. Если диапазон синхронизации покрытия может быть уменьшен, производительность программы может быть значительно улучшена.
Покрытие летучего находится только на уровне переменной. Следовательно, его стоимость синхронизации очень низкая.
Каков принцип нестабильного?
Семантика нестабильной на самом деле должна сообщать процессору не помещать меня в рабочую память, пожалуйста, управляйте мне непосредственно в основной памяти. (См. Модель памяти Java для деталей для рабочей памяти)
Следовательно, когда многоъядерный или многопоточный доступ к переменной будет напрямую эксплуатировать основную память, которая по сути достигает обмена переменной.
Каковы преимущества летучих?
1. Большая пропускная способность программы
2. Меньше кода для реализации многопоточного
3. Программа имеет лучшую масштабируемость
4. Это легче понять, и нет необходимости в слишком высоких затратах на обучение.
Каковы недостатки летучих?
1. Склонность к проблемам
2. Трудно спроектировать
Волатильное использование JDK требует версии 1.5 и выше.
Улучшенный код выглядит следующим образом (также называется Double Lock):
Public Class Singleton4 {Частный статический волатильный экземпляр Singleton4; /*** // *** Двойная блокировка для достижения многопоточной оптимизации приложений и производительности* @return*/public static singleton4 getInstance () {if (экземпляр == null) {synchronized (singleton4.class) {// 1 if (экземпляр == null) // 2 экземпляры = new singleton4 (); // 3}} return Encement; }}