Многопоточность на различных экземплярах того же объекта в Java

Вам необходимо выполнить синхронизацию на общем ресурсе. Если этот ресурс является полем уровня класса, вам следует выполнить синхронизацию в самом классе:

public class Foo {
  private static int someNumber = 0;
  // not thread safe
  public void inc_unsafe()  { 
    someNumber++;
  }

  // not thread safe either; we are sync'ing here on an INSTANCE of
  // the Foo class
  public synchronized void inc_also_unsafe()  { 
    someNumber++;
  }

  // here we are safe, because for static methods, synchronized will use the class
  // itself
  public static synchronized void inc_safe()  { 
    someNumber++;
  }

  // also safe, since we use the class itself
  public static synchronized void inc_also_safe()  { 
    synchronized (Foo.class) {
      someNumber++;
    }
  }
}

Обратите внимание, что {{java.util.concurrent}} предоставляет гораздо больше способов защиты общих данных, чем ключевое слово Java {{synchronized}}. Посмотрите на это, возможно, это то, что вам нужно.

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

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

public class Foo {
  private static int someNumber = 0;
  private static int otherNumber = 0;
  private static final Object lock1 = new Object();
  private static final Object lock2 = new Object();

  public static void incSomeNumber() {
    synchronized (lock1) {
      someNumber++;
    }
  }

  public static void incOtherNumber() {
    synchronized (lock2) {
      otherNumber++;
    }
  }
}

Таким образом, два разных потока могут одновременно вызывать incSomeNumber и incOtherNumber, не застревая на синхронизации.

EDIT

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

import java.util.concurrent.atomic.AtomicInteger;

public class Foo {
  private static AtomicInteger someNumber = new AtomicInteger(0);
  private static AtomicInteger otherNumber = new AtomicInteger(0);

  public static int incSomeNumber() {
    return someNumber.incrementAndGet();
  }

  public static int incOtherNumber() {
    return otherNumber.incrementAndGet();
  }
}

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

a) вы написали свой собственный код, который делает магию загрузчика классов
b) Вы сделали что-то странное, например, включили свой код и в war, и в общую папку lib tomcat... и сделали правильную последовательность событий, чтобы две копии были загружены из разных мест.

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