Примеры простых тупиков

92

Я хотел бы объяснить новичкам многопоточность тупиков. В прошлом я видел много примеров тупиковых ситуаций, некоторые с использованием кода, а некоторые с использованием иллюстраций (например, знаменитые 4 машины ). Существуют также классические задачи, которые легко зайти в тупик, такие как The Dining Philosophers , но они могут быть слишком сложными для полного понимания новичком.

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

  1. Относитесь к «реальному» сценарию программирования, который имеет некоторый смысл.
  2. Будьте очень короткими, простыми и понятными

Что вы порекомендуете?

Рои Адлер
источник
почему бы не использовать знаменитые 4 машины, поскольку мне это кажется довольно простым.
vehomzzz
2
Четыре машины не являются сценарием программирования, и для новичка нетривиально абстрагировать проблему в форме четырех машин. Я использую их, но хочу показать программный сценарий, в котором возникает тупик.
Рои Адлер,
Вот пример hackerseve.com/creating-a-deadlock-situation-in-java
user12711663

Ответы:

139

Может быть, простая банковская ситуация.

class Account {
  double balance;

  void withdraw(double amount){
     balance -= amount;
  } 

  void deposit(double amount){
     balance += amount;
  } 

   void transfer(Account from, Account to, double amount){
        sync(from);
        sync(to);

        from.withdraw(amount);
        to.deposit(amount);

        release(to);
        release(from);
    }

}

Очевидно, что если есть два потока, которые пытаются запустить передачу ( a, b ) и передачу ( b, a ) одновременно, то возникнет тупик, потому что они попытаются получить ресурсы в обратном порядке.

Этот код также отлично подходит для поиска решений для выхода из тупика. Надеюсь это поможет!

AAA
источник
1
Было бы идеально, если бы вы или кто-то другой могли решить эту проблему.
Джеки
2
@Jacky Решение этой проблемы опубликовано Уиллом Хартунгом здесь: stackoverflow.com/questions/13326861/avoid-deadlock-example/…
Piotr Chojnacki
2
Меня смущает твой синтаксис. Что такое метод sync ()? Я бы понял, если sync (от); ... release (from); были заменены на синхронизированные (от) {...}
Эллен Спертус
1
@espertus syncможет быть что - то вроде: sync(Account & a) { a.mutex.lock(); }.
vladon 04
1
javaworld.com/article/2075692/java-concurrency/… (Брайан Гетц) объясняет решение этой проблемы.
lingareddyk
59

Пусть природа объяснит тупик,

Тупик: Лягушка против Змеи

«Я бы хотел увидеть, как они разошлись, но я был истощен», - сказал фотограф. «Лягушка все время пыталась оторвать змею, но змея не отпускала» .

введите описание изображения здесь

Ник Дандулакис
источник
59
Симпатично, но не объясняет, как возникают взаимоблокировки в контексте программирования.
jalf
хорошо, Джалф, по крайней мере, ты оправдал отрицательный голос. Во всяком случае, это похоже на пример «4 машины». Мило представление о том , как тупиковый выглядит.
Ник Дандулакис,
@Nick Dandoulakis: Отличная графическая презентация. Изображение объясняет концепцию тупика
Расми Ранджан Наяк
@NickDandoulakis - Не очень хороший пример с картинкой, imho. Здесь будет полезен простой код.
Erran Morad
13
Как это должно быть МИЛЫМ? Ядовитые змеи и лягушки поедают друг друга и это страшно !!!
vikkyhacks
54

Вот пример кода факультета информатики тайваньского университета, демонстрирующий простой пример Java с блокировкой ресурсов. Это очень актуально для меня. Код ниже:

/**
 * Adapted from The Java Tutorial
 * Second Edition by Campione, M. and
 * Walrath, K.Addison-Wesley 1998
 */

/**
 * This is a demonstration of how NOT to write multi-threaded programs.
 * It is a program that purposely causes deadlock between two threads that
 * are both trying to acquire locks for the same two resources.
 * To avoid this sort of deadlock when locking multiple resources, all threads
 * should always acquire their locks in the same order.
 **/
