Feb

2012

Java Puzzle 2: Dreams – Solution

Time to dream the solution to the dreams puzzle. As a reminder, here’s the challenge:

package sleep;

import dream.Dream;

public class Sleeper {
	private int level;
	
	public synchronized int enter(Dream dream) {
		level++;
		try {
			dream.dream(this);
		} finally {
			level--;
		}
		return level;
	}
}

package sleep;

import dream.Dream;

public class Main {
	public static void main(String[] args) {
		if (new Sleeper().enter(new Dream()) != 0) {
			// The goal is to reach this line
			System.out.println("Am I still dreaming?");
		}
	}
}

Solution

The synchronized on the dream method means that it takes the monitor (lock) of the Sleeper object when we enter it, and it releases it again when we leave it. No other thread can enter the method while the monitor is held.

But here’s the catch: the monitor isn’t necessarily held all the time while the method is running. With Object.wait you can release a monitor in the middle of a synchronized method.

How do we apply that to solve this puzzle? When we enter the outer dream, we use wait to release the monitor. But first we launch a separate thread, that will also enter a dream. Entering that inner dream makes the second thread take the monitor. So in the inner dream, we use wait a second time to release the monitor. That allows the main thread stop waiting, take the monitor back, and leave the outer dream. And there we are: we have woken up from the outer dream, back where we started in main, but the dream within the dream goes on in the second thread.

package dream;

import sleep.Sleeper;

public class Dream {
	private static void doWait(Sleeper s) {
		try {
			s.wait(200);
		} catch (InterruptedException e) {
		}
	}
	
	public void dream(final Sleeper s) {
		new Thread() {
			public void run() {
				s.enter(new Dream() {
					@Override
					public void dream(Sleeper s) {
						doWait(s);
					}
				});
			}
		}.start();
		
		doWait(s);
	}
}

And the winner is…

I got more answers than I expected. The first one came from David Shay. Congrats!

It’s a bit repetitive, but as promised, you can see and compare all dreams as comments below this post.

Conclusion

The moral of the story: synchronized on a method doesn’t mean two different threads can’t be in it at the same time. It only ensures that such threads cannot execute concurrently; at least one of them must be waiting.

You can prevent this kind of abuse and other problems, by using a private object as monitor:

public class Sleeper {
	private final Object lock = new Object();
	
	public int dream(Dream dream) {
		synchronized(lock) {
			...
		}
	}
}

But that still leaves me unsure if I actually woke up this morning.

| 151 Comments, add your own » | Tags: java, puzzle, solution

151 comments to “Java Puzzle 2: Dreams – Solution”

Marcel Hanser says:

February 24, 2012 at 9:08 pm

package dream;

import sleep.Sleeper;

public class Dream {
	private Thread athread;

