线程在java中notifyAll之后不打印所有内容 类锁实现可运行{ int i=0； 公共同步的无效运行（）{ for（i=0；i

i

是一个实例变量。它由所有线程共享。它应该是一个局部变量

---

当第一个线程被唤醒时，它重新获得锁，打印其名称，增加i，并重新计算if

i<10

。但是由于其他线程已经将

i

设置为10，循环停止。

i

是一个实例变量。它由所有线程共享。它应该是一个局部变量

---

当第一个线程被唤醒时，它重新获得锁，打印其名称，增加i，并重新计算if

i<10

。但是由于其他线程已经将

i

设置为10，循环停止。

i

是一个实例变量。它由所有线程共享。它应该是一个局部变量

---

当第一个线程被唤醒时，它重新获得锁，打印其名称，增加i，并重新计算if

i<10

。但是由于其他线程已经将

i

设置为10，循环停止。

i

是一个实例变量。它由所有线程共享。它应该是一个局部变量

---

当第一个线程被唤醒时，它重新获得锁，打印它的名称，增加i，并重新计算if

i<10

。但是由于其他线程已经将

i

设置为10，循环停止。

问题是线程之间共享相同的索引

i

，因此当线程t3存在且t1被唤醒时n index

i

将是

10

，线程t1中的for循环将退出。

问题是线程之间共享相同的索引

i

，因此当线程t3存在且t1被唤醒时，index

i

将是

10

，线程t1中的for循环将退出。

问题是您正在共享g线程之间有相同的索引

i

，因此当线程t3存在且t1被唤醒时，索引

i

将是

10

，线程t1中的for循环将退出。

问题在于线程之间共享相同的索引

i

，因此当线程t3存在且t1被唤醒时，索引

i

将是

 10

线程t1中的for循环将退出。

在启动每个线程后尝试调用.join（），以确保每个线程在程序退出之前完成？

在启动每个线程后尝试调用.join（），以确保每个线程在程序退出之前完成？

尝试调用.join（）在每个线程启动后，请确保每个线程在程序退出之前完成？

尝试在每个线程启动后调用.join（），以确保每个线程在程序退出之前完成？

虽然JB Nizet已经给出了正确答案，但您可能会想，为什么这只会影响

t1

： 调用run方法（已同步）时，每个线程都在重置

i

但是在返回t1执行的那一刻，它不会重置

i

，因为线程已经启动了

for

-循环

class Lock implements Runnable{
  int i=0;
  public synchronized void run(){
    for(i=0;i<10;i++){
        if(Thread.currentThread().getName().equals("t1") && i == 5)
         {try { this.wait();} catch(InterruptedException ie){}}
        System.out.print(Thread.currentThread().getName()+" ");
        if(Thread.currentThread().getName().equals("t3") && i == 9)
         this.notifyAll();
  }
 }
}
public class ThreadLock {
 public static void main(String[] args){   
  Lock l = new Lock();
  Thread t1 = new Thread(l);
  Thread t2 = new Thread(l);
  Thread t3 = new Thread(l);
  t1.setName("t1");
  t2.setName("t2");
  t3.setName("t3");
  t1.start();
  t2.start();
  t3.start();
 }
}

---

注意：这至少是您描述的输出所发生的情况。我认为也有可能t2在t3之前执行，导致不同的输出。

虽然JB Nizet已经给出了正确的答案，但您可能想知道，为什么这只会影响

t1

： 调用run方法（已同步）时，每个线程都在重置

i

但是在返回t1执行的那一刻，它不会重置

i

，因为线程已经启动了

for

-循环

class Lock implements Runnable{
  int i=0;
  public synchronized void run(){
    for(i=0;i<10;i++){
        if(Thread.currentThread().getName().equals("t1") && i == 5)
         {try { this.wait();} catch(InterruptedException ie){}}
        System.out.print(Thread.currentThread().getName()+" ");
        if(Thread.currentThread().getName().equals("t3") && i == 9)
         this.notifyAll();
  }
 }
}
public class ThreadLock {
 public static void main(String[] args){   
  Lock l = new Lock();
  Thread t1 = new Thread(l);
  Thread t2 = new Thread(l);
  Thread t3 = new Thread(l);
  t1.setName("t1");
  t2.setName("t2");
  t3.setName("t3");
  t1.start();
  t2.start();
  t3.start();
 }
}

---

注意：这至少是您描述的输出所发生的情况。我认为也有可能t2在t3之前执行，导致不同的输出。

虽然JB Nizet已经给出了正确的答案，但您可能想知道，为什么这只会影响

t1

： 调用run方法（已同步）时，每个线程都在重置

i

但是在返回t1执行的那一刻，它不会重置

i

，因为线程已经启动了

for

-循环

class Lock implements Runnable{
  int i=0;
  public synchronized void run(){
    for(i=0;i<10;i++){
        if(Thread.currentThread().getName().equals("t1") && i == 5)
         {try { this.wait();} catch(InterruptedException ie){}}
        System.out.print(Thread.currentThread().getName()+" ");
        if(Thread.currentThread().getName().equals("t3") && i == 9)
         this.notifyAll();
  }
 }
}
public class ThreadLock {
 public static void main(String[] args){   
  Lock l = new Lock();
  Thread t1 = new Thread(l);
  Thread t2 = new Thread(l);
  Thread t3 = new Thread(l);
  t1.setName("t1");
  t2.setName("t2");
  t3.setName("t3");
  t1.start();
  t2.start();
  t3.start();
 }
}

---

注意：这至少是您描述的输出所发生的情况。我认为也有可能t2在t3之前执行，导致不同的输出。

虽然JB Nizet已经给出了正确的答案，但您可能想知道，为什么这只会影响

t1

： 调用run方法（已同步）时，每个线程都在重置

i

但是在返回t1执行的那一刻，它不会重置

i

，因为线程已经启动了

for

-循环

class Lock implements Runnable{
  int i=0;
  public synchronized void run(){
    for(i=0;i<10;i++){
        if(Thread.currentThread().getName().equals("t1") && i == 5)
         {try { this.wait();} catch(InterruptedException ie){}}
        System.out.print(Thread.currentThread().getName()+" ");
        if(Thread.currentThread().getName().equals("t3") && i == 9)
         this.notifyAll();
  }
 }
}
public class ThreadLock {
 public static void main(String[] args){   
  Lock l = new Lock();
  Thread t1 = new Thread(l);
  Thread t2 = new Thread(l);
  Thread t3 = new Thread(l);
  t1.setName("t1");
  t2.setName("t2");
  t3.setName("t3");
  t1.start();
  t2.start();
  t3.start();
 }
}

---

注意：这至少是您描述的输出所发生的情况。我认为也有可能，t2在t3之前执行，导致不同的输出。

任何活动的非守护进程线程都应该阻止jvm终止，但当main返回时，stdout可能会关闭。任何活动的非守护进程线程都应该阻止jvm终止，但当main返回时stdout可以关闭。任何活动的非守护进程线程都应该阻止jvm终止，但当main返回时stdout可以关闭。任何活动的非守护进程线程都应该阻止jvm终止，但当main返回时stdout可以关闭。谢谢。我知道了。“I”在同步方法之外，所以现在我做了“I”'for循环的局部变量。'for（int i=0；i谢谢你。我得到了。'i'在同步方法之外，所以现在我做了for循环的'i'局部变量。'for（int i=0；i谢谢你。我得到了。'i'在同步方法之外，所以现在我做了for循环的'i'局部变量。'（int i=0；i谢谢你。我知道了。“i”在同步方法之外，所以现在我创建了for循环的“i”局部变量。“for”（int i=0；i即使在你将

i

更改为