Что такого плохого в синглетах? [закрыто]

Картина синглтона является полностью оплаченным членом GoF «s моделея книги , но в последнее время , кажется , довольно сирот в мире разработчика. Я до сих пор использую довольно много синглетов, особенно для фабричных классов , и, хотя вы должны быть немного осторожнее с проблемами многопоточности (как, впрочем, и с любым другим классом), я не понимаю, почему они такие ужасные.

Переполнение стека особенно предполагает, что все согласны с тем, что синглтоны - это зло. Почему?

Пожалуйста, поддержите ваши ответы " фактами, ссылками или конкретными знаниями "

Перефразированный от Брайана Баттона:

1. Они обычно используются как глобальный экземпляр, почему это так плохо? Потому что вы скрываете зависимости вашего приложения в своем коде, вместо того, чтобы показывать их через интерфейсы. Создание чего-то глобального, чтобы избежать его распространения, является запахом кода .

2. Они нарушают принцип единственной ответственности : в силу того, что они контролируют свое собственное творение и жизненный цикл.

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

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

Синглтоны решают одну (и только одну) проблему.

Ресурс Спор.

Если у вас есть какой-то ресурс, который

( 1 ) может иметь только один экземпляр, и

( 2 ) вам нужно управлять этим единственным экземпляром,

Вам нужен синглтон .

Там не так много примеров. Файл журнала большой. Вы не хотите просто отказаться от одного файла журнала. Вы хотите очистить, синхронизировать и закрыть его правильно. Это пример единого общего ресурса, которым нужно управлять.

Это редко, что вам нужен синглтон. Причина, по которой они плохие, заключается в том, что они чувствуют себя глобальными, и они полностью оплачены в GoF Design Patterns. .

Когда вы думаете, что вам нужен глобальный, вы, вероятно, делаете ужасную ошибку дизайна.

Некоторые снобы кодирования смотрят на них свысока как на прославленную глобализацию. Точно так же, как многие люди ненавидят утверждение goto, так и другие ненавидят идею когда-либо использовать глобальные . Я видел, как несколько разработчиков пошли на все, чтобы избежать глобального, потому что они рассматривали возможность использования одного из них как допущение неудачи. Странно, но это правда.

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

Misko Hevery, от Google, имеет несколько интересных статей именно на эту тему ...

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

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

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

Я думаю, что путаница вызвана тем фактом, что люди не знают реального применения паттерна Синглтона. Я не могу подчеркнуть это достаточно. Синглтон - это не шаблон для переноса глобалов. Шаблон Singleton должен использоваться только для гарантии того, что один и только один экземпляр данного класса существует во время выполнения.

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

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

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

Итак, в основном:

public MyConstructor(Singleton singleton) {
    this.singleton = singleton;
}

скорее, чем:

public MyConstructor() {
    this.singleton = Singleton.getInstance();
}

Я полагаю, что такая модель называется внедрением зависимости и обычно считается хорошей вещью

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

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

Синглтоны также являются проблемой с точки зрения тестирования. Они, как правило, затрудняют написание отдельных юнит-тестов. Инверсия контроля (IoC) и внедрение зависимостей - это шаблоны, предназначенные для решения этой проблемы объектно-ориентированным способом, который поддается модульному тестированию.

В сборки мусора синглтоны могут быстро стать проблемой в отношении управления памятью.

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

Синглтон реализуется статическим методом. Люди, которые проводят модульное тестирование, избегают статических методов, потому что их нельзя высмеять или зарезать. Большинство людей на этом сайте являются большими сторонниками модульного тестирования. Общепринятым соглашением избегать их является использование инверсии схемы управления .

Синглтоны также плохи, когда дело доходит до кластеризации . Потому что тогда у вас больше нет «ровно одного синглтона» в вашем приложении.

Рассмотрим следующую ситуацию: Как разработчик, вы должны создать веб-приложение, которое обращается к базе данных. Чтобы параллельные вызовы базы данных не конфликтовали друг с другом, вы создаете сохранение потока SingletonDao:

public class SingletonDao {
    // songleton's static variable and getInstance() method etc. omitted
    public void writeXYZ(...){
        synchronized(...){
            // some database writing operations...
        }
    }
}

Таким образом, вы уверены, что в вашем приложении существует только один синглтон, и все базы данных проходят через этот единственный SingletonDao . Ваша производственная среда теперь выглядит так:

Пока все хорошо.

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