public class Deadlock {
  public static void main(String[] args){
    //These are the two resource objects 
    //we'll try to get locks for
    final Object resource1 = "resource1";
    final Object resource2 = "resource2";
    //Here's the first thread.
    //It tries to lock resource1 then resource2
    Thread t1 = new Thread() {
      public void run() {
        //Lock resource 1
        synchronized(resource1){
          System.out.println("Thread 1: locked resource 1");
          //Pause for a bit, simulating some file I/O or 
          //something. Basically, we just want to give the 
          //other thread a chance to run. Threads and deadlock
          //are asynchronous things, but we're trying to force 
          //deadlock to happen here...
          try{ 
            Thread.sleep(50); 
          } catch (InterruptedException e) {}

          //Now wait 'till we can get a lock on resource 2
          synchronized(resource2){
            System.out.println("Thread 1: locked resource 2");
          }
        }
      }
    };

    //Here's the second thread.  
    //It tries to lock resource2 then resource1
    Thread t2 = new Thread(){
      public void run(){
        //This thread locks resource 2 right away
        synchronized(resource2){
          System.out.println("Thread 2: locked resource 2");
          //Then it pauses, for the same reason as the first 
          //thread does
          try{
            Thread.sleep(50); 
          } catch (InterruptedException e){}

          //Then it tries to lock resource1.  
          //But wait!  Thread 1 locked resource1, and 
          //won't release it till it gets a lock on resource2.  
          //This thread holds the lock on resource2, and won't
          //release it till it gets resource1.  
          //We're at an impasse. Neither thread can run, 
          //and the program freezes up.
          synchronized(resource1){
            System.out.println("Thread 2: locked resource 1");
          }
        }
      }
    };

    //Start the two threads. 
    //If all goes as planned, deadlock will occur, 
    //and the program will never exit.
    t1.start(); 
    t2.start();
  }
}
Кайл Розендо
источник
1
Проблема в том, что это не совсем «реальный» пример. Речь идет о «ресурсе 1» и «ресурсе 2», и было бы неплохо связать это с реальной проблемой программирования (я имею в виду, непосредственно применимым на практике, со ссылкой на проблемную область и т. Д.)
Джей,
7
На мой взгляд, хороший пример. Спасибо.
Джеймс Райцев 08
Этот код, кажется, был опубликован в нескольких разных книгах ... stackoverflow.com/a/11338853/112705
Дэн Дж
15

Если методы method1 () и method2 () будут вызываться двумя или многими потоками, существует большая вероятность тупиковой ситуации, потому что если поток 1 получает блокировку объекта String при выполнении method1 (), а поток 2 получает блокировку объекта Integer во время выполнения method2 () оба будут ждать друг друга, чтобы снять блокировку с Integer и String, чтобы продолжить, чего никогда не произойдет.

public void method1() {
    synchronized (String.class) {
        System.out.println("Acquired lock on String.class object");

        synchronized (Integer.class) {
            System.out.println("Acquired lock on Integer.class object");
        }
    }
}

public void method2() {
    synchronized (Integer.class) {
        System.out.println("Acquired lock on Integer.class object");

        synchronized (String.class) {
            System.out.println("Acquired lock on String.class object");
        }
    }
}
Ashish Chaurasia
источник
Быстро и просто. Ницца.
user1068352
13

Один из простых примеров тупика, с которыми я столкнулся.

public class SimpleDeadLock {
   public static Object l1 = new Object();
   public static Object l2 = new Object();
   private int index;
   public static void main(String[] a) {
      Thread t1 = new Thread1();
      Thread t2 = new Thread2();
      t1.start();
      t2.start();
   }
   private static class Thread1 extends Thread {
      public void run() {
         synchronized (l1) {
            System.out.println("Thread 1: Holding lock 1...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 1: Waiting for lock 2...");
            synchronized (l2) {
               System.out.println("Thread 2: Holding lock 1 & 2...");
            }
         }
      }
   }
   private static class Thread2 extends Thread {
      public void run() {
         synchronized (l2) {
            System.out.println("Thread 2: Holding lock 2...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 2: Waiting for lock 1...");
            synchronized (l1) {
               System.out.println("Thread 2: Holding lock 2 & 1...");
            }
         }
      }
   }
}
Hemanth
источник
Мне нравится этот пример. Но почему класс SimpleDeadLock выходит за пределы Thread? В этом нет необходимости.
Чармин
1
Это почти то же самое, что и этот ответ: stackoverflow.com/a/1385868/1310566 . И что private int indexон там делает?
Саймон Форсберг
6

Вот простой пример на C ++ 11.

#include <mutex>    // mutex
#include <iostream> // cout 
#include <cstdio>   // getchar
#include <thread>   // this_thread, yield
#include <future>   // async
#include <chrono>   // seconds

using namespace std;
mutex _m1;
mutex _m2;

// Deadlock will occur because func12 and func21 acquires the two locks in reverse order

void func12()
{
    unique_lock<mutex> l1(_m1);
    this_thread::yield(); // hint to reschedule
    this_thread::sleep_for( chrono::seconds(1) );
    unique_lock<mutex> l2(_m2 );
}

void func21()
{
    unique_lock<mutex> l2(_m2);
    this_thread::yield(); // hint to reschedule
    this_thread::sleep_for( chrono::seconds(1) );
    unique_lock<mutex> l1(_m1);
}

int main( int argc, char* argv[] )
{
    async(func12);
    func21();
    cout << "All done!"; // this won't be executed because of deadlock
    getchar();
}
Филип Нган
источник
5

Пожалуйста, посмотрите мой ответ на этот вопрос . Итог, когда двум потокам нужно получить два разных ресурса и делать это в разном порядке, вы можете получить взаимоблокировки.

джна
источник
2
Я действительно не вижу смысла дублировать информацию из другого ответа здесь. Я предполагаю, что если вы думаете, что этот ответ можно улучшить, вы можете редактировать его самостоятельно.
djna 06
Я думаю, такая ситуация называется «блокирующая инверсия». Ну, я знаю, что это называется блокирующей инверсией, потому что я так это называю, но я думаю, что это тоже художественный термин для этого :-)
Стив Джессоп
4

