Напишіть програму, яка напевно зайде в глухий кут [закрито]

Нещодавно це запитання я задав в інтерв’ю.

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

Чи можемо ми написати таку програму? Чи можете ви вказати мені на такий приклад програми?

ОНОВЛЕННЯ: Це питання було предметом мого блогу в січні 2013 року . Дякую за чудове запитання!

Як ми можемо написати програму, яка завжди впаде в глухий кут, незалежно від того, як заплановані потоки?

Ось приклад у C #. Зверніть увагу, що програма, здається, не містить блокування та спільних даних. У ньому є лише одна локальна змінна та три твердження, і тим не менш, вона забивається із 100% впевненістю. Було б важко придумати простішу програму, яка б із певністю зайшла у глухий кут.

Вправа для читача №1: поясніть, як це зайшло в глухий кут. (Відповідь - у коментарях.)

Вправа для читача №2: продемонструйте той самий глухий кут у Java. (Відповідь тут: https://stackoverflow.com/a/9286697/88656 )

class MyClass
{
  static MyClass() 
  {
    // Let's run the initialization on another thread!
    var thread = new System.Threading.Thread(Initialize);
    thread.Start();
    thread.Join();
  }

  static void Initialize() 
  { /* TODO: Add initialization code */ }

  static void Main() 
  { }
}

Засувка тут гарантує, що обидва замки тримаються, коли кожна нитка намагається зафіксувати іншу:

import java.util.concurrent.CountDownLatch;

public class Locker extends Thread {

   private final CountDownLatch latch;
   private final Object         obj1;
   private final Object         obj2;

   Locker(Object obj1, Object obj2, CountDownLatch latch) {
      this.obj1 = obj1;
      this.obj2 = obj2;
      this.latch = latch;
   }

   @Override
   public void run() {
      synchronized (obj1) {

         latch.countDown();
         try {
            latch.await();
         } catch (InterruptedException e) {
            throw new RuntimeException();
         }
         synchronized (obj2) {
            System.out.println("Thread finished");
         }
      }

   }

   public static void main(String[] args) {
      final Object obj1 = new Object();
      final Object obj2 = new Object();
      final CountDownLatch latch = new CountDownLatch(2);

      new Locker(obj1, obj2, latch).start();
      new Locker(obj2, obj1, latch).start();

   }

}

Цікаво запустити jconsole, який правильно покаже вам глухий кут на вкладці Threads.

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

Отже, найпростіший спосіб уникнути глухого кута - це надати загальний порядок ресурсам і нав'язати правило, згідно з яким ресурси отримуються лише потоками в порядку . І навпаки, глухий кут можна навмисно створити, запустивши потоки, які отримують ресурси, але не отримують їх по порядку. Наприклад:

Дві нитки, два замки. Перший потік запускає цикл, який намагається отримати замки в певному порядку, другий потік запускає цикл, який намагається отримати замки в протилежному порядку. Кожна нитка звільняє обидва замки після успішного отримання замків.

public class HighlyLikelyDeadlock {
    static class Locker implements Runnable {
        private Object first, second;

        Locker(Object first, Object second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (first) {
                    synchronized (second) {
                        System.out.println(Thread.currentThread().getName());
                    }
                }
            }
        }
    }

    public static void main(final String... args) {
        Object lock1 = new Object(), lock2 = new Object();
        new Thread(new Locker(lock1, lock2), "Thread 1").start();
        new Thread(new Locker(lock2, lock1), "Thread 2").start();
    }
}

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

Однак питання співбесіди часом можуть бути академічними, і це ТА питання має в назві слово "напевно", тож далі йде програма, яка, безумовно, тупикова. Створюються два Lockerоб'єкти, кожен отримує два блокування та CountDownLatchвикористовується для синхронізації між потоками. Кожен Lockerзамикає перший замок, після чого відраховує засувку один раз. Коли обидві нитки отримали замок і відрахували засувку, вони проходять повз заслінку замку і намагаються отримати другий замок, але в кожному випадку інша нитка вже тримає бажаний замок. Ця ситуація призводить до певного глухого кута.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CertainDeadlock {
    static class Locker implements Runnable {
        private CountDownLatch latch;
        private Lock first, second;

        Locker(CountDownLatch latch, Lock first, Lock second) {
            this.latch = latch;
            this.first = first;
            this.second = second;
        }

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            try {
                first.lock();
                latch.countDown();
                System.out.println(threadName + ": locked first lock");
                latch.await();
                System.out.println(threadName + ": attempting to lock second lock");
                second.lock();
                System.out.println(threadName + ": never reached");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(final String... args) {
        CountDownLatch latch = new CountDownLatch(2);
        Lock lock1 = new ReentrantLock(), lock2 = new ReentrantLock();
        new Thread(new Locker(latch, lock1, lock2), "Thread 1").start();
        new Thread(new Locker(latch, lock2, lock1), "Thread 2").start();
    }
}

Ось приклад Java, слідуючи прикладу Еріка Ліпперта:

public class Lock implements Runnable {

    static {
        System.out.println("Getting ready to greet the world");
        try {
            Thread t = new Thread(new Lock());
            t.start();
            t.join();
        } catch (InterruptedException ex) {
            System.out.println("won't see me");
        }
    }

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

    public void run() {           
        Lock lock = new Lock();      
    }

}

Ось приклад із документації:

public class Deadlock {
    static class Friend {
        private final String name;
        public Friend(String name) {
            this.name = name;
        }
        public String getName() {
            return this.name;
        }
        public synchronized void bow(Friend bower) {
            System.out.format("%s: %s"
                + "  has bowed to me!%n", 
                this.name, bower.getName());
            bower.bowBack(this);
        }
        public synchronized void bowBack(Friend bower) {
            System.out.format("%s: %s"
                + " has bowed back to me!%n",
                this.name, bower.getName());
        }
    }

    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new Runnable() {
            public void run() { alphonse.bow(gaston); }
        }).start();
        new Thread(new Runnable() {
            public void run() { gaston.bow(alphonse); }
        }).start();
    }
}

