Question

当我执行以下代码时

public class ThreadTalk {
    public static void main(String[] args) {
        SimpleThread obj = new SimpleThread();
        Thread t = new Thread(obj, "NewThread");
        t.start();
        synchronized (obj) {
            System.out.println("In Synchronized BLOCK");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Out of Synchronized BLOCK");
        }
    }
}

class SimpleThread implements Runnable {
    public void run() {
        System.out.println("The thread running now " + Thread.currentThread());
        for (int i = 0; i < 10; i++) {
            System.out.println("The val of i= " + i);
        }
    }
}

我得到的输出是

In Synchronized BLOCK
The thread running now Thread[NewThread,5,main]
The val of i= 0
The val of i= 1
The val of i= 2
The val of i= 3
The val of i= 4
The val of i= 5
The val of i= 6
The val of i= 7
The val of i= 8
The val of i= 9
Out of Synchronized BLOCK

我期待像

这样的输出

In Synchronized BLOCK
Out of Synchronized BLOCK
The thread running now Thread[NewThread,5,main]
The val of i= 0
The val of i= 1
The val of i= 2
The val of i= 3
The val of i= 4
The val of i= 5
The val of i= 6
The val of i= 7
The val of i= 8
The val of i= 9

如果我使用主线程的同步块在SimpleThread对象上放置一个Lock，那么当主线程进入睡眠状态时我的NewThread是如何运行的。我的意思是NewThread不应等到主线程移除锁定在SimpleThread对象上，因为两个线程都在同一个对象上运行。

Answer 1

run()和/或start()不接受任何锁定。他们只是运行代码。你需要让SimpleTread获取与主线程相同的锁，以便这两个线程以某种方式同步。

我认为最好的做法是明确声明一个单独的对象用作锁。而不是尝试在Runnable对象上进行同步。

class ThreadTalk{
   public static void main(String[] args){
     Object lock = new Object();
     SimpleThread obj=new SimpleThread( lock );
     Thread t=new Thread(obj,"NewThread");
     t.start();

    synchronized(lock){
      System.out.println("In Synchronized BLOCK");
      try{
        Thread.sleep(5000);
        }catch(InterruptedException e){
         e.printStackTrace();
        }
      System.out.println("Out of Synchronized BLOCK");
    }
  }
}
class SimpleThread implements Runnable{
    private final Object lock;
    public SimpleThread( Object lock ) { this.lock = lock;}
    public void run(){
      synchronized( lock ) {
         System.out.println("The thread running now "+Thread.currentThread());
         for(int i=0;i<10;i++){
           System.out.println("The val of i= "+i);
         }
       }
    }
}

Answer 2

您需要在同一对象（即所谓的“监视器”）的两个线程中进行同步，以使它们互斥。

最简单的方法是使run()方法本身synchronized：

class SimpleThread implements Runnable {
    // See the synchronized modifier on the next line
    public synchronized void run() {
        System.out.println("The thread running now " + Thread.currentThread());
        for (int i = 0; i < 10; i++) {
            System.out.println("The val of i= " + i);
        }
    }
}

您还需要确保在之前在SimpleThread对象上进行同步，然后在线程中启动它，因此您需要在t.start();内移动synchronized (obj) {语句阻止。如果你不这样做，两个线程仍然不正确地同步，并且不知道哪个线程将首先运行。

Answer 3

synchronized阻止不符合您的想法。这意味着同时只有一个线程可以在其中（或者更确切地说在同一对象上的任何同步块内）。在您的情况下，块内只有一个（主）线程。另一个是执行不同的代码。这是预期的。

在以下java代码中无法理解线程同步的行为

3 个答案: