您应该同步 run 方法吗？为什么或为什么不呢？

Question

我一直认为在实现Runnable的java类中同步run方法是多余的。 我试图弄清楚人们为什么这样做：

public class ThreadedClass implements Runnable{
    //other stuff
    public synchronized void run(){
        while(true)
             //do some stuff in a thread
        }
    }
}

这似乎是多余和不必要的，因为他们正在为另一个线程获取对象的锁。或者更确切地说，他们明确表示只有一个线程可以访问 run() 方法。但既然是run方法，那它本身不就是自己的线程吗？因此，只有它自己可以访问它不需要单独的锁定机制？

我在网上发现了一个建议，通过同步 run 方法，您可以通过这样做创建一个事实上的线程队列：

 public void createThreadQueue(){
    ThreadedClass a = new ThreadedClass();
    new Thread(a, "First one").start();
    new Thread(a, "Second one, waiting on the first one").start();
    new Thread(a, "Third one, waiting on the other two...").start();
 }

我个人永远不会这样做，但这引出了一个问题：为什么有人会同步 run 方法。 有什么想法为什么或为什么不应该同步 run 方法吗？

Answer 1

同步 Runnable 的 run() 方法是完全没有意义的，除非您想在多个线程之间共享 Runnable 并且您希望按顺序执行这些线程。这基本上是一个矛盾。

理论上还有另一种更复杂的场景，您可能希望同步 run() 方法，这同样涉及在多个线程之间共享 Runnable，但也利用wait() 和notify()。我在使用 Java 21 年多的时间里从未遇到过它。

Answer 2

与 void blah() { synchronized(this) { 相比，使用 synchronized void blah() 有 1 个优点，即生成的字节码将短 1 个字节，因为同步将成为方法签名的一部分，而不是单独的操作。这可能会影响 JIT 编译器内联该方法的机会。除此之外没有什么区别。

最好的选择是使用内部 private final Object lock = new Object() 来防止有人可能锁定您的监视器。它实现了相同的结果，而没有邪恶的外部锁定的缺点。你确实有那个额外的字节，但它很少有什么区别。

所以我想说不，不要在签名中使用 synchronized 关键字。相反，请使用类似

public class ThreadedClass implements Runnable{
    private final Object lock = new Object();

    public void run(){
        synchronized(lock) {
            while(true)
                 //do some stuff in a thread
            }
        }
    }
}

“编辑”的内容来响应评论：

考虑同步的作用：它防止其他线程进入相同的代码块。想象一下您有一个像下面这样的课程。假设当前大小为 10。有人尝试执行添加操作，它会强制调整后备数组的大小。当他们正在调整数组大小时，有人在不同的线程上调用 makeExactSize(5)。现在，您突然尝试访问data[6]，结果却突然崩溃了。同步应该可以防止这种情况发生。在多线程程序中，您只需要同步。

class Stack {
    int[] data = new int[10];
    int pos = 0;

    void add(int inc) {
        if(pos == data.length) {
            int[] tmp = new int[pos*2];
            for(int i = 0; i < pos; i++) tmp[i] = data[i];
            data = tmp;
        }
        data[pos++] = inc;
    }

    int remove() {
        return data[pos--];
    }

    void makeExactSize(int size) {
        int[] tmp = new int[size];
        for(int i = 0; i < size; i++) tmp[i] = data[i];
        data = tmp;
    }
}

Answer 3

为什么？最低限度的额外安全性，我看不出任何可能产生影响的情况。

为什么不呢？这不是标准的。如果您作为团队的一员进行编码，当其他成员看到您同步的 run 时，他可能会浪费 30 分钟试图弄清楚您的 run 有什么特别之处> 或使用您用来运行 Runnable 的框架。

Answer 4

根据我的经验，向 run() 方法添加“synchronized”关键字没有用。如果我们需要同步多个线程，或者需要线程安全的队列，我们​​可以使用更合适的组件，例如ConcurrentLinkedQueue。

Answer 5

查看代码注释并取消注释并运行不同的块以清楚地看到差异，注意只有使用相同的可运行实例时同步才会有差异，如果每个启动的线程都获得一个新的可运行实例，则不会有任何差异。

class Kat{

public static void main(String... args){
  Thread t1;
  // MyUsualRunnable is usual stuff, only this will allow concurrency
  MyUsualRunnable m0 = new MyUsualRunnable();
  for(int i = 0; i < 5; i++){
  t1 = new Thread(m0);//*imp*  here all threads created are passed the same runnable instance
  t1.start();
  }

  // run() method is synchronized , concurrency killed
  // uncomment below block and run to see the difference

  MySynchRunnable1 m1 = new MySynchRunnable1();
  for(int i = 0; i < 5; i++){
  t1 = new Thread(m1);//*imp*  here all threads created are passed the same runnable instance, m1
  // if new insances of runnable above were created for each loop then synchronizing will have no effect

  t1.start();
}

  // run() method has synchronized block which lock on runnable instance , concurrency killed
  // uncomment below block and run to see the difference
  /*
  MySynchRunnable2 m2 = new MySynchRunnable2();
  for(int i = 0; i < 5; i++){
  // if new insances of runnable above were created for each loop then synchronizing will have no effect
  t1 = new Thread(m2);//*imp*  here all threads created are passed the same runnable instance, m2
  t1.start();
}*/

}
}

class MyUsualRunnable implements Runnable{
  @Override
  public void  run(){
    try {Thread.sleep(1000);} catch (InterruptedException e) {}
}
}

class MySynchRunnable1 implements Runnable{
  // this is implicit synchronization
  //on the runnable instance as the run()
  // method is synchronized
  @Override
  public synchronized void  run(){
    try {Thread.sleep(1000);} catch (InterruptedException e) {}
}
}

class MySynchRunnable2 implements Runnable{
  // this is explicit synchronization
  //on the runnable instance
  //inside the synchronized block
  // MySynchRunnable2 is totally equivalent to MySynchRunnable1
  // usually we never synchronize on this or synchronize the run() method
  @Override
  public void  run(){
    synchronized(this){
    try {Thread.sleep(1000);} catch (InterruptedException e) {}
  }
}
}

Answer 6

理论上，您可以毫无问题地调用 run 方法本身（毕竟它是公共的）。但这并不意味着人们应该这样做。所以基本上没有理由这样做，除了给调用 run() 的线程增加了可以忽略不计的开销。好吧，除非您多次使用实例调用 new Thread - 尽管我 a) 不确定这对于线程 API 是否合法，b) 似乎完全没用。

此外，您的 createThreadQueue 也不起作用。非静态方法上的 synchronized 在实例对象（即 this）上同步，因此所有三个线程都将并行运行。