Это звучит странно, но теперь у вас есть много синглетонов в вашем приложении . И это именно то, чем не должен быть синглтон: иметь много объектов. Это особенно плохо, если вы, как показано в этом примере, хотите выполнять синхронизированные вызовы в базу данных.

Конечно, это пример плохого использования синглтона. Но смысл этого примера таков: вы не можете полагаться на то, что в вашем приложении есть ровно один экземпляр синглтона, особенно когда речь идет о кластеризации.

1. Он легко (ab) используется как глобальная переменная.
2. Классы, которые зависят от синглетонов, относительно сложнее для модульного тестирования в изоляции.

Монополия - это дьявол, а синглтоны с нечитаемым / изменяемым состоянием - это «настоящая» проблема ...

После прочтения « Синглетоны - это патологические лжецы», как это было предложено в ответе Джейсона, я натолкнулся на этот маленький кусочек, который дает лучший представленный пример того, как синглтоны часто используются неправильно.

Глобальный это плохо, потому что:

• а. Это вызывает конфликт пространства имен
• б. Это подвергает государство необоснованному

Когда дело доходит до синглетонов

• а. Явный ОО способ их вызова предотвращает конфликты, поэтому укажите а. это не проблема
• б. Синглтоны без состояния (как и фабрики) не являются проблемой. Синглтоны с состоянием могут снова попасть в две категории, которые являются неизменяемыми или пишутся один раз и читают много (файлы конфигурации / свойств). Это не плохо. Мутабельные синглтоны, которые являются своего рода держателями ссылок - это те, о которых вы говорите.

В последнем утверждении он ссылается на концепцию блога «одиночки - лжецы».

Как это относится к монополии?

Чтобы начать игру в монополию, сначала:

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

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

Итак, вы играете в монополию с друзьями Бобом, Джо и Эдом. Вы быстро строите свою империю и занимаете долю рынка по экспоненте. Ваши противники слабеют, и вы начинаете чувствовать запах крови (в переносном смысле). Ваш приятель Боб вложил все свои деньги в блокировку как можно большего количества недорогих объектов недвижимости, но он не получает высокую отдачу от инвестиций, как он ожидал. Боб, как удар неудачи, приземляется на ваш дощатый настил и исключается из игры.

Теперь игра переходит от дружелюбной игры в кости к серьезному бизнесу. Боб стал примером неудачи, а Джо и Эд не хотят в конечном итоге стать «тем парнем». Итак, будучи ведущим игроком, вы внезапно становитесь врагом. Джо и Эд начинают практиковать сделки «за столом», вливания денег за спиной, недооцененный обмен домами и вообще все, что может ослабить вас как игрока, пока один из них не поднимется на вершину.

Затем, вместо того, чтобы выиграть один из них, процесс начинается заново. Внезапно, конечный набор правил становится движущейся целью, и игра вырождается в тип социальных взаимодействий, которые составляли бы основу каждого высококлассного реалити-шоу со времен Survivor. Почему, потому что правила меняются, и нет единого мнения о том, как / почему / что они должны представлять, и что более важно, никто не принимает решения. Каждый игрок в игре, в этот момент, устанавливает свои собственные правила, и за этим следует хаос, пока два игрока не станут слишком уставшими, чтобы не отставать от шарады и медленно сдаваться.

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

Как это относится к программированию?

Помимо всех очевидных проблем с безопасностью потоков и синхронизацией, которые возникают в изменчивых синглетах ... Если у вас есть один набор данных, который может считываться / обрабатываться несколькими различными источниками одновременно и существует в течение времени жизни приложения, Вероятно, сейчас самое время сделать шаг назад и спросить: «Использую ли я здесь правильный тип структуры данных».

Лично я видел, как программист злоупотребляет синглтоном, используя его как некое скрученное многопоточное хранилище базы данных в приложении. Работая непосредственно с кодом, я могу засвидетельствовать, что он был медленным (из-за всех блокировок потоков, необходимых для обеспечения его потоковой безопасности) и кошмаром для работы (из-за непредсказуемой / прерывистой природы ошибок синхронизации), и почти невозможно проверить в условиях «производства». Конечно, система могла бы быть разработана с использованием опроса / сигнализации для преодоления некоторых проблем с производительностью, но это не решило бы проблемы с тестированием и зачем беспокоиться, когда «настоящая» база данных уже может выполнять те же функции в гораздо более надежной среде. / масштабируемый способ.