Один из примеров, который я могу придумать, - это сценарий «Стол, фонарик и батарейки». Представьте себе фонарик и пару батареек, размещенных на столе. Если вы подойдете к этому столу и возьмете батарейки, пока у другого человека есть фонарик, вы оба будете вынуждены неловко смотреть друг на друга, ожидая, кто первым положит свой предмет обратно на стол. Это пример тупика. Вы и этот человек ждете ресурсов, но никто из вас не отказывается от своих ресурсов.

Точно так же в программе взаимоблокировка возникает, когда два или более потока (вы и другой человек) ждут освобождения двух или более блокировок (фонарик и батарейки), а обстоятельства в программе таковы, что блокировки никогда не освобождаются ( у вас обоих есть одна часть головоломки).

Если вы знаете java, то можете представить эту проблему следующим образом:

import java.util.concurrent.locks.*;

public class Deadlock1 {

    public static class Table {

        private static Lock Flashlight = new ReentrantLock();
        private static Lock Batteries = new ReentrantLock();        

        public static void giveFlashLightAndBatteries() {
            try {
                Flashlight.lock();
                Batteries.lock();
                System.out.println("Lights on");
            } finally {
                Batteries.unlock();
                Flashlight.unlock();
            }
        }

        public static void giveBatteriesAndFlashLight() {
            try {
                Batteries.lock();
                Flashlight.lock();
                System.out.println("Lights on");
            } finally {
                Flashlight.unlock();
                Batteries.unlock();
            }
        }
    }

    public static void main(String[] args) {
        // This thread represents person one
        new Thread(new Runnable() {
            public void run() { Table.giveFlashLightAndBatteries(); }
        }).start();

        // This thread represents person two
        new Thread(new Runnable() {
            public void run() { Table.giveBatteriesAndFlashLight(); }
        }).start();
    }
}

Если вы запустите этот пример, вы заметите, что иногда все работает хорошо и правильно. Но иногда ваша программа просто ничего не печатает. Это потому, что у одного человека есть батарейки, а у другого есть фонарик, который не позволяет им включить фонарик, вызывая тупик.

Этот пример похож на пример, приведенный в руководствах по java: http://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html

Другой пример - пример цикла:

public class Deadlock2 {

    public static class Loop {
        private static boolean done = false;

        public static synchronized void startLoop() throws InterruptedException {
            while(!done) {
                Thread.sleep(1000);
                System.out.println("Not done");
            }
        }

        public static synchronized void stopLoop() {
            done = true;
        }

    }

