Синхронизация на Целочисленном значении [дубликат]

Integer.valueOf() только возвраты кэшировали экземпляры для ограниченного диапазона. Вы не определили свой диапазон, но в целом, это не будет работать.

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

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

Между прочим, с помощью WeakHashMap не будет работать также. Если экземпляр, служащий ключом, будет не имеющим ссылки, то он будет собран "мусор". И если на это сильно ссылаются, Вы могли бы использовать его непосредственно.

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

Использование ConcurrentMap.putIfAbsent, но вместо того, чтобы поместить фактическое значение, использование Future с в вычислительном отношении легкой конструкцией вместо этого. Возможно FutureTask реализация. Выполните вычисление и затем get результат, который ориентировано на многопотоковое исполнение заблокируется, пока не сделано.

Используя синхронизируемый на Целом числе звучит действительно неправильным дизайном.

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

// this contains only those IDs that are currently locked, that is, this
// will contain only very few IDs most of the time
Set<Integer> activeIds = ...

Object retrieve(Integer id) {
    // acquire "lock" on item #id
    synchronized(activeIds) {
        while(activeIds.contains(id)) {
            try { 
                activeIds.wait();   
            } catch(InterruptedExcption e){...}
        }
        activeIds.add(id);
    }
    try {

        // do the retrieve here...

        return value;

    } finally {
        // release lock on item #id
        synchronized(activeIds) { 
            activeIds.remove(id); 
            activeIds.notifyAll(); 
        }   
    }   
}

то же переходит к хранилищу.

нижняя строка: нет никакой одной строки кода, который решает эту проблему точно способ, которым Вам нужно.

Как насчет ConcurrentHashMap с Целым числом возражает как ключи?

Вы могли взглянуть на этот код для создания взаимного исключения из идентификатора. Код был написан для Идентификаторов строки, но мог легко быть отредактирован для Целочисленных объектов.

Как Вы видите от множества ответов, существуют различные способы освежевать эту кошку:

• Goetz и подход al хранения кэша FutureTasks работают вполне хорошо в таких ситуациях, где Вы "кэшируете что-то так или иначе", так не возражайте создавать карту объектов FutureTask (и если Вы действительно возражали против роста карты, по крайней мере, легко сделать сокращение его параллельным)
• Как общий ответ на, "как соединить идентификатор", подход, обрисованный в общих чертах Antonio, имеет преимущество, что очевидно, когда карта блокировок добавляется к от.

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

Steve,

Ваш предложенный код имеет набор проблем с синхронизацией. (Antonio делает также).

Для суммирования:

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

псевдо код, чтобы заставить это произойти (использование ConcurrentHashMap как кэш):

ConcurrentMap<Integer, java.util.concurrent.Future<Page>> cache = new ConcurrentHashMap<Integer, java.util.concurrent.Future<Page>>;

public Page getPage(Integer id) {
    Future<Page> myFuture = new Future<Page>();
    cache.putIfAbsent(id, myFuture);
    Future<Page> actualFuture = cache.get(id);
    if ( actualFuture == myFuture ) {
        // I am the first w00t!
        Page page = getFromDataBase(id);
        myFuture.set(page);
    }
    return actualFuture.get();
}

Примечание:

1. java.util.concurrent. Будущее является интерфейсом
2. java.util.concurrent. Будущее на самом деле не имеет набора (), но смотрит на существующие классы, которые реализуют будущее, чтобы понять, как реализовать Ваше собственное будущее (Или использовать FutureTask)
3. , Продвижение фактического извлечения к рабочему потоку почти наверняка будет хорошей идеей.

Посмотрите раздел 5.6 в Параллелизм Java на практике : "Создавая эффективный, масштабируемый, кэш результата". Это занимается точной проблемой, которую Вы пытаетесь решить. В частности, проверьте memoizer шаблон.

_{(источник: umd.edu )}