synchronized 与 object's Monitor

 1 public class SuperClass {
 2 
 3     public synchronized void method0() {
 4     }
 5 
 6     public static synchronized void method1() {}
 7 
 8     Object object = new Object();
 9     public void method3() {
10         synchronized (object) {
11         }
12     }
13 
14     public void method4() {
15         synchronized (this) {
16         }
17     }
18 
19     static Object sObject = new Object();
20     public void method5() {
21         synchronized (sObject) {
22         }
23     }
24 
25     public void method6() {
26         synchronized (SuperClass.class) {
27         }
28     }
29 
30 }

 1 /**
 2      * Causes the current thread to wait until another thread invokes the
 3      * {@link java.lang.Object#notify()} method or the
 4      * {@link java.lang.Object#notifyAll()} method for this object.
 5      * In other words, this method behaves exactly as if it simply
 6      * performs the call {@code wait(0)}.
 7      * <p>
 8      * The current thread must own this object's monitor. The thread
 9      * releases ownership of this monitor and waits until another thread
10      * notifies threads waiting on this object's monitor to wake up
11      * either through a call to the {@code notify} method or the
12      * {@code notifyAll} method. The thread then waits until it can
13      * re-obtain ownership of the monitor and resumes execution.
14      * <p>
15      * As in the one argument version, interrupts and spurious wakeups are
16      * possible, and this method should always be used in a loop:
17      * <pre>
18      *     synchronized (obj) {
19      *         while (&lt;condition does not hold&gt;)
20      *             obj.wait();
21      *         ... // Perform action appropriate to condition
22      *     }
23      * </pre>
24      * This method should only be called by a thread that is the owner
25      * of this object's monitor. See the {@code notify} method for a
26      * description of the ways in which a thread can become the owner of
27      * a monitor.
28      *
29      * @exception  IllegalMonitorStateException  if the current thread is not
30      *               the owner of the object's monitor.
31      * @exception  InterruptedException if any thread interrupted the
32      *             current thread before or while the current thread
33      *             was waiting for a notification.  The <i>interrupted
34      *             status</i> of the current thread is cleared when
35      *             this exception is thrown.
36      * @see        java.lang.Object#notify()
37      * @see        java.lang.Object#notifyAll()
38      */
39     public final void wait() throws InterruptedException {
40         wait(0);
41     }

 1 /**
 2      * Wakes up a single thread that is waiting on this object's
 3      * monitor. If any threads are waiting on this object, one of them
 4      * is chosen to be awakened. The choice is arbitrary and occurs at
 5      * the discretion of the implementation. A thread waits on an object's
 6      * monitor by calling one of the {@code wait} methods.
 7      * <p>
 8      * The awakened thread will not be able to proceed until the current
 9      * thread relinquishes the lock on this object. The awakened thread will
10      * compete in the usual manner with any other threads that might be
11      * actively competing to synchronize on this object; for example, the
12      * awakened thread enjoys no reliable privilege or disadvantage in being
13      * the next thread to lock this object.
14      * <p>
15      * This method should only be called by a thread that is the owner
16      * of this object's monitor. A thread becomes the owner of the
17      * object's monitor in one of three ways:
18      * <ul>
19      * <li>By executing a synchronized instance method of that object.
20      * <li>By executing the body of a {@code synchronized} statement
21      *     that synchronizes on the object.
22      * <li>For objects of type {@code Class,} by executing a
23      *     synchronized static method of that class.
24      * </ul>
25      * <p>
26      * Only one thread at a time can own an object's monitor.
27      *
28      * @exception  IllegalMonitorStateException  if the current thread is not
29      *               the owner of this object's monitor.
30      * @see        java.lang.Object#notifyAll()
31      * @see        java.lang.Object#wait()
32      */
33     public final native void notify();
34 
35 
36 
37 
38 
39     /**
40      * Wakes up all threads that are waiting on this object's monitor. A
41      * thread waits on an object's monitor by calling one of the
42      * {@code wait} methods.
43      * <p>
44      * The awakened threads will not be able to proceed until the current
45      * thread relinquishes the lock on this object. The awakened threads
46      * will compete in the usual manner with any other threads that might
47      * be actively competing to synchronize on this object; for example,
48      * the awakened threads enjoy no reliable privilege or disadvantage in
49      * being the next thread to lock this object.
50      * <p>
51      * This method should only be called by a thread that is the owner
52      * of this object's monitor. See the {@code notify} method for a
53      * description of the ways in which a thread can become the owner of
54      * a monitor.
55      *
56      * @exception  IllegalMonitorStateException  if the current thread is not
57      *               the owner of this object's monitor.
58      * @see        java.lang.Object#notify()
59      * @see        java.lang.Object#wait()
60      */
61     public final native void notifyAll();