Синглтон - это только вариант, если вам нужно то, что обеспечивает синглтон. Доступный только для чтения экземпляр объекта. Это же правило должно касаться и свойств / элементов объекта.

Синглтон не о единственном экземпляре!

В отличие от других ответов, я не хочу говорить о том, что не так с Singletons, но чтобы показать вам, насколько они мощные и потрясающие при правильном использовании!

• Проблема : Singleton может быть проблемой в многопоточной среде
  Решение : Используйте однопоточный процесс начальной загрузки для инициализации всех зависимостей вашего singleton.
• Проблема : трудно издеваться над одиночками.
  Решение : использовать метод Factory pattern для издевательства

Вы можете отобразить MyModelна TestMyModelкласс , который наследует это, везде , когда MyModelбудет закачиваться вы получите TestMyModelinstread. - Проблема : синглтоны могут вызвать утечку памяти, поскольку они никогда не утилизируются.
Решение : Ну, избавьтесь от них! Внедрите в свое приложение функцию обратного вызова для правильной утилизации синглетонов, вы должны удалить все связанные с ними данные и, наконец, удалить их из Factory.

Как я уже говорил, в названии синглтона речь идет не об одном экземпляре.

• Singletons улучшает читабельность : вы можете посмотреть на ваш класс и увидеть, какой синглтон он внедрил, чтобы выяснить, каковы его зависимости.
• Singletons улучшает обслуживание : после того, как вы удалили зависимость из класса, вы только что удалили однокомпонентную инъекцию, вам не нужно переходить и редактировать большую ссылку других классов, которые просто перемещали вашу зависимость (Это вонючий код для меня @Jim Burger )
• Singletons улучшает память и производительность : когда что-то происходит в вашем приложении, и для доставки требуется длинная цепочка обратных вызовов, вы тратите впустую память и производительность, с помощью Singleton вы сокращаете средний уровень и улучшаете свою производительность и использование памяти ( избегая ненужных локальных переменных размещения).

Мой ответ о том, как синглтоны плохие, всегда звучит так: «Их трудно сделать правильно». Многие из основополагающих компонентов языков являются синглетонами (классы, функции, пространства имен и даже операторы), как и компоненты в других аспектах вычислений (локальный хост, маршрут по умолчанию, виртуальная файловая система и т. Д.), И это не случайно. Хотя они время от времени доставляют неприятности и разочарование, они также могут заставить многое работать намного лучше.

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

Все говорят о Синглтоне как о глобале, потому что они в основном так и есть. Тем не менее, большая (к сожалению, не вся) вредность в глобальном масштабе проистекает не из того, что он глобальный, а из-за его использования. То же самое касается синглетонов. На самом деле тем более, что «отдельный экземпляр» на самом деле не должен означать «глобально доступный». Это более естественный побочный продукт, и, учитывая все плохое, что мы знаем, оно исходит от нас, мы не должны спешить использовать глобальную доступность. Как только программисты видят Singleton, они, кажется, всегда получают к нему доступ напрямую через метод его экземпляра. Вместо этого вы должны перейти к нему так же, как к любому другому объекту. Большая часть кода даже не должна знать, что имеет дело с синглтоном (слабая связь, верно?). Если только небольшой кусочек кода обращается к объекту, как к глобальному объекту, большой вред отменяется.

Контекст Singleton также очень важен. Определяющей характеристикой Singleton является то, что существует «только один», но на самом деле он «только один» в некотором контексте / пространстве имен. Обычно это один из них: один на поток, процесс, IP-адрес или кластер, но также может быть один на процессор, машину, пространство имен языка / загрузчик классов / что угодно, подсеть, Интернет и т. Д.