Я переписав Java-версію прикладу тупикової ситуації Юрія Зубарева, опублікований Еріком Ліппертом: https://stackoverflow.com/a/9286697/2098232, щоб більше нагадувати версію C #. Якщо блок ініціалізації Java працює подібно до статичного конструктора C # і спочатку отримує блокування, нам не потрібен інший потік, щоб також викликати метод join, щоб отримати глухий кут, йому потрібно лише викликати якийсь статичний метод із класу Lock, як оригінальний C # приклад. Виниклий тупик, схоже, підтверджує це.

public class Lock {

    static {
        System.out.println("Getting ready to greet the world");
        try {
            Thread t = new Thread(new Runnable(){

                @Override
                public void run() {
                    Lock.initialize();
                }

            });
            t.start();
            t.join();
        } catch (InterruptedException ex) {
            System.out.println("won't see me");
        }
    }

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

    public static void initialize(){
        System.out.println("Initializing");
    }

}

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

Found one Java-level deadlock:
=============================
"Thread-2":
  waiting to lock monitor 7f91c5802b58 (object 7fb291380, a java.lang.String),
  which is held by "Thread-1"
"Thread-1":
  waiting to lock monitor 7f91c6075308 (object 7fb2914a0, a java.lang.String),
  which is held by "Thread-2"

Java stack information for the threads listed above:
===================================================
"Thread-2":
    at uk.ac.ebi.Deadlock.run(Deadlock.java:54)
    - waiting to lock <7fb291380> (a java.lang.String)
    - locked <7fb2914a0> (a java.lang.String)
    - locked <7f32a0760> (a uk.ac.ebi.Deadlock)
    at java.lang.Thread.run(Thread.java:680)
"Thread-1":
    at uk.ac.ebi.Deadlock.run(Deadlock.java:54)
    - waiting to lock <7fb2914a0> (a java.lang.String)
    - locked <7fb291380> (a java.lang.String)
    - locked <7f32a0580> (a uk.ac.ebi.Deadlock)
    at java.lang.Thread.run(Thread.java:680)

Отже, метою було б отримати глухий кут, який JVM вважатиме тупиковим. Очевидно, що рішення не схоже

synchronized (this) {
    wait();
}

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

