Яке найчастіше питання про сумісність, з яким ви стикалися на Java? [зачинено]

Це опитування на зразок поширених проблем спільної валюти на Java. Прикладом може бути класичний тупиковий стан або стан перегонів або, можливо, помилки з потоком EDT в Swing. Мене цікавить як широта можливих питань, так і питання, які є найбільш поширеними. Отже, будь ласка, залиште одну конкретну відповідь на помилку одночасності Java на коментар і проголосуйте, якщо ви бачите одну, з якою ви стикалися.

Найпоширеніша проблема одночасності, яку я бачив, - це не усвідомлення того, що поле, записане одним потоком, не гарантовано бачити іншим потоком. Загальне застосування цього:

class MyThread extends Thread {
  private boolean stop = false;

  public void run() {
    while(!stop) {
      doSomeWork();
    }
  }

  public void setStop() {
    this.stop = true;
  }
}

До тих пір поки зупинки не летючий або setStopі runНЕ синхронізовані це не гарантує роботу. Ця помилка особливо диявольська, оскільки в 99,999% це не має значення на практиці, оскільки читацька нитка зрештою побачить зміни - але ми не знаємо, як скоро він це побачив.

Моя найболючіша проблема одночасності, коли дві різні бібліотеки з відкритим кодом робили щось подібне:

private static final String LOCK = "LOCK";  // use matching strings 
                                            // in two different libraries

public doSomestuff() {
   synchronized(LOCK) {
       this.work();
   }
}

На перший погляд, це виглядає як досить тривіальний приклад синхронізації. Однак; оскільки струни інтерновані в Java, буквальна рядок "LOCK"виявляється тим самим екземпляром java.lang.String(навіть якщо вони оголошені абсолютно неоднаково один від одного.) Результат, очевидно, поганий.

Одна класична проблема - зміна об'єкта, на якому ви синхронізуєтесь, синхронізуючи його:

synchronized(foo) {
  foo = ...
}

Інші одночасні потоки синхронізуються з іншим об'єктом, і цей блок не забезпечує взаємного виключення, яке ви очікуєте.

Поширеною проблемою є використання таких класів, як Calendar та SimpleDateFormat з декількох потоків (часто кешуючи їх у статичній змінній) без синхронізації. Ці класи не є безпечними для потоків, тому багатопотоковий доступ в кінцевому підсумку спричинить дивні проблеми з непослідовним станом.

Не належна синхронізація з об’єктами, поверненими Collections.synchronizedXXX(), особливо під час ітерації чи декількох операцій:

Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());

...

if(!map.containsKey("foo"))
    map.put("foo", "bar");

Це неправильно . Незважаючи synchronizedна одночасні операції , стан карти між викликом containsі putможе бути змінений іншим потоком. Вона повинна бути:

synchronized(map) {
    if(!map.containsKey("foo"))
        map.put("foo", "bar");
}

Або з ConcurrentMapреалізацією:

map.putIfAbsent("foo", "bar");

Двічі перевірено блокування. За великим рахунком.

Парадигма, за якою я почав вивчати проблеми, коли працював у BEA, полягає в тому, що люди перевірятимуть одиночку таким чином:

public Class MySingleton {
  private static MySingleton s_instance;
  public static MySingleton getInstance() {
    if(s_instance == null) {
      synchronized(MySingleton.class) { s_instance = new MySingleton(); }
    }
    return s_instance;
  }
}

Це ніколи не працює, тому що інший потік, можливо, потрапив до синхронізованого блоку, і s_instance вже не є нульовою. Тож природна зміна полягає в тому, щоб це зробити:

  public static MySingleton getInstance() {
    if(s_instance == null) {
      synchronized(MySingleton.class) {
        if(s_instance == null) s_instance = new MySingleton();
      }
    }
    return s_instance;
  }

Це не працює, тому що модель пам'яті Java не підтримує її. Вам потрібно оголосити s_instance як мінливу, щоб вона працювала, і навіть тоді вона працює лише на Java 5.

Люди, які не знайомі з тонкощами моделі пам'яті Java, псують це весь час .

