Немодифицируемая обертка для наборов Java делают их ориентированными на многопотоковое исполнение?
Вы можете получить доступ к переменной «N» или 3 символам перед i, выполнив:
for i,str in enumerate(myString):
if str == "7":
myList.append(myString[i-3])
Перечисление начнется с i = 0 и будет добавлять 1 к i каждый раз, когда цикл будет продолжаться, но я посоветую вам добавить условие, чтобы избежать отрицательного числа, и ошибку в myString[i-3], например:
for i,str in enumerate(myString):
if (i > 2 and str == "7"):
myList.append(myString[i-3])
9 ответов
Это зависит. Обертка только предотвратит изменения в наборе, который она переносит, не в объектах в наборе. Если у Вас есть ArrayList ArrayLists, глобальный Список, а также каждый из его Списков элемента должен быть перенесен отдельно, и Вам, вероятно, также придется сделать что-то для содержания тех списков. Наконец, необходимо удостовериться, что исходные объекты списка не изменяются, так как обертка только предотвращает изменения через ссылку обертки, не к исходному объекту.
Вам НЕ нужна синхронизируемая обертка в этом случае.
На связанную тему - я видел, что несколько ответов предлагают использовать синхронизируемый набор, для достижения потокобезопасности. Используя синхронизируемую версию набора не делает это "ориентированным на многопотоковое исполнение" - хотя каждая операция (вставляют, количество и т.д.) защищена взаимным исключением при объединении двух операций, нет никакой гарантии, что они выполнились бы атомарно. Например, следующий код не ориентирован на многопотоковое исполнение (даже с синхронизируемой очередью):
if(queue.Count > 0)
{
queue.Add(...);
}
Немодифицируемая обертка только предотвращает изменения в структуре списка, к которому она относится. Если этот список содержит другие списки, и у Вас есть потоки, пытающиеся изменить эти вложенные списки, то Вы не защищены от параллельных рисков модификации.
Я полагаю, что, потому что обертка UnmodifiableList хранит ArrayList к заключительному полю, любые методы чтения на обертке будут видеть список, как это было, когда обертка была создана, пока список не изменяется после того, как обертка создается, и, пока изменяемые ArrayLists в обертке не изменяются (который обертка не может защитить от).
Это будет ориентировано на многопотоковое исполнение, если немодифицируемое представление будет безопасно опубликовано, и модифицируемый оригинал никогда не изменяется (включая все объекты, рекурсивно содержавшиеся в наборе!) после публикации немодифицируемого представления.
, Если Вы хотите продолжать изменять оригинал, тогда можно или создать защитную копию графа объектов набора и возвратить немодифицируемое представление этого, или использовать по сути ориентированный на многопотоковое исполнение список для начала и возвратить немодифицируемое представление этого.
Вы не можете возвращать unmodifiableList (synchonizedList (theList)), если Вы все еще намереваетесь получить доступ к theList, несинхронизируемому впоследствии; если изменяемое состояние совместно используется несколькими потоками, то весь потоки должны синхронизироваться на тот же блокировки, когда они получают доступ к тому состоянию.
От рассмотрения источника Наборов это похоже Немодифицируемый, делает не , делают, это синхронизировалось.
static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
implements Set<E>, Serializable;
static class UnmodifiableCollection<E> implements Collection<E>, Serializable;
синхронизируемые обертки класса имеют взаимоисключающий объект в них сделать синхронизируемые части, так похож на Вас, должен использовать обоих для получения обоих. Или самокрутка!
Неизменный объект по определению ориентирован на многопотоковое исполнение (предположение, что никто не сохраняет ссылки на исходные наборы), таким образом, синхронизация не необходима.
Обертывание внешнего ArrayList с помощью Collections.unmodifiableList () препятствует тому, чтобы клиент изменил его содержание (и таким образом делает это ориентированным на многопотоковое исполнение), но внутренние ArrayLists все еще изменяемы.
Обертывание внутреннего ArrayLists с помощью Collections.unmodifiableList () также препятствует тому, чтобы клиент изменил их содержание (и таким образом делает их ориентированными на многопотоковое исполнение), который является тем, в чем Вы нуждаетесь.
Сообщают нам, вызывает ли это решение проблемы (наверху, использование памяти и т.д.); другие решения могут быть применимы к Вашей проблеме. :)
РЕДАКТИРОВАНИЕ: Конечно, если списки изменяются, они не ориентированы на многопотоковое исполнение. Я предположил, что никакие дальнейшие редактирования не должны были быть сделаны.
Не уверенный, если я понял то, что Вы пытаетесь сделать, но я сказал бы, что ответ в большинстве случаев является "Нет".
при установке ArrayList ArrayList и обоих внешние и внутренние списки никогда не могут изменяться после создания (и во время создания только один поток будет иметь доступ к любой внутренние и внешние списки), они, вероятно, ориентированы на многопотоковое исполнение оберткой (если оба, внешние и внутренние списки перенесены таким способом, которым изменение их невозможно). Все операции только для чтения на ArrayLists, скорее всего, ориентированы на многопотоковое исполнение. Однако Sun не делает гарантия их, чтобы быть ориентированным на многопотоковое исполнение (также не для операций только для чтения), поэтому даже при том, что он мог бы работать правильно теперь, он мог прервать будущее (если Sun создает некоторое внутреннее кэширование данных для более быстрого доступа, например).
Это необходимо если:
- существует все еще ссылка на исходный модифицируемый список.
- к списку возможно получат доступ хотя итератор.
, Если Вы намереваетесь читать из ArrayList индексом только, Вы могли бы предположить, что это ориентировано на многопотоковое исполнение.
, Когда в сомнении, выбрал синхронизируемую обертку.