Другая, менее распространенная ошибка - игнорировать образ жизни Синглтона. Тот факт, что существует только один, не означает, что синглтон является всемогущим «всегда был и всегда будет», и это не всегда желательно (объекты без начала и конца нарушают все виды полезных предположений в коде и должны использоваться только в самых отчаянных обстоятельствах.

Если вы избежите этих ошибок, Singletons все еще могут быть PITA, но они готовы увидеть, что многие худшие проблемы значительно смягчены. Представьте себе Java Singleton, который явно определяется как один раз для загрузчика классов (что означает, что ему нужна политика безопасности потоков), с определенными методами создания и уничтожения и жизненным циклом, который определяет, когда и как они будут вызваны, и чей метод «instance» имеет защита пакета, так что к нему обычно обращаются через другие, не глобальные объекты. Все еще потенциальный источник проблем, но, конечно, гораздо меньше проблем.

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

Смотрите Википедию Singleton_pattern

Некоторые люди считают, что он также является анти-паттерном, который использует его чрезмерно, вводя ненужные ограничения в ситуациях, когда единственного экземпляра класса фактически не требуется. [1] [2] [3] [4]

Список литературы (только соответствующие ссылки из статьи)

1. ^ Алекс Миллер. Образцы, которые я ненавижу № 1: Синглтон , июль 2007
2. ^ Скотт Денсмор. Почему синглтоны злые , май 2004
3. ^ Стив Йегге. Синглтоны считаются глупыми , сентябрь 2004
4. ^ JB Рейнсбергер, IBM. Используй свои синглеты с умом , июль 2001

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

Использование одного экземпляра класса является допустимой конструкцией, если в коде применяются следующие средства:

1. Убедитесь, что класс, который будет использоваться как синглтон, реализует интерфейс. Это позволяет реализовать заглушки или макеты, используя один и тот же интерфейс.

2. Убедитесь, что Singleton является поточно-ориентированным. Это дано.

3. Синглтон должен быть простым по природе и не слишком сложным.

4. Во время выполнения вашего приложения, где синглтоны должны быть переданы данному объекту, используйте фабрику классов, которая создает этот объект и заставляет фабрику классов передавать экземпляр singleton классу, который в этом нуждается.

5. Во время тестирования и для обеспечения детерминированного поведения создайте одноэлементный класс в качестве отдельного экземпляра в качестве самого фактического класса или заглушки / макета, который реализует его поведение, и передайте его как есть классу, который в этом нуждается. Не используйте фактор класса, который создает тестируемый объект, который нуждается во синглтоне во время теста, так как он пропустит единственный глобальный экземпляр этого объекта, что противоречит цели.

Мы использовали Singletons в наших решениях с большим успехом, которые можно тестировать, обеспечивая детерминированное поведение в параллельных потоках тестовых прогонов.

Я хотел бы рассмотреть 4 пункта в принятом ответе, надеюсь, кто-то может объяснить, почему я не прав.

1. Почему плохо скрывать зависимости в вашем коде? Уже есть десятки скрытых зависимостей (вызовы времени выполнения C, вызовы API OS, вызовы глобальных функций), и одноэлементные зависимости легко найти (поиск instance ()).

   «Создание чего-то глобального, чтобы избежать его распространения, - это запах кода». Почему бы не передать что-то, чтобы не сделать это одним запахом кода?

   Если вы пропускаете объект через 10 функций в стеке вызовов просто для того, чтобы избежать одиночного вызова, это так здорово?

2. Принцип единой ответственности: я думаю, что это немного расплывчато и зависит от вашего определения ответственности. Уместным будет вопрос, почему добавление этой конкретной «ответственности» к классу имеет значение?

3. Почему передача объекта в класс делает его более тесно связанным, чем использование этого объекта в качестве одиночного изнутри класса?

4. Почему это меняет то, как долго длится государство? Синглтоны могут быть созданы или уничтожены вручную, так что элемент управления все еще там, и вы можете сделать время жизни таким же, как было бы время жизни не-одиночного объекта.

Относительно юнит-тестов:

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

У Винса Хьюстона есть следующие критерии, которые кажутся мне разумными:

Синглтон следует рассматривать только в том случае, если выполнены все три из следующих критериев:

• Право собственности на один экземпляр не может быть назначено разумно
• Ленивая инициализация желательна
• Глобальный доступ не предусмотрен для

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

Синглтоны плохие с пуристической точки зрения.

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

Если вы знаете, что ваше приложение не сильно изменится, с ним все в порядке. Просто знайте, что вам может потребоваться рефакторинг, если ваши требования неожиданно изменятся (что в большинстве случаев вполне нормально).

Синглтоны иногда также усложняют юнит-тестирование .

В паттерне нет ничего неправильного, если он используется для какого-то аспекта вашей модели, который действительно единый.

Я полагаю, что обратная реакция связана с ее чрезмерным использованием, что, в свою очередь, связано с тем, что это самый простой шаблон для понимания и реализации.

Я не собираюсь комментировать доводы добра / зла, но я не использовал их с тех пор, как пришла весна . Использование внедрения зависимостей в значительной степени сняло мои требования к синглтону, сервис-локаторам и фабрикам. Я считаю, что это намного более производительная и чистая среда, по крайней мере, для того типа работы, которую я выполняю (веб-приложения на основе Java).

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

Плохая часть синглтона - это обычно пользователь (или я должен сказать, что использование синглтона нецелесообразно для вещей, для которых он не предназначен). Крупнейший преступник использует синглтон в качестве фиктивной глобальной переменной.

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

Синглтоны затрудняют переход от них к обычным объектам.

Кроме того, слишком просто написать не-поточно-безопасный синглтон.

Вместо того, чтобы использовать синглтоны, вы должны передавать все необходимые служебные объекты от функции к функции. Это можно упростить, если вы оберните их все во вспомогательный объект, например так:

void some_class::some_function(parameters, service_provider& srv)
{
    srv.get<error_logger>().log("Hi there!");
    this->another_function(some_other_parameters, srv);
}

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

Теперь я предпочитаю проектировать контейнер с инверсией управления (IoC) и позволять контейнеру контролировать время жизни. Это дает вам преимущество того, что классы, зависящие от экземпляра, не знают о том, что существует один экземпляр. Время жизни синглтона может быть изменено в будущем. Однажды с таким примером, с которым я недавно столкнулся, была простая настройка от однопоточного к многопоточному.

FWIW, если это PIA, когда вы пытаетесь выполнить юнит-тестирование, то это будет PIA, когда вы пытаетесь отладить, исправить ошибку или улучшить ее.

Недавняя статья на эту тему Криса Рита в « Кодировании без комментариев» .

Примечание. Кодирование без комментариев больше не действует. Тем не менее, ссылка на статью была клонирована другим пользователем.

http://geekswithblogs.net/AngelEyes/archive/2013/09/08/singleton-i-love-you-but-youre-bringing-me-down-re-uploaded.aspx

Синглтоны НЕ плохие. Это плохо, когда вы делаете что-то глобально уникальное, а не уникальное.

Однако существуют «службы области приложения» (подумайте о системе обмена сообщениями, которая обеспечивает взаимодействие компонентов) - это CALLS для одиночного объекта, «MessageQueue» - класс, имеющий метод «SendMessage (...)».

Затем вы можете сделать следующее со всего места:

MessageQueue.Current.SendMessage (new MailArrivedMessage (...));

И, конечно же, сделать:

MessageQueue.Current.RegisterReceiver (это);

в классах, которые реализуют IMessageReceiver.

Слишком много людей помещают объекты, которые не являются потокобезопасными, в шаблон синглтона. Я видел примеры DataContext ( LINQ to SQL ), выполненного в одноэлементном шаблоне, несмотря на тот факт, что DataContext не является потокобезопасным и является чисто единичным объектом.

Вот еще одна вещь о синглетах, о которой еще никто не говорил.

В большинстве случаев «синглтонность» - это деталь реализации некоторого класса, а не характеристика его интерфейса. Обращение Контейнер Контроля может скрыть эту характеристику от пользователей класса; вам просто нужно пометить ваш класс как одиночный (например, с @Singletonаннотацией в Java) и все; IoCC сделает все остальное. Вам не нужно предоставлять глобальный доступ к вашему экземпляру синглтона, потому что доступ уже управляется IoCC. Таким образом, в IoC Singletons нет ничего плохого.

Предполагается, что GoF Singletons в отличие от IoC Singletons предоставляют «единство» в интерфейсе с помощью метода getInstance (), и поэтому они страдают от всего, что сказано выше.

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

Во-первых, класс и его сотрудники должны сначала выполнить свое предназначение, а не фокусироваться на иждивенцах. Управление жизненным циклом (когда создаются экземпляры и когда они выходят за рамки) не должно быть частью ответственности классов. Для этого рекомендуется создать или настроить новый компонент для управления зависимостями с помощью внедрения зависимостей.

Часто программное обеспечение усложняется, имеет смысл иметь несколько независимых экземпляров класса Singleton с различным состоянием. В таких случаях использование кода для простого захвата синглтона является неправильным. Использование Singleton.getInstance()может быть приемлемым для небольших простых систем, но оно не работает / не масштабируется, когда может потребоваться другой экземпляр того же класса.

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

Проблемы, которые синглтон вызывают в тестировании, являются признаком их жестко запрограммированного варианта использования / среды. Набор тестов и множество тестов являются отдельными и отдельными, что несовместимо с жестким кодированием одиночного кода.

Поскольку они в основном являются объектно-ориентированными глобальными переменными, вы обычно можете создавать свои классы таким образом, чтобы они вам не нужны.