高手们能讲讲synchronized (）｛｝的具体用法吗？？

Question

synchronized(对象锁) {
    //被同步的代码块
}

Answer 1

A synchronized statement acquires a mutual-exclusion lock (§17.13) on behalf of the executing thread, executes a block, then releases the lock. While the executing thread owns the lock, no other thread may acquire the lock. SynchronizedStatement:  synchronized ( Expression ) Block The type of Expression must be a reference type, or a compile-time error occurs. A synchronized statement is executed by first evaluating the Expression. If evaluation of the Expression completes abruptly for some reason, then the synchronized statement completes abruptly for the same reason. Otherwise, if the value of the Expression is null, a NullPointerException is thrown. Otherwise, let the non-null value of the Expression be V. The executing thread locks the lock associated with V. Then the Block is executed. If execution of the Block completes normally, then the lock is unlocked and the synchronized statement completes normally. If execution of the Block completes abruptly for any reason, then the lock is unlocked and the synchronized statement then completes abruptly for the same reason. Acquiring the lock associated with an object does not of itself prevent other threads from accessing fields of the object or invoking unsynchronized methods on the object. Other threads can also use synchronized methods or the synchronized statement in a conventional manner to achieve mutual exclusion. The locks acquired by synchronized statements are the same as the locks that are acquired implicitly by synchronized methods; see §8.4.3.5. A single thread may hold a lock more than once. The example: 
class Test {
 public static void main(String[] args) {
   Test t = new Test();
    synchronized(t) {
      synchronized(t) {
        System.out.println("made it!");
      }
    }
  }
}
 prints: made it!
 This example would deadlock if a single thread were not permitted to lock a lock more than once.

Answer 2

A synchronized method acquires a lock before it executes. For a class (static) method, the lock associated with the Class object for the method's class is used. For an instance method, the lock associated with this (the object for which the method was invoked) is used. These are the same locks that can be used by the synchronized statement; thus, the code: 
class Test {
  int count;
  synchronized void bump() { count++; }
  static int classCount;
  static synchronized void classBump() {
    classCount++;
  }
}
 has exactly the same effect as: 
class BumpTest {
  int count;
  void bump() {
   synchronized (this) {
     count++;
   }
 }
  static int classCount;
  static void classBump() {
   try {
      synchronized (Class.forName("BumpTest")) {
        classCount++;
     }
   } catch (ClassNotFoundException e) {
       ...
   }
  }
}
 The more elaborate example: 
public class Box {
  private Object boxContents;  public synchronized Object get() {
    Object contents = boxContents;
    boxContents = null;
    return contents;
  }  public synchronized boolean put(Object contents) {
    if (boxContents != null)
      return false;
    boxContents = contents;
    return true;
  }
}
 defines a class which is designed for concurrent use. Each instance of the class Box has an instance variable contents that can hold a reference to any object. You can put an object in a Box by invoking put, which returns false if the box is already full. You can get something out of a Box by invoking get, which returns a null reference if the box is empty. If put and get were not synchronized, and two threads were executing methods for the same instance of Box at the same time, then the code could misbehave. It might, for example, lose track of an object because two invocations to put occurred at the same time.

Answer 3

only allow one thread use it at one time since it has been used.