Хоча, мабуть, не саме те, про що ви просите, найчастіша проблема, пов’язана з одночасністю, з якою я стикався (можливо, тому, що вона з'являється у звичайному однопотоковому коді) - це

java.util.ConcurrentModificationException

викликані такими речами, як:

List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c"));
for (String string : list) { list.remove(string); }

Думаю, що синхронізовані колекції дають вам більший захист, ніж вони насправді, і забути утримувати замок між дзвінками. Я кілька разів бачив цю помилку:

 List<String> l = Collections.synchronizedList(new ArrayList<String>());
 String[] s = l.toArray(new String[l.size()]);

Наприклад, у другому рядку вище toArray()і size()обидва способи є безпечними для потоку, але значення size()оцінюється окремо відtoArray() , а блокування у списку не проводиться між цими двома викликами.

Якщо ви запускаєте цей код за допомогою іншого потоку, одночасно видаляючи елементи зі списку, рано чи пізно у вас з’явиться новий String[]повернутий, який більший, ніж потрібно для вміщення всіх елементів у списку, і має нульові значення в хвості. Неважко подумати, що оскільки два виклики методу до Списку відбуваються в одному рядку коду, це якимось чином атомна операція, але це не так.

Найпоширеніша помилка, яку ми бачимо, де я працюю, - це програмісти, які виконують довгі операції, як-от виклики сервера, на EDT, блокуючи GUI на кілька секунд і роблячи додаток невідповідним.

Забувши зачекати () (або Condition.await ()) у циклі, перевіривши, чи справді умова очікування справдиться. Без цього ви стикаєтеся з помилками через помилкові пробудження wait (). Канонічне використання повинно бути:

 synchronized (obj) {
     while (<condition does not hold>) {
         obj.wait();
     }
     // do stuff based on condition being true
 }

Ще одна поширена помилка - це погана обробка виключень. Коли фоновий потік видає виняток, якщо ви не обробляєте його належним чином, ви можете взагалі не побачити сліду стека. Або, можливо, ваше фонове завдання перестає виконуватись і ніколи не запускається заново, оскільки ви не впоралися з винятком.

Поки я не брав заняття з Брайаном Гетцем, я не розумів, що несинхронізоване getterприватне поле, мутоване за допомогою синхронізованого setter, ніколи не гарантує повернення оновленого значення. Тільки тоді, коли змінна захищена синхронізованим блоком на обох прочитаних І записаних , ви отримаєте гарантію останнього значення змінної.

public class SomeClass{
    private Integer thing = 1;

    public synchronized void setThing(Integer thing)
        this.thing = thing;
    }

    /**
     * This may return 1 forever and ever no matter what is set
     * because the read is not synched
     */
    public Integer getThing(){
        return thing;  
    }
}

Думаючи, що ви пишете однопотоковий код, але використовуєте змінну статику (включаючи одинакові). Очевидно, вони будуть розділені між потоками. Це трапляється напрочуд часто.

Виклики довільних методів не повинні здійснюватися із синхронізованих блоків.

Дейв Рей торкнувся цього у своїй першій відповіді, і насправді я також зіткнувся з тупиком, що також стосується виклику методів для слухачів із синхронізованого методу. Я думаю, що більш загальним уроком є ​​те, що виклики методів не слід робити "в дику природу" зсередини синхронізованого блоку - ви не маєте уявлення, чи буде виклик довготривалим, чи призведе до тупикової ситуації чи будь-чого іншого.

У цьому випадку і, як правило, загалом, рішення полягало в тому, щоб зменшити область застосування синхронізованого блоку, щоб просто захистити критичну приватний розділ коду.

Крім того, оскільки ми тепер отримували доступ до Колекції слухачів поза синхронізованого блоку, ми змінили це на Збірник копіювання за записом. Або ми могли просто зробити захисну копію колекції. Справа в тому, що зазвичай є альтернативи безпечному доступу до Колекції невідомих об'єктів.

Остання помилка, пов’язана з Concurrency, на яку я зіткнувся, - це об’єкт, який у своєму конструкторі створив ExecutorService, але коли на об'єкт більше не було посилань, він ніколи не вимикав ExecutorService. Таким чином, протягом тижня тисячі ниток просочилися, врешті-решт спричиняючи крах системи. (Технічно він не вийшов з ладу, але перестав функціонувати належним чином, продовжуючи працювати.)

Технічно я вважаю, що це не проблема паралельності, але це проблема, що стосується використання бібліотек java.util.concurrency.

Збалансована синхронізація, особливо щодо Карт, здається досить поширеною проблемою. Багато людей вважають, що синхронізація на картах (не ConcurrentMap, але кажуть HashMap), а не синхронізація на get є достатньою. Це, однак, може призвести до нескінченного циклу під час повторного хешування.

Ця ж проблема (часткова синхронізація) може виникнути в будь-якому місці, де ви поділилися станом, але читає і записує.

У сервлетів я зіткнувся з проблемою одночасності, коли є змінні поля, які встановлюватимуться кожним запитом. Але є лише один екземпляр сервлета для всіх запитів, тож це прекрасно працювало в одному середовищі користувача, але коли більше одного користувача просили сервлет виникнути непередбачувані результати.

