Java 线程在同步块(synchronized block)上加锁

Question

我正在学习带锁的同步块(synchronized block)。我想知道这个锁和程序中提供的一些第三方锁之间的区别。

public class NewThread extends Thread {
StringBuffer sb;
NewThread(StringBuffer sb){
    this.sb=sb;
}
public void run(){
    synchronized(this.sb){
        for(int i=0;i<1000;i++){
            System.out.print(sb);
               try{
             Thread.sleep(5*60);
        }
        catch(Exception e){}
        }
       char c = this.sb.charAt(0);
       this.sb.setCharAt(0, ++c);
    }
}
public static void main(String[] args){
    StringBuffer sb=new StringBuffer("A");
    NewThread nt=new NewThread(sb);
    NewThread nt1=new NewThread(sb);
    NewThread nt2=new NewThread(sb);
    nt.start();
    nt1.start();
    nt2.start();
}

}

如果我要放

public void run(){
    synchronized(this){
        for(int i=0;i<1000;i++){
            System.out.print(sb);
               try{
             Thread.sleep(5*60);
        }
        catch(Exception e){}
        }
       char c = this.sb.charAt(0);
       this.sb.setCharAt(0, ++c);
    }
}

在上面的运行方法中，我在同步块(synchronized block)中给出了这个...我想要它们之间的区别

我还有一个问题，如果我们在同步块(synchronized block)中给出一个锁对象，并且我们没有在该 block 内使用该对象，那么与普通 block 相比，我们是否观察到任何特定的事情

Answer 1

如果您有通用操作系统 API 的并发开发经验，例如Linux 中的 pthread 库，您可能知道我们应该使用锁或其他数据结构来同步访问临界区(共享对象可能被修改)的进程/线程。

Java使用锁来实现同步块(synchronized block)。同步块(synchronized block)是一种封装与锁相关的繁琐操作的机制(操作系统中称为监视器)。 java中每个对象都有一个锁。当同步时，共享对象中的锁首先被锁定(也可以说其他进程需要共享对象的锁)。如果某个线程获取锁失败，则说明有其他线程正在持有锁，它必须等待其他线程释放锁，然后重新获取锁，直到它持有锁，然后进入临界区。

第一个代码片段在StringBuffer的实例中使用锁，即sb，每个线程在运行代码之前都会尝试获取sb的锁(调用lock_of_sb.lock()。只有成功获取sb的锁才能最终执行代码。

对于第二段代码，相当于

public synchronized void run(){
  for(int i=0;i<1000;i++){
      System.out.print(sb);
         try{
       Thread.sleep(5*60);
  }
  catch(Exception e){}
  }
  char c = this.sb.charAt(0);
  this.sb.setCharAt(0, ++c);
}

我认为它的行为不符合您的预期。它获取该对象的锁，但是，该对象永远不会被共享。因此，共享 sb 暴露在临界区中，没有任何同步。

该链接将为您提供另一种实现同步的工作方式。 How to synchronize static method in java虽然问题本身是关于静态方法的，但它也适用于实例成员方法。