Почему переменные в Java не энергозависимы по умолчанию?
Предполагая, что у вас IIS 7.0 или выше, вы можете настроить аутентификацию сопоставления сертификатов клиентов
Использование Active Directory (Чрезвычайно просто, сопоставление выполняется на сервере AD)
Или с использованием IIS (в IIS требуется дополнительная настройка, требуется доступ к клиентскому сертификату, но он работает автономно, без обращений к AD). В этом случае вы указываете (один или несколько) учетных данных пользователя и
- сопоставляете каждого пользователя с открытым ключом сертификата пользователю, чьи учетные данные вы указываете, или
- сопоставляют несколько сертификатов с пользователь, основываясь на значениях в полях сертификата
Конфигурация (много к одному):
(Пример конфигурации довольно бесстыдно скопирован из примеров на страницах документации iis.net , что довольно сложно.)
Или вы можете настроить свое приложение на использование аутентификации на основе утверждений со службой маркеров безопасности (STS), которая аутентифицирует клиентов на основе клиентских сертификатов. ADFS 2.0 может выполнить эту роль или, если она недоступна, вы можете взглянуть на Thinktecture Identity Server .
6 ответов
Короче говоря, изменчивые переменные - будь то в Java или C # - никогда не кэшируются локально внутри потока. Это не имеет большого значения, если вы не имеете дело с многопроцессорным / многоядерным процессором с потоками, выполняемыми на разных ядрах, поскольку они будут смотреть на один и тот же кеш. Когда вы объявляете переменную как изменчивую, все операции чтения и записи происходят прямо из фактического места в основной памяти и направляются прямо в него; нет никакого кеша. Это имеет значение, когда дело доходит до оптимизации, и делать это без необходимости (когда большинство переменных не должны быть нестабильными) привело бы к снижению производительности (ничтожно, как бы то ни было) с относительно небольшим выигрышем.
Лично я считаю, что поля должны быть окончательными по умолчанию и изменяться только с помощью дополнительного ключевого слова, но эта лодка уже давно отплыла. ;)
Volatiles действительно нужны только тогда, когда вы пытаетесь написать низкоуровневый поточно-безопасный код без блокировок. Большая часть вашего кода, вероятно, не должна быть ни поточно-ориентированной , ни без блокировки. По моему опыту, программирование без блокировок стоит попробовать только после того, как вы обнаружите, что более простая версия, которая выполняет блокировку, значительно снижает производительность из-за блокировки.
Более приятная альтернатива - это использовать другие строительные блоки в java.util.concurrent , некоторые из которых свободны от блокировок, но не беспокоят вашу голову в такой же степени, как попытки сделать все самостоятельно на низком уровне.
Волатильность имеет свои собственные затраты на производительность, и нет причин, по которым большая часть кода должна нести эти затраты.
Поскольку компилятор не может оптимизировать изменчивые переменные.
volatile сообщает компилятору, что переменная может измениться в любое время. Следовательно, нельзя предполагать, что переменная не изменится и не оптимизируется соответствующим образом.
Объявление переменных volatile обычно имеет огромное влияние на производительность. В традиционных однопоточных системах было относительно легко узнать, что должно быть изменчивым; это были те вещи, которые обращались к оборудованию.
В многопоточном режиме это может быть немного сложнее, но я обычно рекомендую использовать уведомления и очереди событий для обработки передачи данных между группами магических переменных. В Java это может не иметь большого значения; в C / C ++ вы столкнетесь с проблемами, если эти переменные не могут быть атомарно установлены базовым оборудованием.
В то время как другие правы, указывая, почему было бы плохой идеей использовать по умолчанию volatile, есть еще один момент, который следует отметить: очень вероятно, что в вашем коде есть ошибка. Переменные редко нужно делать нестабильными: всегда есть способ правильно синхронизировать доступ к переменным (либо с помощью ключевого слова synchronized, либо с использованием объектов AtomicXxx из java.util.concurrency): исключения будут включать код JNI, управляющий ими (который не связан синхронизацией директивы).
Таким образом, вместо добавления volatile вы можете выяснить, ПОЧЕМУ он решил проблему. Это не единственный способ решить эту проблему, и, вероятно, есть способ лучше.