    public static void main(String[] args) {
        // This thread starts the loop
        new Thread(new Runnable() {
            public void run() {
                try {
                    Loop.startLoop();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // This thread stops the loop
        new Thread(new Runnable() {
            public void run() {
                Loop.stopLoop();
            }
        }).start();
    }
}

Этот пример может либо печатать «Not done» снова и снова, либо он никогда не может печатать «Not done» вообще. Первое происходит потому, что первый поток получает блокировку класса и никогда не снимает ее, предотвращая доступ к «stopLoop» для второго потока. И последнее происходит потому, что второй поток запускается раньше первого потока, в результате чего переменная done становится истинной до того, как первый поток выполнится.

Г_Г
источник
4
public class DeadLock {
    public static void main(String[] args) throws InterruptedException {
        Thread mainThread = Thread.currentThread();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    mainThread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread1.join();
    }
}
gstackoverflow
источник
3

Я считаю, что проблема Dining Philosophers является одним из наиболее простых примеров показа взаимоблокировок, поскольку четыре требования к взаимоблокировкам можно легко проиллюстрировать с помощью рисунка (особенно кругового ожидания).

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

Джулсон Лим
источник
3

Недавно я понял, что ссоры между парами - это не что иное, как тупик ... где обычно один из процессов должен дать сбой, чтобы разрешить его, конечно, это имеет меньший приоритет (Мальчик;)).

Вот аналогия ...

Процесс1: Девушка (G) Процесс2: Мальчик (B) Ресурс1: Извините Ресурс2
: Принятие собственной ошибки

Необходимые условия:
1. Взаимное исключение: только один из G или B может одновременно извиниться или принять свою Ошибка.
2. Удерживайте и ждите: в то время, как один держит «Извините», а другой - «Принимает собственную ошибку», один ждет, пока «Принятие собственной ошибки» отпустит извинение, а другой ждет, пока «извините» отпустит, принимая собственную ошибку.
3. Отсутствие упреждения: даже Бог не может заставить B или G отпустить извинение или принятие собственной ошибки. И добровольно? Ты шутишь, что ли??
4. Круговое ожидание. Опять же, тот, кто извиняется, ждет, пока другой примет свои ошибки, а один из тех, кто примет свои ошибки, хочет, чтобы другой сначала извинился. Так что он круговой.

Таким образом, взаимоблокировки возникают, когда все эти условия действуют одновременно, и это всегда имеет место в парной битве;)

Источник: http://www.quora.com/Saurabh-Pandey-3/Posts/Never-ending-couple-fights-a-deadlock

i_am_saurabh
источник
3

Еще один простой пример взаимоблокировки с двумя разными ресурсами и двумя потоками, ожидающими друг друга, чтобы освободить ресурс. Непосредственно с examples.oreilly.com/jenut/Deadlock.java

 public class Deadlock {
  public static void main(String[] args) {
    // These are the two resource objects we'll try to get locks for
    final Object resource1 = "resource1";
    final Object resource2 = "resource2";
    // Here's the first thread.  It tries to lock resource1 then resource2
    Thread t1 = new Thread() {
      public void run() {
        // Lock resource 1
        synchronized(resource1) {
          System.out.println("Thread 1: locked resource 1");

          // Pause for a bit, simulating some file I/O or something.  
          // Basically, we just want to give the other thread a chance to
          // run.  Threads and deadlock are asynchronous things, but we're
          // trying to force deadlock to happen here...
          try { Thread.sleep(50); } catch (InterruptedException e) {}

          // Now wait 'till we can get a lock on resource 2
          synchronized(resource2) {
            System.out.println("Thread 1: locked resource 2");
          }
        }
      }
    };

    // Here's the second thread.  It tries to lock resource2 then resource1
    Thread t2 = new Thread() {
      public void run() {
        // This thread locks resource 2 right away
        synchronized(resource2) {
          System.out.println("Thread 2: locked resource 2");

          // Then it pauses, for the same reason as the first thread does
          try { Thread.sleep(50); } catch (InterruptedException e) {}

          // Then it tries to lock resource1.  But wait!  Thread 1 locked
          // resource1, and won't release it 'till it gets a lock on
          // resource2.  This thread holds the lock on resource2, and won't
          // release it 'till it gets resource1.  We're at an impasse. Neither
          // thread can run, and the program freezes up.
          synchronized(resource1) {
            System.out.println("Thread 2: locked resource 1");
          }
        }
      }
    };

    // Start the two threads. If all goes as planned, deadlock will occur, 
    // and the program will never exit.
    t1.start(); 
    t2.start();
  }
}
Бхавин Шах
источник
If all goes as planned, deadlock will occur, and the program will never exit.Можем ли мы сделать этот пример guaranteeтупиковым?
Эрран Морад,
Это тот же код, что и опубликовал Кайл , зачем добавлять повторяющийся ответ через три года после другого ответа? (и почему я комментирую это еще через три года?)
Саймон Форсберг
2

Тупик может возникнуть в ситуации, когда кто-то Girl1хочет пофлиртовать с Guy2кем-то, кто пойман другим Girl2, и Girl2хочет флиртовать с Guy1пойманным Girl1. Поскольку обе девушки ждут сброса друг друга, состояние называется тупиковой.

class OuchTheGirls
{
    public static void main(String[] args)
    {
        final String resource1 = "Guy1";
        final String resource2 = "Guy2";

        // Girl1 tries to lock resource1 then resource2
        Thread Girl1 = new Thread(() ->
                                  {
                                      synchronized (resource1)
                                      {
                                          System.out.println("Thread 1: locked Guy1");

                                          try { Thread.sleep(100);} catch (Exception e) {}

                                          synchronized (resource2)
                                          {
                                              System.out.println("Thread 1: locked Guy2");
                                          }
                                      }
                                  });

        // Girl2 tries to lock Guy2 then Guy1
        Thread Girl2 = new Thread(() ->
                                  {
                                      synchronized (resource2)
                                      {
                                          System.out.println("Thread 2: locked Guy2");

                                          try { Thread.sleep(100);} catch (Exception e) {}

                                          synchronized (resource1)
                                          {
                                              System.out.println("Thread 2: locked Guy1");
                                          }
                                      }
                                  });


        Girl1.start();
        Girl2.start();
    }
}
snr
источник
не рекомендуется блокировать классы String или оболочки из-за того, как внутренняя строка и объекты оболочки обрабатываются в java. Множественные ссылки будут указывать на один и тот же объект внутри. Лучше использовать класс Object, если у вас нет настраиваемого объекта.
Локеш
1

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

Майкл Фукаракис
источник
1

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

На самом деле не имеет значения, каковы основные ресурсы; для простоты вы можете просто сделать их парой файлов, в которые оба потока могут писать.

EDIT: это предполагает отсутствие межпроцессного взаимодействия, кроме удерживаемых блокировок.

Джон
источник
1

Я обнаружил, что при чтении проблемы философов-обедающих трудно понять, что тупик, ИМХО, на самом деле связан с распределением ресурсов. Хочу привести более простой пример, где 2 медсестры должны сражаться за 3 снаряжения, чтобы выполнить задание. Хотя написано на java. Создан простой метод lock () для имитации возникновения тупиковой ситуации, поэтому его можно применять и на других языках программирования. http://www.justexample.com/wp/example-of-deadlock/

Просто пример
источник
1

Простой пример из https://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html

public class Deadlock {

public static void printMessage(String message) {

    System.out.println(String.format("%s %s ", Thread.currentThread().getName(), message));

}

private static class Friend {

    private String name;

    public Friend(String name) {
        this.name = name;
    }

    public void bow(Friend friend) {

        printMessage("Acquiring lock on " + this.name);

        synchronized(this) {
            printMessage("Acquired lock on " + this.name);
            printMessage(name + " bows " + friend.name);
            friend.bowBack(this);
        }

    }

    public void bowBack(Friend friend) {

        printMessage("Acquiring lock on " + this.name);

        synchronized (this) {
            printMessage("Acquired lock on " + this.name);
            printMessage(friend.name + " bows back");
        }

    }

}

public static void main(String[] args) throws InterruptedException {

    Friend one = new Friend("one");
    Friend two = new Friend("two");

    new Thread(new Runnable() {
        @Override
        public void run() {
            one.bow(two);
        }
    }).start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            two.bow(one);
        }
    }).start();
}

}

