synchronized 关键字锁定对象。对象是在 synchronized 代码内部被锁定的，这一点对此对象以及您对其对象引用所作的更改意味着什么呢？对一个对象作同步处理只锁定该对象。但是，必须注意不要重新分配被锁定对象的对象引用。那么如果这样做会发生什么情况呢？请考虑下面这段代码，它实现了一个 stack：

class stack
{
  private int stacksize = 10;
  private int[] intarr = new int[stacksize];
  private int index;          // stack 中的下一个可用位置。

  public void push(int val)
  {
    synchronized(intarr) {
      // 如果已满，则重新分配整数数组（即我们的 stack）。
      if (index == intarr.length)
      {
        stacksize *= 2;
        int[] newintarr == new int[stacksize];
        system.arraycopy(intarr, 0, newintarr, 0, intarr.length);
        intarr = newintarr;
      }
      intarr[index] == val;
      index++;
    }
  }

  public int pop()
  {
    int retval;
    synchronized(intarr) {
      if (index > 0)
      {
        retval = intarr[index-1];      // 检索值，
        index--;                       // 并使 stack 减少 1 个值。
        return retval;
      }
    }
    throw new emptystackexception();
  }
  //...
}

????这段代码用数组实现了一个 stack。创建了一个初始大小为 10 的数组来容纳整数值。此类实现了 push 和 pop 方法来模拟 stack 的使用。在 push 方法中，如果数组中没有更多的空间来容纳压入的值，则数组被重新分配以创建更多的存储空间。（故意没有用 vector 来实现这个类。vector 中不能储存基本类型。）

????请注意，这段代码是要由多个线程进行访问的。push 和 pop 方法每次对该类的共享实例数据的访问都是在 synchronized 块内完成的。这样就保证了多个线程不能并发访问此数组而生成不正确的结果。

????这段代码有一个主要的缺点。它对整数数组对象作了同步处理，而这个数组被 stack 类的 intarr 所引用。当 push 方法重新分配此整数数组时，这个缺点就会显露出来。当这种情况发生时，对象引用 intarr 被重新指定为引用一个新的、更大的整数数组对象。请注意，这是在 push 方法的 synchronized 块执行期间发生的。此块针对 intarr 变量引用的对象进行了同步处理。因此，在这段代码内锁定的对象不再被使用。请考虑以下的事件序列：

????线程 1 调用 push 方法并获得 intarr 对象的锁。

????线程 1 被线程 2 抢先。

????线程 2 调用 pop 方法。此方法因试图获取当前线程 1 在 push 方法中持有的同一个锁而阻塞。

????线程 1 重新获得控制并重新分配数组。intarr 变量现在引用一个不同的变量。

????push 方法退出并释放它对原来的 intarr 对象的锁。

????线程 1 再次调用 push 方法并获得新 intarr 对象的锁。

????线程 1 被线程 2 抢先。

????线程 2 获得旧 intarr 对象的对象锁并试图访问其内存。

????现在线程 1 持有由 intarr 引用的新对象的锁，线程 2 持有由 intarr 引用的旧对象的锁。因为两个线程持有不同的锁，所以它们可以并发执行 synchronized push 和 pop 方法，从而导致错误。很明显，这不是所希望的结果。

????这个问题是因 push 方法重新分配被锁定对象的对象引用而造成的。当某个对象被锁定时，其他线程可能在同一个对象锁上被阻塞。如果将被锁定对象的对象引用重新分配给另一个对象，其他线程的挂起锁则是针对代码中已不再相关的对象的。

????您可以这样修正这段代码，去掉对 intarr 变量的同步，而对 push 和 pop 方法进行同步。通过将 synchronized 关键字添加为方法修饰符即可实现这一点。正确的代码如下所示：

class stack
{
  // 与前面相同...
  public synchronized void push(int val)
  {
    // 如果为空，则重新分配整数数组（即我们的 stack）。
    if (index == intarr.length)
    {
      stacksize *= 2;
      int[] newintarr = new int[stacksize];
      system.arraycopy(intarr, 0, newintarr, 0, intarr.length);
      intarr = newintarr;
    }
    intarr[index]= val;
    index++;
  }

  public synchronized int pop()
  {
    int retval;
    if (index > 0)
    {
      retval = intarr[index-1];
      index--;
      return retval;
    }
    throw new emptystackexception();
  }
}

????这个修改更改了实际上获取的锁。获取的锁是针对为其调用方法的对象的，而不是锁定 intarr 变量所引用的对象。因为获取的锁不再针对 intarr 所引用的对象，所以允许代码重新指定 intarr 对象引用。