class ABC implements Runnable {
private static int a;
private static int b;
public void run() {
}
}
У меня есть класс Java, как указано выше. У меня несколько потоков этого класса. В методе run() переменные a и b увеличиваются каждый раз в несколько раз. На каждом приращении я помещаю эти переменные в Hashtable.
Следовательно, каждый поток будет увеличивать обе переменные и помещать их в Hashtable. Как я могу сделать эти операции потоками безопасными?
Я бы использовал AtomicInteger, который был спроектирован так, чтобы быть потокобезопасным и мертв, легко использовать и придает абсолютный минимум синхронизации служебные данные для приложения:
class ABC implements Runnable {
private static AtomicInteger a;
private static AtomicInteger b;
public void run() {
// effectively a++, but no need for explicit synchronization!
a.incrementAndGet();
}
}
// In some other thread:
int i = ABC.a.intValue(); // thread-safe without explicit synchronization
В зависимости от того, что должно быть потокобезопасным. Для этих примитивов int вам нужно либо заменить их на AtomicInteger, либо работать только с ними в методе или блоке synchronized. Если вам нужно сделать поточный поток Hashtable для потоковой передачи, вам не нужно ничего делать, поскольку он уже синхронизирован.
Используйте метод synchronized, например.
public synchronized void increment()
{
a++; b++;
// push in to hash table.
}
Вышеприведенное хорошо, если вы получаете доступ к статике через один экземпляр, однако, если у вас есть несколько экземпляров, вам нужно синхронизировать какой-либо статический объект - что-то вроде (непроверено).
private static Object lock = new Object();
в методе
public void increment()
{
synchronize(lock)
{
a++;b++;
// do stuff
}
}
ПРИМЕЧАНИЕ. Эти подходы предполагают, что вы хотите увеличивать a и b за одно атомное действие, другие ответы показывают, как их можно индивидуально увеличить с помощью атомистики.
Я хотел бы добавить некоторые сведения о ответе на этот вопрос.
Во-первых, OP спрашивает о:
Как я могу сделать эти операции потоками безопасными?
Прежде чем ответить на этот вопрос, нам нужно достичь согласованности в отношении потокобезопасности. Определение, которое мне больше всего нравится, состоит в том, что из "Java Concurrency In Practice" и
Класс является потокобезопасным, если он корректно ведет себя при доступе из нескольких потоков, независимо от планирования или чередование выполнения этих потоков во время выполнения окружающей среды и без дополнительной синхронизации или другой координация со стороны вызывающего кода.
Если вы согласны с определением, это означает, что мы достигаем согласованности перед дальнейшим обсуждением. Вернитесь к операциям, которые вы имели в виду, это a++ и b++, после приращения вы поместите их в HashTable.
Для операции a++ это не единственная операция. Он подчиняется модели read edit write. Как вы можете видеть, на самом деле он содержит три отдельных шага. Прочитайте значение, добавьте его и сохраните. Если у вас есть два потока, прочитайте переменную a со значением 1 в одно и то же время после изменений и операций возврата. Значение будет 2, но оно должно быть 3. Чтобы избежать такой ситуации, как и другие, вы можете использовать тип AtomicInteger вместо int. AtomicInteger будет гарантировать, что некоторые операции, такие как приращение, выполняются атомарно. Это означает, что операции read edit write не могут быть разделены и будут выполняться как один отдельный шаг.
После этого OP хочет сохранить значение в HashTable. HashTable - это поточно-безопасный контейнер, никакой другой синхронизации не требуется.
Надеюсь, это разъяснение может помочь кому-то другим способом. Спасибо.