	public void dream(final Sleeper sleeper) {
		final Dream current = this;
		if (athread == null) {
			System.out.println("Creating new Thread");
			athread = new Thread(new Runnable() {

				@Override
				public void run() {
					sleeper.enter(current);
				}
			});
			athread.start();
			try {

				synchronized (sleeper) {
					System.out.println("set the current on sleep;)");
					sleeper.wait();
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			System.out
					.println("now we added 1 to the level, notify the first and sleep");
			sleeper.notify();
			synchronized (sleeper) {
				try {
					sleeper.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

Markus Keller says:

February 24, 2012 at 9:38 pm

Thanks for these great puzzles!

Here’s a commented solution. As always with concurrency, I find it hard to prove whether the solution is safe, but I think it is. I’m not sure though, whether “volatile” is necessary.

package dream;

import sleep.Sleeper;

public class Dream {

    private volatile boolean flag;

    public void dream(final Sleeper s) {
        if (!flag) {
            // In first dream, start a thread that will enter a second dream:
            flag= true;
            new Thread() {
                @Override
                public void run() {
                    s.enter(Dream.this);
                }
            }.start();

            // Wait until second dream has started:
            do {
                try {
                    // Release monitor, so that the second dream can start:
                    s.wait(10);
                } catch (InterruptedException e) {
                }
            } while (flag); // Repeat until second dream really started.
            
            // Now, the first dream can end while the second is still ongoing.
            
            // Notify the second dream that it can end. This is safe since
            // the first dream still holds the sleeper's monitor.
            s.notify();

        } else {
            // In 2nd dream, set flag to false and then wait for termination:
            flag= false;
            try {
                s.wait();
            } catch (InterruptedException e) {
            }
        }
    }
}

Paul Martin says:

February 24, 2012 at 9:54 pm

That was fun – hadn’t really thought of the relationship between synchronized methods and wait and notify before!

// this is the only file you're allowed to edit
package dream;
 
import sleep.Sleeper;
 
public class Dream {
    public void dream(final Sleeper s) {
    	new Thread(new Runnable() {
			@Override
			public void run() {
				s.enter(new DreamForever());
			}
		}).start();	// Start a new inner dream, will be blocked on Sleeper
    	try {
			s.wait();	// Relinquish control of Sleeper to inner dream, and wait to be notified once inner has started
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
    }
}

class DreamForever extends Dream {
	
	@Override
	public void dream(Sleeper s) {
		s.notifyAll();		// Notify (the parent dream)
		try {
			s.wait(5000L);	// And then relinquish control and wait for a notification (that will never come).
							// 5 seconds should be enough time for the parent thread to finish (could wait forever though)
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
}

Daniel Simoes says:

February 24, 2012 at 10:00 pm

My version.

http://pastebin.com/7E5Prbgd

Great puzzle!! Thanks.

Reply

Paul Martin says:

February 24, 2012 at 10:12 pm

Oh, I guess that you don’t really need separate Dream classes (especially if you don’t mind infinite loops & threads, though you could implement a static counter to limit them)

// this is the only file you're allowed to edit
package dream;
 
import sleep.Sleeper;
 
public class Dream {
    public void dream(final Sleeper s) {
    	new Thread(new Runnable() {
			@Override
			public void run() {
				s.enter(new Dream());
			}
		}).start();
    	s.notifyAll();
    	try {
			s.wait();
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
    }
}

Tomasz Biedka says:

February 24, 2012 at 10:13 pm

package dream;

import sleep.Sleeper;

public class Dream {

    private static Sleeper sleeper;

    public void dream(final Sleeper s) {
        try {
            dreamInternal(s);
        } catch (InterruptedException ignore) {
        }
    }

    private void dreamInternal(Sleeper s) throws InterruptedException {
        if (sleeper == null) {
            sleeper = s;
            mainThreadDream(s);
        } else {
            additionalThreadDream(s);
        }
    }

    private void mainThreadDream(Sleeper s) throws InterruptedException {
        Thread additionalThread = createAdditionalThread(s);
        additionalThread.start();
        s.wait(); // wait for notify() from additionalThread
        additionalThread.interrupt();
    }

    private Thread createAdditionalThread(Sleeper s) {
        final Dream dream = this;
        return new Thread(new Runnable() {
            public void run() {
                sleeper.enter(dream);
            }
        });
    }

    private void additionalThreadDream(Sleeper s) throws InterruptedException {
        s.notify();
        s.wait();  // wait for interrupt() from mainThread
    }
}

sico says:

February 24, 2012 at 10:21 pm

// this is the only file you're allowed to edit
package dream;

import sleep.Sleeper;

public class Dream {
	public void dream(final Sleeper s) {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				s.enter(new NeverEndingDream());
			}
		};
		new Thread(r).start();

		try {
			s.wait();
		} catch (Exception e1) {
			e1.printStackTrace();
		}
	}
}

class NeverEndingDream extends Dream {
	public void dream(Sleeper s) {
		try {
			s.notifyAll();
			s.wait();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Thomas says:

February 24, 2012 at 10:38 pm

Hi,

I’m a bit late with my entry but here it comes: it’s a dream that spawns another dream and waits for the second dream to start which will then cause the first dream to finish and then the night is over before the second dream came to its end. Don’t we all know this strange feeling when waking up and having some unfinished matters still on our minds?

Actually I found this puzzle a lot easier than the one with the clowns. Maybe because it is closer to what I have to deal with (i.e. debug) during my daily work.

BTW, I love this kind of puzzles, thank you!

Kind regards,
Thomas
```
 
package dream;

import java.util.*;
import sleep.Sleeper;

public class Dream extends TimerTask {
  
  Sleeper sleeper;
  
  public void run() {
    sleeper.enter(this);
  }

  public void dream(final Sleeper s) {
    if (sleeper == null) {
      sleeper = s;
      new Timer(true).schedule(this, 100);
    } else {
      s.notify();
    }
    try {
      s.wait();
    } catch (InterruptedException ex) {}
  }
}
```
Reply

eyrieowl says:

February 24, 2012 at 10:59 pm

public class Dream {
   public void dream(final Sleeper s) {
      Thread t = new Thread() {
            @Override
            public void run() {
               s.enter(new Dream() {
                     @Override
                     public void dream(Sleeper s) {
                        try {
                           synchronized (s) {
                              s.notify();
                              s.wait();
                           }
                        }
                        catch (InterruptedException e) {
                           throw new RuntimeException(e);
                        }
                     }
                  });
            }
         };
      t.start();

      try {
         synchronized (s) {
            s.wait();
         }
      }
      catch (InterruptedException e) {
         throw new RuntimeException(e);
      }
   }
}

catac says:

February 24, 2012 at 11:20 pm

You can fool the Sleeper by doing a ping-pong with another thread, stealing Sleeper’s lock to insert an extra dream:

package sleep;

import java.util.concurrent.atomic.AtomicBoolean;

public class Dream {
    private AtomicBoolean firstTime = new AtomicBoolean(true);

    public void dream(final Sleeper s) {
        try {
            if (firstTime.getAndSet(false)) {
                new Thread() {
                    @Override
                    public void run() {
                        s.enter(Dream.this);
                    }
                }.start();
                synchronized (s) {
                    s.wait();
                    s.notify();
                }
            } else {
                synchronized (s) {
                    s.notify();
                    s.wait();
                }
            }
        } catch (InterruptedException e) {
            // don't care
        }
    }
}

finnw says:

February 24, 2012 at 11:23 pm

package dream;

import sleep.Sleeper;

public class Dream {

    private static class StrangeDream extends Dream implements Runnable {
        public void dream(Sleeper s) {
            s.notify();
            try {
                s.wait();
            } catch (InterruptedException ex) {
            }
        }
        public void run() {
            s.enter(this);
        }
        StrangeDream(Sleeper s) {
            this.s = s;
        }
        private Sleeper s;
    }

    public void dream(Sleeper s) {
        new Thread(new StrangeDream(s)).start();
        try {
            s.wait();
        } catch (InterruptedException ex) {
        }
        s.notify();
    }

}

finnw says:

February 25, 2012 at 12:00 am

I should probably add a Thread.sleep() after the wait in StrangeDream.dream(Sleeper) – I think there’s a race as it stands.

Reply

slavarosin says:

February 24, 2012 at 11:49 pm

// this is the only file you're allowed to edit
package sleep;

public class Dream {
	public void dream(final Sleeper s) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				s.enter(new Dream() {
					@Override
					public void dream(final Sleeper s) {
						try {
							s.wait(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				});
			}
		}).start();

		try {
			s.wait(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

mentallurg says:

February 25, 2012 at 1:02 am

Dream of unlimited depth can be created. The limit depends on your resources only, i.e. on how many threads can your JVM create under you OS with its default RAM. In this example it is set to 100. You can see the level, if you add one logging line to the Main class.

package dream;

import sleep.Sleeper;

public class Dream {

    private int count = 0;

    private static final int DREAM_DEPTH = 100;

    public void dream(final Sleeper s) {
        if (count++ <= DREAM_DEPTH) {
            new Thread() {
                public void run() {
                    s.enter(Dream.this);
                };
            }.start();
        } else {
            s.notify();
            return;
        }

        try {
            s.wait();
        } catch (InterruptedException e) {
            return;
        }

        s.enter(this);
        s.notify();
    }
}

mentallurg says:

February 25, 2012 at 1:07 am

If smb wants to check the real level, logging can be added as follows:

package sleep;

import dream.Dream;

public class Main {
    public static void main(String[] args) {
        int level = new Sleeper().enter(new Dream());
        System.out.println("level=" + level);
        if (level != 0) {
            // The goal is to reach this line
            System.out.println("Am I still dreaming?");
        }
    }
}

mentallurg says:

February 25, 2012 at 1:09 am

… and to get the better feeling about what is going on, a single logging line can be added to the Sleeper:

package sleep;

import dream.Dream;

public class Sleeper {
    private int level;

    public synchronized int enter(Dream dream) {
        level++;
        try {
            dream.dream(this);
        } finally {
            level--;
        }
        System.out.println("level=" + level);
        return level;
    }
}

Paul Michael Bauer says:

February 25, 2012 at 4:15 am

package dream;
import sleep.Sleeper;

public class Dream {
    public void dream(final Sleeper s) {
        Thread t = new Thread(new Runnable() {
            public void run() {
                s.enter(new Dream() {
                    public void dream(Sleeper s) {
                        s.notify();
                        wait(s);
                    }
                });
            }
        });
        t.setDaemon(true);
        t.start();
        wait(s);
    }

    protected static void wait(Sleeper s) {
        try {
            s.wait();
        } catch (InterruptedException ignored) {
        }
    }
}

Erik Kuefler says:

February 25, 2012 at 4:23 am

synchronized does indeed keep multiple threads from running at once inside a given method – but it doesn’t stop one thread from running while others are waiting. This code works on my machine:

public class Dream {
  public void dream(final Sleeper s) {
    new Thread() {
      public void run() {
        s.enter(new Dream() {
          public void dream(Sleeper s) {
            try {
              s.wait(1000);
            } catch (InterruptedException e) {}
          }
        });
      }
    }.start();
    try {
      s.wait(500);
    } catch (InterruptedException e) {}
  }
}

Dmitriy Likhten says:

February 25, 2012 at 5:29 am

https://github.com/dlikhten/dreams

That contains the solution. You can’t use the security manager via intellij (it’s all set to go) but you can see that it is unnecessary as I don’t need the features of setAccessible. And it runs from command line Pretty simple actually, especially when you use drugs when you go sleep.

Reply

lexa says:

February 25, 2012 at 7:59 am

package dream;
 
import sleep.Sleeper;
 
public class Dream {
    
    boolean firstEnter = true;
    
    public void dream(Sleeper s) {
       if (firstEnter) {
            System.out.println("first dream ...");
            firstEnter = false;
            // create one more thread with recursion call
            final Sleeper sleeper = s;
            final Dream dream = this;
            new Thread(
                new Runnable() {
                    public void run() {
                        System.out.println("start another sleeper dream ...");
                        sleeper.enter(dream);
                    }
                }
            ).start();
            
            // another critical section by sleeper    
            // even though we are inside
            synchronized (s) {
                try {
                    System.out.println("first dream is put on wait ...");
                    // pause execution and release monitor
                    s.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // we get out of waiting 
            System.out.println("first dream goes further ...");
            // wake other dreams
            s.notifyAll();
        } else {
            System.out.println("another dream ...");
            System.out.println("wake first one ...");
            // wake other dreams
            s.notifyAll();
            // another critical section by sleeper    
            // even though we are inside
            synchronized (s) {
                try {
                    System.out.println("another dream is put on wait ...");
                    // pause execution and release monitor
                    s.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //some pause, just for proper order of outs
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // we get out of waiting 
            System.out.println("another dream goes further ...");        
        }
        
    }
}

Chris says:

February 25, 2012 at 9:32 am

This seems to work.

    public void dream(final Sleeper s) {
    	
        synchronized (s) {
			new Thread() {
				public void run() {
					s.enter(new Dream());
				}
			}.start();
        	try {
        		s.notify();
        		s.wait();
        	} catch (Exception e) {
        		
        	}
        	
		}
    }

Martin Hilton says:

February 25, 2012 at 4:10 pm

// this is the only file you're allowed to edit
package dream;
 
import sleep.Sleeper;
 
public class Dream {
    public void dream(Sleeper s) {
		Thread t = new Thread(new Runner(s));
		t.setDaemon(true);
		t.start();
			
		wait(s);
    }

	protected void wait(Sleeper s) {
		synchronized (s) {
			try {
				s.wait();
			} catch (InterruptedException e) { }
		}
	}

	private static class Runner implements Runnable {
		private Sleeper s;
		
		public Runner(Sleeper s) {
			this.s = s;
		}
		
		public void run() {
			s.enter(new Dream2());
		}
	}

	private static class Dream2 extends Dream {
		public void dream(Sleeper s) {
			synchronized (s) {
				s.notify();
			}
			
			wait(s);
		}
	}
}

Algirdas says:

February 25, 2012 at 6:20 pm

package dream;

import sleep.Sleeper;

/**
 * Endlessly parallel dream.
 */
public class Dream {
  
  public void dream(Sleeper sleeper) {
    fallAsleepInParallelUniverse(sleeper);
    wakeUpInParallelUniverse(sleeper);
    sleepTillWakenUp(sleeper);
  }

  private void fallAsleepInParallelUniverse(final Sleeper sleeper) {
    new Thread() {
      public void run() {
        sleeper.enter(Dream.this);
      }
    }.start();    
  }

  private void wakeUpInParallelUniverse(Sleeper sleeper) {
    sleeper.notify();
  }

  private void sleepTillWakenUp(Sleeper sleeper) {
    try {
      sleeper.wait();
    } catch (InterruptedException e) {
    }
  }

}

Filip says:

February 25, 2012 at 7:35 pm

// this is the only file you're allowed to edit
package dream;
 
import sleep.Sleeper;
 
public class Dream {
    public void dream(final Sleeper s1) {
    	new Thread() {
    		public void run() {
    			synchronized (s1) {
					s1.enter(new Dream(){
						@Override
						public void dream(Sleeper s1) {
							s1.notify();
							try {
								s1.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					});
				}
    		}
    	}.start();
    	
    	try {
			s1.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
    }
 
}

Jan Schäfer says:

February 25, 2012 at 7:51 pm

package dream;

import sleep.Sleeper;

public class Dream {
    public void dream (final Sleeper s) {
        // call enter in a different thread
        new Thread() {
            @Override
            public void run () {
                s.enter(new SpecialDream());
            };
        }.start();

        try {
            // give SpecialDream possibility to enter monitor
            s.wait();
            // terminate SpecialDream
            s.notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class SpecialDream extends Dream {

        @Override
        public void dream (Sleeper s) {
            try {
                // in monitor now, wake up Dream
                s.notifyAll();
                // give Dream possibility to enter monitor
                s.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Alessandro Abbruzzetti says:

February 25, 2012 at 11:16 pm

Hi,
I used a supplementary thread in order to increment the level counter and wait 2 seconds meanwhile the primary calling thread is waiting only 1 second. In this way the check on the level variable will be done while the supplementary thread is still waiting on a wait condition: A a result we will have the level counter with a value of 2.
```
public class Dream {
int state = 0;
public void dream(Sleeper s) {
if (state == 1) synchronized (s) {
try { s.wait(2000); } catch (Exception e) {}
return;
}
final Sleeper s1 = s;
new Thread() {
public void run() { state =1; s1.enter(Dream.this);}
}.start();
try { synchronized { s.wait(1000); } } catch (Exception e) {}
}
}
```
Reply

Yann Massard says:

February 25, 2012 at 11:37 pm

package dream;

import sleep.Sleeper;

public class Dream {

    public void dream(final Sleeper s) {
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {}
                s.enter(new Dream() {
                    @Override
                    public void dream(Sleeper s)  {
                        synchronized(s) {
                            s.notifyAll();
                            try {
                                s.wait(100);
                            } catch (InterruptedException e) {}
                        }
                    }
                });
            }
        }.start();
        synchronized (s) {
            try {
                s.wait();
            } catch (InterruptedException e) {}
        }
    }
}

Yann Massard says:

February 25, 2012 at 11:39 pm

actually lower synchronized block is not needed…

Reply

Ludovic Claude says:

February 26, 2012 at 12:15 am

Sleeping other this problem was a good idea. I found a solution:

package dream;

import sleep.Sleeper;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class Dream {

    private static Executor executor = Executors.newFixedThreadPool(128);
    private static CountDownLatch dreamsLatch = new CountDownLatch(128);
    private static AtomicInteger wakingUp = new AtomicInteger(128);

    public void dream(Sleeper s) {

        for (int i = 0; i < 128; i++) {
            executor.execute(new WaitingDream(s));
        }
        try {
            synchronized(s) {
                System.out.println("Gathering sheeps...");
                dreamsLatch.await();
                System.out.println("Counting sheeps...");
                s.wait(10000);
                System.out.println("Wake up!");
                s.notifyAll();
                System.out.println("Grumble grumble...");
                while (wakingUp.get() > 10) {
                    s.notifyAll();
                }
                System.out.println("I'm awake");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class SimpleDream extends Dream {
        public void dream(Sleeper s) {
            try {
                s.notifyAll();
                s.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static Dream inner = new SimpleDream();

    static class WaitingDream extends Dream implements Runnable {
        private final Sleeper sleeper;

        public WaitingDream(Sleeper s) {
            sleeper = s;
        }

        public void dream(Sleeper s) {
            s.enter(inner);
        }

        public void run() {
            try {
                dreamsLatch.countDown();
                sleeper.enter(this);
            } catch (Exception e) {
                e.printStackTrace();
            }
            wakingUp.decrementAndGet();
            System.out.print(".");
        }
    }
}

Nicolas Pirard says:

February 26, 2012 at 10:21 pm

@Ludo : t’es un grand malade!

@Wouter : thank you for sharing thoses puzzles! Had a nice time burning some neurons on them, will have another nice time bashing some colleagues and friends tomorrow

Reply

Alex Dvinsky says:

February 26, 2012 at 10:27 am

public void dream(final Sleeper s)
{
    Thread t = new Thread()
    {
        public void run()
        {
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
            s.enter(new LongDream());
            synchronized (s) { Dream.this.notifyAll(); }
    };

    t.setDaemon(true);
    t.start();
    try { s.wait(); } catch (InterruptedException e) {}
}

private static class LongDream extends Dream
{
    public void dream(Sleeper s)
    {
        s.notifyAll();
        try { s.wait(); } catch (InterruptedException e) {}
    }
}

Wouter says:

February 26, 2012 at 5:11 pm

=======================================================
Any comments above these line were made before the solution came out. Anything below comes after.
If there is anything between the lines, clean your monitor.

Reply
finnw says:

February 26, 2012 at 5:43 pm

If you make this change to the Sleeper class, none of the posted solutions will work anymore…
```
package sleep;
 
import dream.Dream;
 
public class Sleeper {
    private int level;
    private Object lock = new Object();
 
    public int enter(Dream dream) {
        synchronized (lock) {
            level++;
            try {
                dream.dream(this);
            } finally {
                level--;
            }
            return level;
        }
    }
}
```
I wonder if it is still possible to break it like this?

Reply
- Wouter says:
  
  February 26, 2012 at 5:57 pm
  
  I don’t expect it’s possible to break that. But I’d love to be surprised.
  
  Reply
- Roel Spilker says:
  
  February 27, 2012 at 9:55 am
  
  If you use Project Lombok, you can write:
```
@Synchronized public int enter(Dream dream) {
    // original implementation
}
```
  The @Synchronized will create the lock field for you and wraps the entire method content in a synchronized block.
  
  See http://projectlombok.org/features/Synchronized.html for more information.
  
  Disclaimer, I’m one of the Project Lombok developers.
  
  Reply
Jonathan Fisher says:

February 26, 2012 at 8:11 pm

Simply awesome! I wish we could do this daily not weekly!!!

Reply
Markus Keller says:

February 26, 2012 at 10:18 pm

Concurrency devils are disturbing your dreams

The “official” solution is not guaranteed to reach the goal line. Just set a breakpoint on line 16 at
s.enter(new Dream() {
and debug.

You’ll always wake up in the cold reality.

If you remove the timeout from s.wait(200); and insert
s.notify();
before doWait(s); in the inner dream and after doWait(s); in Dream#dream(..), then you get the sweet dream in many more cases.

But to be completely safe, every invocation of wait(..) needs to be performed inside a loop (see the Javadoc).

Reply
- Wouter says:
  
  February 26, 2012 at 10:25 pm
  
  You’re right.
  
  I was being lazy, and something that works 99.99% of the time unless you intentionally make it not work (by setting a breakpoint) seems good enough for this puzzle. I also didn’t want to make the sequence diagram any more complicated than it already is.
  
  It needs an extra “Kids, don’t write code like this for real” disclaimer.
  
  Reply
- Tim Lammens says:
  
  February 27, 2012 at 12:26 am
  
  I can only agree with this comment ;P
  
  Reply
Yakov says:

February 27, 2012 at 8:15 pm

Guys,

It seems that almost all of you forget to wrap wait calls in a cycle. It seems to be wrong.

Reply
- Wouter says:
  
  February 27, 2012 at 9:30 pm
  
  It has many more things wrong with it.
  It relies on an implementation detail of the locking of the Sleeper; it does a frick’n .wait() on someone else’s lock. It also does complicated things without commenting why, it’s lacking javadoc and unit tests.
  Solutions to previous and next puzzles have done and will do things that make my wrongness-meter go much more into the red then any of that.
  
  The whole point of these puzzles is to break the conventional rules. The usual wrong or correct don’t apply here. All that matters is that it’s fun, it seems to work when you run it, and that others can understand why it works.
  And in my opinion, it also leads to a whole different kind of code beauty.
  
  Reply
nothize says:

February 29, 2012 at 12:39 pm

Thanks for the exercise for concurrency programming in Java.

Reply

Hanson Char says:

March 1, 2012 at 5:55 am

package dream;

import sleep.Sleeper;

public class Dream {
  public void dream(final Sleeper s) {
      new Thread() {
          @Override public void run() {
              s.enter(new Dream() {
                  @Override public void dream(Sleeper s) {
                      synchronized(s) {
                          try {
                            s.notify();
                            s.wait();
                        } catch (InterruptedException e) {}
                      }
                  }
              });
          }
      }.start();
      
      synchronized(s) {
          try { s.wait(); } catch (InterruptedException e) { }
      }
  }
}

Christoph says:

March 7, 2012 at 5:12 pm

I think the original task is a bit confusing because of the “// TODO implement me” in the dream method. I thought this is the only location you may modify but in your solution you added a method to the class.

Reply
- Wouter says:
  
  March 7, 2012 at 7:48 pm
  
  It doesn’t really change anything to the puzzle; you can just as easily do it without that extra method.
  
  Reply
drieu says:

September 5, 2012 at 4:23 pm

I’m happy ! I found the solution !
Not easy but It was interesting.
Thanks.

Reply

Java Puzzle 2: Dreams – Solution

Solution

And the winner is…

Conclusion

151 comments to “Java Puzzle 2: Dreams – Solution”

Leave a comment to nothize

Menu

Recent Posts

Archives

Search