Выход:

Thread-0 Acquiring lock on one 
Thread-1 Acquiring lock on two 
Thread-0 Acquired lock on one 
Thread-1 Acquired lock on two 
Thread-1 two bows one 
Thread-0 one bows two 
Thread-1 Acquiring lock on one 
Thread-0 Acquiring lock on two 

Дамп потока:

2016-03-14 12:20:09
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.74-b02 mixed mode):

"DestroyJavaVM" #13 prio=5 os_prio=0 tid=0x00007f472400a000 nid=0x3783 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Thread-1" #12 prio=5 os_prio=0 tid=0x00007f472420d800 nid=0x37a3 waiting for monitor entry [0x00007f46e89a5000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at com.anantha.algorithms.ThreadJoin$Friend.bowBack(ThreadJoin.java:102)
    - waiting to lock <0x000000076d0583a0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$Friend.bow(ThreadJoin.java:92)
    - locked <0x000000076d0583e0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$2.run(ThreadJoin.java:141)
    at java.lang.Thread.run(Thread.java:745)

"Thread-0" #11 prio=5 os_prio=0 tid=0x00007f472420b800 nid=0x37a2 waiting for monitor entry [0x00007f46e8aa6000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at com.anantha.algorithms.ThreadJoin$Friend.bowBack(ThreadJoin.java:102)
    - waiting to lock <0x000000076d0583e0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$Friend.bow(ThreadJoin.java:92)
    - locked <0x000000076d0583a0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$1.run(ThreadJoin.java:134)
    at java.lang.Thread.run(Thread.java:745)

"Monitor Ctrl-Break" #10 daemon prio=5 os_prio=0 tid=0x00007f4724211000 nid=0x37a1 runnable [0x00007f46e8def000]
   java.lang.Thread.State: RUNNABLE
    at java.net.SocketInputStream.socketRead0(Native Method)
    at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
    at java.net.SocketInputStream.read(SocketInputStream.java:170)
    at java.net.SocketInputStream.read(SocketInputStream.java:141)
    at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
    at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
    at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
    - locked <0x000000076d20afb8> (a java.io.InputStreamReader)
    at java.io.InputStreamReader.read(InputStreamReader.java:184)
    at java.io.BufferedReader.fill(BufferedReader.java:161)
    at java.io.BufferedReader.readLine(BufferedReader.java:324)
    - locked <0x000000076d20afb8> (a java.io.InputStreamReader)
    at java.io.BufferedReader.readLine(BufferedReader.java:389)
    at com.intellij.rt.execution.application.AppMain$1.run(AppMain.java:93)
    at java.lang.Thread.run(Thread.java:745)

"Service Thread" #9 daemon prio=9 os_prio=0 tid=0x00007f47240c9800 nid=0x3794 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread3" #8 daemon prio=9 os_prio=0 tid=0x00007f47240c6800 nid=0x3793 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread2" #7 daemon prio=9 os_prio=0 tid=0x00007f47240c4000 nid=0x3792 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread1" #6 daemon prio=9 os_prio=0 tid=0x00007f47240c2800 nid=0x3791 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread0" #5 daemon prio=9 os_prio=0 tid=0x00007f47240bf800 nid=0x3790 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" #4 daemon prio=9 os_prio=0 tid=0x00007f47240be000 nid=0x378f waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" #3 daemon prio=8 os_prio=0 tid=0x00007f472408c000 nid=0x378e in Object.wait() [0x00007f46e98c5000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x000000076cf88ee0> (a java.lang.ref.ReferenceQueue$Lock)
    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
    - locked <0x000000076cf88ee0> (a java.lang.ref.ReferenceQueue$Lock)
    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
    at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)

"Reference Handler" #2 daemon prio=10 os_prio=0 tid=0x00007f4724087800 nid=0x378d in Object.wait() [0x00007f46e99c6000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x000000076cf86b50> (a java.lang.ref.Reference$Lock)
    at java.lang.Object.wait(Object.java:502)
    at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
    - locked <0x000000076cf86b50> (a java.lang.ref.Reference$Lock)
    at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

"VM Thread" os_prio=0 tid=0x00007f4724080000 nid=0x378c runnable 

"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x00007f472401f000 nid=0x3784 runnable 

"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x00007f4724021000 nid=0x3785 runnable 

"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x00007f4724022800 nid=0x3786 runnable 

"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x00007f4724024800 nid=0x3787 runnable 

"GC task thread#4 (ParallelGC)" os_prio=0 tid=0x00007f4724026000 nid=0x3788 runnable 

"GC task thread#5 (ParallelGC)" os_prio=0 tid=0x00007f4724028000 nid=0x3789 runnable 

"GC task thread#6 (ParallelGC)" os_prio=0 tid=0x00007f4724029800 nid=0x378a runnable 

"GC task thread#7 (ParallelGC)" os_prio=0 tid=0x00007f472402b800 nid=0x378b runnable 

"VM Periodic Task Thread" os_prio=0 tid=0x00007f47240cc800 nid=0x3795 waiting on condition 