Зараз sleep()рішення є нормальним, у певному сенсі важко уявити ситуацію, коли це не спрацьовує, але не чесно (ми займаємося чесним видом спорту, чи не так?). Рішення @artbristol (моє те саме, просто різні об'єкти як монітори) є приємним, але довгим і використовує нові примітиви одночасності, щоб привести потоки в потрібний стан, що не так вже й весело:

public class Deadlock implements Runnable {
    private final Object a;
    private final Object b;
    private final static CountDownLatch latch = new CountDownLatch(2);

    public Deadlock(Object a, Object b) {
        this.a = a;
        this.b = b;
    }

    public synchronized static void main(String[] args) throws InterruptedException {
        new Thread(new Deadlock("a", "b")).start();
        new Thread(new Deadlock("b", "a")).start();
    }

    @Override
    public void run() {
        synchronized (a) {
            latch.countDown();
            try {
                latch.await();
            } catch (InterruptedException ignored) {
            }
            synchronized (b) {
            }
        }
    }
}

Я пам’ятаю, що synchronizedрішення -only вміщує 11..13 рядків коду (за винятком коментарів та імпорту), але все ще не пам’ятає фактичного фокусу. Оновить, якщо я це зроблю.

Оновлення: ось негарне рішення щодо synchronized:

public class Deadlock implements Runnable {
    public synchronized static void main(String[] args) throws InterruptedException {
        synchronized ("a") {
            new Thread(new Deadlock()).start();
            "a".wait();
        }
        synchronized ("") {
        }
    }

    @Override
    public void run() {
        synchronized ("") {
            synchronized ("a") {
                "a".notifyAll();
            }
            synchronized (Deadlock.class) {
            }
        }
    }
}

Зверніть увагу, ми замінюємо засувку на монітор об’єкта (використовуємо "a"як об’єкт).

Ця версія C #, я думаю, java повинна бути досить схожою.

static void Main(string[] args)
{
    var mainThread = Thread.CurrentThread;
    mainThread.Join();

    Console.WriteLine("Press Any key");
    Console.ReadKey();
}

import java.util.concurrent.CountDownLatch;

public class SO8880286 {
    public static class BadRunnable implements Runnable {
        private CountDownLatch latch;

        public BadRunnable(CountDownLatch latch) {
            this.latch = latch;
        }

        public void run() {
            System.out.println("Thread " + Thread.currentThread().getId() + " starting");
            synchronized (BadRunnable.class) {
                System.out.println("Thread " + Thread.currentThread().getId() + " acquired the monitor on BadRunnable.class");
                latch.countDown();
                while (true) {
                    try {
                        latch.await();
                    } catch (InterruptedException ex) {
                        continue;
                    }
                    break;
                }
            }
            System.out.println("Thread " + Thread.currentThread().getId() + " released the monitor on BadRunnable.class");
            System.out.println("Thread " + Thread.currentThread().getId() + " ending");
        }
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[2];
        CountDownLatch latch = new CountDownLatch(threads.length);
        for (int i = 0; i < threads.length; ++i) {
            threads[i] = new Thread(new BadRunnable(latch));
            threads[i].start();
        }
    }
}

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

Тут є приклад у Java

http://baddotrobot.com/blog/2009/12/24/deadlock/

Де викрадач потрапляє в глухий кут, коли він відмовляється відмовитись від жертви, поки не отримає готівку, але учасник переговорів відмовляється відмовитись від готівки, поки не отримає жертву.

Простий пошук дав мені такий код:

public class Deadlock {
    static class Friend {
        private final String name;
        public Friend(String name) {
            this.name = name;
        }
        public String getName() {
            return this.name;
        }
        public synchronized void bow(Friend bower) {
            System.out.format("%s: %s"
                + "  has bowed to me!%n", 
                this.name, bower.getName());
            bower.bowBack(this);
        }
        public synchronized void bowBack(Friend bower) {
            System.out.format("%s: %s"
                + " has bowed back to me!%n",
                this.name, bower.getName());
        }
    }

    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new Runnable() {
            public void run() { alphonse.bow(gaston); }
        }).start();
        new Thread(new Runnable() {
            public void run() { gaston.bow(alphonse); }
        }).start();
    }
}

Джерело: Тупик

Ось приклад, коли один потік, що утримує замок, запускає інший потік, який хоче той самий замок, а потім стартер чекає, поки запущений закінчиться ... назавжди:

class OuterTask implements Runnable {
    private final Object lock;

    public OuterTask(Object lock) {
        this.lock = lock;
    }

    public void run() {
        System.out.println("Outer launched");
        System.out.println("Obtaining lock");
        synchronized (lock) {
            Thread inner = new Thread(new InnerTask(lock), "inner");
            inner.start();
            try {
                inner.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class InnerTask implements Runnable {
    private final Object lock;

    public InnerTask(Object lock) {
        this.lock = lock;
    }

    public void run() {
        System.out.println("Inner launched");
        System.out.println("Obtaining lock");
        synchronized (lock) {
            System.out.println("Obtained");
        }
    }
}

class Sample {
    public static void main(String[] args) throws InterruptedException {
        final Object outerLock = new Object();
        OuterTask outerTask = new OuterTask(outerLock);
        Thread outer = new Thread(outerTask, "outer");
        outer.start();
        outer.join();
    }
}

Ось приклад:

два потоки працюють, кожен чекає, поки інший звільнить блокування

публічний клас ThreadClass розширює Thread {

String obj1,obj2;
ThreadClass(String obj1,String obj2){
    this.obj1=obj1;
    this.obj2=obj2;
    start();
}

public void run(){
    synchronized (obj1) {
        System.out.println("lock on "+obj1+" acquired");

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("waiting for "+obj2);
        synchronized (obj2) {
            System.out.println("lock on"+ obj2+" acquired");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }


}

}

Запуск цього призведе до глухого кута:

публічний клас SureDeadlock {

public static void main(String[] args) {
    String obj1= new String("obj1");
    String obj2= new String("obj2");

    new ThreadClass(obj1,obj2);
    new ThreadClass(obj2,obj1);


}

}