public class MyServlet implements Servlet{
    private Object something;

    public void service(ServletRequest request, ServletResponse response)
        throws ServletException, IOException{
        this.something = request.getAttribute("something");
        doSomething();
    }

    private void doSomething(){
        this.something ...
    }
}

Не зовсім помилка, але найгіршим гріхом є надання бібліотеки, яку ви збираєтесь використовувати інші люди, але не вказуючи, які класи / методи є безпечними для потоків та які потрібно викликати лише з однієї нитки тощо.

Більше людей повинні використовувати анотації про сумісність (наприклад, @ThreadSafe, @GuardedBy тощо), описані в книзі Геца.

Моя найбільша проблема завжди були тупиками, особливо це викликано слухачами, які звільняються із замком. У цих випадках отримати перевернутий замок між двома нитками дуже просто. У моєму випадку між моделюванням, що працює в одному потоці, і візуалізацією моделювання, що працює в потоці інтерфейсу користувача.

РЕДАКТУВАННЯ: Друга частина перенесена на окрему відповідь

Запустити потік у конструкторі класу проблематично. Якщо клас розширений, потік можна запустити перед виконанням конструктора підкласу .

Класи, що змінюються, в спільних структурах даних

Thread1:
    Person p = new Person("John");
    sharedMap.put("Key", p);
    assert(p.getName().equals("John");  // sometimes passes, sometimes fails

Thread2:
    Person p = sharedMap.get("Key");
    p.setName("Alfonso");

Коли це відбувається, код набагато складніший, ніж цей спрощений приклад. Повторити, знайти та виправити помилку важко. Можливо, цього можна було б уникнути, якби ми могли позначити певні класи як непорушні, а певні структури даних - лише ті, що тримають незмінні об’єкти.

Синхронізація на рядковому буквальному або константному, визначеному літеральним рядком, є (потенційно) проблемою, оскільки інтерламент рядка є інтернованим і буде спільним для всіх інших в JVM, використовуючи той самий літеральний рядок. Я знаю, що ця проблема виникла на серверах додатків та інших «контейнерних» сценаріях.

Приклад:

private static final String SOMETHING = "foo";

synchronized(SOMETHING) {
   //
}

У цьому випадку кожен, хто використовує рядок "foo" для блокування, ділиться тим самим замком.

Я вірю, що в майбутньому основною проблемою Java буде гарантія видимості для конструкторів (відсутність). Наприклад, якщо ви створюєте наступний клас

class MyClass {
    public int a = 1;
}

а потім просто прочитайте властивість MyClass a з іншого потоку, MyClass.a може бути 0 або 1, залежно від реалізації JavaVM та настрою. Сьогодні шанси на «а» бути 1 дуже високі. Але на майбутніх машинах NUMA це може бути інакше. Багато людей цього не знають і вважають, що їм не потрібно дбати про багатопотоковість на етапі ініціалізації.

Найбільш тупа помилка, яку я часто роблю, - це забути синхронізуватись перед тим, як викликати сповіщення () або чекати () на об’єкті.

Використання локального "нового об'єкта ()" як mutex.

synchronized (new Object())
{
    System.out.println("sdfs");
}

Це марно.

Інша поширена проблема "одночасності" - використовувати синхронізований код, коли це зовсім не потрібно. Наприклад, я все ще бачу програмістів, які використовують StringBufferабо навіть java.util.Vector(як локальні змінні).

Кілька об'єктів, які захищені замком, але зазвичай отримують доступ послідовно. Ми натрапили на кілька випадків, коли блокування отримуються за різним кодом у різних порядках, що призводить до тупикової ситуації.

Не розуміючи, що thisвнутрішній клас не thisє зовнішнім класом. Зазвичай в анонімному внутрішньому класі, який реалізує Runnable. Основна проблема полягає в тому, що оскільки синхронізація є частиною всіх Objects, фактично не існує перевірки статичного типу. Я бачив це щонайменше двічі на Usenet, а також з'являється у програмі Brian Goetz'z Java Concurrency in Practice.

Закриття BGGA не страждає від цього, оскільки немає thisдля закриття ( thisпосилається на зовнішній клас). Якщо ви використовуєте необ'єкти thisяк блоки, то це може вирішити цю проблему та інші.

Використання глобального об'єкта, такого як статична змінна для блокування.

Це призводить до дуже поганих результатів через суперечки.

Чесно? До появи java.util.concurrentнайпоширенішої проблеми, з якою я звичайно стикався, було те, що я називаю "обмолотом ниток": програми, які використовують нитки для одночасності, але створюють занадто багато їх і закінчують обробляти.