JNI global references: 16


Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x00007f46dc003f08 (object 0x000000076d0583a0, a com.anantha.algorithms.ThreadJoin$Friend),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x00007f46dc006008 (object 0x000000076d0583e0, a com.anantha.algorithms.ThreadJoin$Friend),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
    at com.anantha.algorithms.ThreadJoin$Friend.bowBack(ThreadJoin.java:102)
    - waiting to lock <0x000000076d0583a0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$Friend.bow(ThreadJoin.java:92)
    - locked <0x000000076d0583e0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$2.run(ThreadJoin.java:141)
    at java.lang.Thread.run(Thread.java:745)
"Thread-0":
    at com.anantha.algorithms.ThreadJoin$Friend.bowBack(ThreadJoin.java:102)
    - waiting to lock <0x000000076d0583e0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$Friend.bow(ThreadJoin.java:92)
    - locked <0x000000076d0583a0> (a com.anantha.algorithms.ThreadJoin$Friend)
    at com.anantha.algorithms.ThreadJoin$1.run(ThreadJoin.java:134)
    at java.lang.Thread.run(Thread.java:745)

Found 1 deadlock.

Heap
 PSYoungGen      total 74752K, used 9032K [0x000000076cf80000, 0x0000000772280000, 0x00000007c0000000)
  eden space 64512K, 14% used [0x000000076cf80000,0x000000076d8520e8,0x0000000770e80000)
  from space 10240K, 0% used [0x0000000771880000,0x0000000771880000,0x0000000772280000)
  to   space 10240K, 0% used [0x0000000770e80000,0x0000000770e80000,0x0000000771880000)
 ParOldGen       total 171008K, used 0K [0x00000006c6e00000, 0x00000006d1500000, 0x000000076cf80000)
  object space 171008K, 0% used [0x00000006c6e00000,0x00000006c6e00000,0x00000006d1500000)
 Metaspace       used 3183K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 352K, capacity 388K, committed 512K, reserved 1048576K
Ананта Кришнан
источник
1

Вот один простой тупик в Java. Нам нужны два ресурса для демонстрации тупика. В приведенном ниже примере один ресурс - это блокировка класса (через метод синхронизации), а другой - целое число 'i'

public class DeadLock {

    static int i;
    static int k;

    public static synchronized void m1(){
        System.out.println(Thread.currentThread().getName()+" executing m1. Value of i="+i);

        if(k>0){i++;}

        while(i==0){
            System.out.println(Thread.currentThread().getName()+" waiting in m1 for i to be > 0. Value of i="+i);
            try { Thread.sleep(10000);} catch (InterruptedException e) { e.printStackTrace(); }
        }
    }

    public static void main(String[] args) {

        Thread t1 = new Thread("t1") {
            public void run() {
                m1();
            }
        };

        Thread t2 = new Thread("t2") {
            public void run() {
                try { Thread.sleep(100);} catch (InterruptedException e) { e.printStackTrace(); }
                k++;
                m1();
            }
        };

        t1.start();
        t2.start();
    }
}
ernesto
источник
1
public class DeadLock {

    public static void main(String[] args) {
        Object resource1 = new Object();
        Object resource2 = new Object();
        SharedObject s = new SharedObject(resource1, resource2);
        TestThread11 t1 = new TestThread11(s);
        TestThread22 t2 = new TestThread22(s);
        t1.start();
        t2.start();
    }

}

class SharedObject {
    Object o1, o2;
    SharedObject(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }
    void m1() {
        synchronized(o1) {
            System.out.println("locked on o1 from m1()");
            synchronized(o2) { 
                System.out.println("locked on o2 from m1()");
            }
        }
    }
    void m2() {
        synchronized(o2) {
            System.out.println("locked on o2 from m2()");
            synchronized(o1) { 
                System.out.println("locked on o1 from m2()");
            }
        }
    }
}

class TestThread11 extends Thread {
    SharedObject s;
    TestThread11(SharedObject s) {
        this.s = s;
    }
    public void run() {
        s.m1();
    }
}

class TestThread22 extends Thread {
    SharedObject s;
    TestThread22(SharedObject s) {
        this.s = s;
    }
    public void run() {
        s.m2();
    }
}
3515327
источник
1
Не могли бы вы добавить текст, чтобы объяснить свой ответ.
Kmeixner
1

Вот простой тупик в C #.

void UpdateLabel(string text) {
   lock(this) {
      if(MyLabel.InvokeNeeded) {
        IAsyncResult res =  MyLable.BeginInvoke(delegate() {
             MyLable.Text = text;
            });
         MyLabel.EndInvoke(res);
        } else {
             MyLable.Text = text;
        }
    }
}

Если однажды вы вызовете это из потока графического интерфейса пользователя, а другой поток также вызовет его, вы можете заблокироваться. Другой поток переходит к EndInvoke, ожидая, пока поток GUI выполнит делегата, удерживая блокировку. Поток GUI блокируется на той же блокировке, ожидая, пока другой поток освободит его, чего не будет, потому что поток GUI никогда не будет доступен для выполнения делегата, которого ждет другой поток. (конечно, блокировка здесь не является строго необходимой - и, возможно, EndInvoke, но в немного более сложном сценарии блокировка может быть получена вызывающим абонентом по другим причинам, что приведет к тому же тупику.)

