What should we do to overcome livelock? (in general and specific to the code example provided below)

Question

I'm new to Java and is trying to learn the concept of livelock.

I found a great example of livelock online, where a husband and wife are trying to eat soup, but only have one spoon between them. Each spouse is too polite, and will pass the spoon if the other has not yet eaten.

My question is, what should we do to overcome the problem of livelock in general, and in this particular example? I am looking to modify my code to demonstrate the solution to the problem.

public class Livelock {
    static class Spoon {
        private Diner owner;
        public Spoon(Diner d) { owner = d; }
        public Diner getOwner() { return owner; }
        public synchronized void setOwner(Diner d) { owner = d; }
        public synchronized void use() { 
            System.out.printf("%s has eaten!", owner.name); 
        }
    }

    static class Diner {
        private String name;
        private boolean isHungry;

        public Diner(String n) { name = n; isHungry = true; }       
        public String getName() { return name; }
        public boolean isHungry() { return isHungry; }

        public void eatWith(Spoon spoon, Diner spouse) {
            while (isHungry) {
                // Don't have the spoon, so wait patiently for spouse.
                if (spoon.owner != this) {
                    try { Thread.sleep(1); } 
                    catch(InterruptedException e) { continue; }
                    continue;
                }                       

                // If spouse is hungry, insist upon passing the spoon.
                if (spouse.isHungry()) {                    
                    System.out.printf(
                        "%s: You eat first my darling %s!%n", 
                        name, spouse.getName());
                    spoon.setOwner(spouse);
                    continue;
                }

                // Spouse wasn't hungry, so finally eat
                spoon.use();
                isHungry = false;               
                System.out.printf(
                    "%s: I am stuffed, my darling %s!%n", 
                    name, spouse.getName());                
                spoon.setOwner(spouse);
            }
        }
    }

    public static void main(String[] args) {
        final Diner husband = new Diner("Bob");
        final Diner wife = new Diner("Alice");

        final Spoon s = new Spoon(husband);

        new Thread(new Runnable() { 
            public void run() { husband.eatWith(s, wife); }   
        }).start();

        new Thread(new Runnable() { 
            public void run() { wife.eatWith(s, husband); } 
        }).start();
    }
}

I would perform atomically the action which is causing the livelock. In this case, I would use `synchronized(spoon)` on each loop iteration. — Nadir, Feb 18 '16 at 12:54

score 1 · Accepted Answer · answered Feb 18 '16 at 13:07

In general there isn't a universal solution to livelock.

A thread has to stop repeating the same actions if no progress has been detected.

In your example allowing spouse to eat more than once (thereby detecting that the loved one has not eaten and no progress has been made, since eating takes just 1 step) should force the owner of the spoon to just eat.

Obviously real life scenarios will be more elaborate, but detecting zero progress and acting differently than normally is crucial.

What should we do to overcome livelock? (in general and specific to the code example provided below)

1 Answers1