нет
источник
0
package test.concurrent;
public class DeadLockTest {
   private static long sleepMillis;
   private final Object lock1 = new Object();
   private final Object lock2 = new Object();

   public static void main(String[] args) {
       sleepMillis = Long.parseLong(args[0]);
       DeadLockTest test = new DeadLockTest();
       test.doTest();
   }

   private void doTest() {
       Thread t1 = new Thread(new Runnable() {
           public void run() {
               lock12();
           }
       });
       Thread t2 = new Thread(new Runnable() {
           public void run() {
               lock21();
           }
       });
       t1.start();
       t2.start();
   }

   private void lock12() {
       synchronized (lock1) {
           sleep();
           synchronized (lock2) {
               sleep();
           }
       }
   }

   private void lock21() {
       synchronized (lock2) {
           sleep();
           synchronized (lock1) {
               sleep();
           }
       }
   }

   private void sleep() {
       try {
           Thread.sleep(sleepMillis);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}
To run the deadlock test with sleep time 1 millisecond:
java -cp . test.concurrent.DeadLockTest 1
солнце007
источник
0
public class DeadlockProg {

    /**
     * @Gowtham Chitimi Reddy IIT(BHU);
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final Object ob1 = new Object();
        final Object ob2 = new Object();
        Thread t1 = new Thread(){
            public void run(){
                synchronized(ob1){
                    try{
                        Thread.sleep(100);
                    }
                    catch(InterruptedException e){
                        System.out.println("Error catched");
                    }
                    synchronized(ob2){

                    }
                }

            }
        };
        Thread t2 = new Thread(){
            public void run(){
                synchronized(ob2){
                    try{
                        Thread.sleep(100);
                    }
                    catch(InterruptedException e){
                        System.out.println("Error catched");
                    }
                    synchronized(ob1){                      
                    }
                }               
            }
        };
        t1.start();
        t2.start();
    }

}
Chitimi Reddy Gowtham
источник
0
package ForkBlur;

public class DeadLockTest {
  public static void main(String args[]) {

    final DeadLockTest t1 = new DeadLockTest();
    final DeadLockTest t2 = new DeadLockTest();

    Runnable r1 = new Runnable() {

        @Override
        public void run() {
            try {

                synchronized (t1) {
                    System.out
                            .println("r1 has locked t1, now going to sleep");
                    Thread.sleep(100);
                    System.out
                            .println("r1 has awake , now going to aquire lock for t2");
                    synchronized (t2) {
                        Thread.sleep(100);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    };

    Runnable r2 = new Runnable() {

        @Override
        public void run() {
            try {

                synchronized (t2) {
                    System.out
                            .println("r2 has aquire the lock of t2 now going to sleep");
                    Thread.sleep(100);
                    System.out
                            .println("r2 is awake , now going to aquire the lock from t1");
                    synchronized (t1) {
                        Thread.sleep(100);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    };

    new Thread(r1).start();
    new Thread(r2).start();
  }
}
user3669507
источник
0

Я создал очень простой пример рабочего DeadLock: -

package com.thread.deadlock;

public class ThreadDeadLockClient {

    public static void main(String[] args) {
        ThreadDeadLockObject1 threadDeadLockA = new ThreadDeadLockObject1("threadDeadLockA");
        ThreadDeadLockObject2 threadDeadLockB = new ThreadDeadLockObject2("threadDeadLockB");

        new Thread(new Runnable() {

            @Override
            public void run() {
                threadDeadLockA.methodA(threadDeadLockB);

            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                threadDeadLockB.methodB(threadDeadLockA);

            }
        }).start();
    }
}

package com.thread.deadlock;

public class ThreadDeadLockObject1 {

    private String name;

    ThreadDeadLockObject1(String name){
        this.name = name;
    }

    public  synchronized void methodA(ThreadDeadLockObject2 threadDeadLockObject2) {
        System.out.println("In MethodA "+" Current Object--> "+this.getName()+" Object passed as parameter--> "+threadDeadLockObject2.getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        threadDeadLockObject2.methodB(this);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }   
}

package com.thread.deadlock;

public class ThreadDeadLockObject2 {

    private String name;

    ThreadDeadLockObject2(String name){
        this.name = name;
    }

    public  synchronized void methodB(ThreadDeadLockObject1 threadDeadLockObject1) {
        System.out.println("In MethodB "+" Current Object--> "+this.getName()+" Object passed as parameter--> "+threadDeadLockObject1.getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        threadDeadLockObject1.methodA(this);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

В приведенном выше примере 2 потока выполняют синхронизированные методы двух разных объектов. Синхронизированный методA вызывается объектом threadDeadLockA, а синхронизированный методB вызывается объектом threadDeadLockB. В методе A передается ссылка на threadDeadLockB, а в методеB передается ссылка на threadDeadLockA. Теперь каждый поток пытается заблокировать другой объект. В methodA поток, удерживающий блокировку для threadDeadLockA, пытается получить блокировку для объекта threadDeadLockB, и аналогично в methodB поток, удерживающий блокировку для threadDeadLockB, пытается получить блокировку для threadDeadLockA. Таким образом, оба потока будут ждать вечно, создав тупик.

Гоял Вики
источник
0

Позвольте мне объяснить более четко на примере, имеющем более двух потоков.

Допустим, у вас есть n потоков, каждый из которых удерживает блокировки L1, L2, ..., Ln соответственно. Теперь предположим, что, начиная с потока 1, каждый поток пытается получить блокировку своего соседнего потока. Итак, поток 1 блокируется за попытку получить L2 (поскольку L2 принадлежит потоку 2), поток 2 блокируется для L3 и так далее. Поток n блокируется для L1. Теперь это тупик, поскольку ни один поток не может выполняться.

class ImportantWork{
   synchronized void callAnother(){     
   }
   synchronized void call(ImportantWork work) throws InterruptedException{
     Thread.sleep(100);
     work.callAnother();
   }
}
class Task implements Runnable{
  ImportantWork myWork, otherWork;
  public void run(){
    try {
      myWork.call(otherWork);
    } catch (InterruptedException e) {      
    }
  }
}
class DeadlockTest{
  public static void main(String args[]){
    ImportantWork work1=new ImportantWork();
    ImportantWork work2=new ImportantWork();
    ImportantWork work3=new ImportantWork();
    Task task1=new Task(); 
    task1.myWork=work1;
    task1.otherWork=work2;

    Task task2=new Task(); 
    task2.myWork=work2;
    task2.otherWork=work3;

    Task task3=new Task(); 
    task3.myWork=work3;
    task3.otherWork=work1;

    new Thread(task1).start();
    new Thread(task2).start();
    new Thread(task3).start();
  }
}

В приведенном выше примере вы можете видеть, что есть три потока, содержащих Runnableзадачи task1, task2 и task3. Перед оператором sleep(100)потоки получают блокировки трех рабочих объектов при входе в call()метод (из-за наличия synchronized). Но как только они пытаются выполнить callAnother()операцию на объекте соседнего потока, они блокируются, что приводит к тупиковой ситуации, потому что блокировки этих объектов уже приняты.

оборота zafar142003
источник
0
CountDownLatch countDownLatch = new CountDownLatch(1);
ExecutorService executorService = ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.execute(() -> {
    Future<?> future = executorService.submit(() -> {
        System.out.println("generated task");
    });
    countDownLatch.countDown();
    try {
        future.get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
         e.printStackTrace();
    }
});


countDownLatch.await();
executorService.shutdown();
gstackoverflow
источник
0

Коварный способ зайти в тупик с помощью всего одного потока - попытаться дважды заблокировать один и тот же (нерекурсивный) мьютекс. Возможно, это не тот простой пример, который вы искали, но, конечно же, я уже сталкивался с такими случаями.

#include <mutex>
#include <iostream>

int main()
{
  std::mutex m;
  m.lock();
  m.lock();
  std::cout << "Expect never to get here because of a deadlock!";
}
rknuus
источник
0

Вот мой подробный пример тупика после того, как я потратил много времени. Надеюсь, это поможет :)

package deadlock;

public class DeadlockApp {

    String s1 = "hello";
    String s2 = "world";

    Thread th1 = new Thread() {
        public void run() {
            System.out.println("Thread th1 has started");
            synchronized (s1) { //A lock is created internally (holds access of s1), lock will be released or unlocked for s1, only when it exits the block Line #23
                System.out.println("Executing first synchronized block of th1!");
                try {
                    Thread.sleep(1000);
                } catch(InterruptedException ex) {
                    System.out.println("Exception is caught in th1");
                }
                System.out.println("Waiting for the lock to be released from parrallel thread th1");
                synchronized (s2) { //As another has runned parallely Line #32, lock has been created for s2
                    System.out.println(s1 + s2);
                }

            }
            System.out.println("Thread th1 has executed");
        }
    };


    Thread th2 = new Thread() {
        public void run() {
            System.out.println("Thread th2 has started");
            synchronized (s2) { //A lock is created internally (holds access of s2), lock will be released or unlocked for s2, only when it exits the block Line #44
                System.out.println("Executing first synchronized block of th2!");
                try {
                    Thread.sleep(1000);
                } catch(InterruptedException ex) {
                    System.out.println("Exception is caught in th2");
                }
                System.out.println("Waiting for the lock to be released from parrallel thread th2");
                synchronized (s1) { //As another has runned parallely Line #11, lock has been created for s1
                    System.out.println(s1 + s2);
                }

            }
            System.out.println("Thread th2 has executed");
        }
    };

    public static void main(String[] args) {
        DeadlockApp deadLock = new DeadlockApp();
        deadLock.th1.start();
        deadLock.th2.start();
        //Line #51 and #52 runs parallely on executing the program, a lock is created inside synchronized method
        //A lock is nothing but, something like a blocker or wall, which holds access of the variable from being used by others.
        //Locked object is accessible, only when it is unlocked (i.e exiting  the synchronized block)
        //Lock cannot be created for primitive types (ex: int, float, double)
        //Dont forget to add thread.sleep(time) because if not added, then object access will not be at same time for both threads to create Deadlock (not actual runtime with lots of threads) 
        //This is a simple program, so we added sleep90 to create Deadlock, it will execute successfully, if it is removed. 
    }

    //Happy coding -- Parthasarathy S
}
Партасарати S
источник