关于一个线程的基础问题,头大了,郁闷中

Question

这是从网上找的例子
class ThreadA
{
public static void main(String[] args)
{
ThreadB b = new ThreadB();
b.start();
System.out.println("b is start....");
synchronized (b)
{
try
{
System.out.println("Waiting for b to complete...");
b.wait();
System.out.println("Completed.Now back to main thread");
}
catch (InterruptedException e)
{
}
}
System.out.println("Total is :" + b.total);
}
}class ThreadB extends Thread
{
  int total;
  public void run()
  {
    synchronized(this)
    {
      System.out.println("ThreadB is running..");
      for (int i=0;i<100;i++ )
      {
        total +=i;
        System.out.println("total is "+total);
      }
      notify();
      System.out.println("ThreadB is finish..");
    }
  }
}在运行主程序 ThreadA时,下面是大部分的结果
b is start....
ThreadB is running..
total is 0
total is 1
total is 3
total is 6
............(这是中间省略的结果)
ThreadB is finish..
Waiting for b to complete...
Completed.Now back to main thread
Total is :4950但是多运行几次后,有时候会出现如下结果虽然是小概率
b is start....
ThreadB is running..
total is 0
total is 1
total is 3
............(这是中间省略的结果)
ThreadB is finish..
Waiting for b to complete...
程序就处于一种无限等待状态,除非我手动结束我现在的问题是,根据每次的输出结果基本上都是ThreadB 能抢到锁,然后去执行,所以我认为
每次都应该是主线程出现无限等待状态才对.但是实际结果是大部分居然能执行完成,那这里的wait方法,还有什么作用?感觉就没起作用,wait不是说,把线程持有的对象锁释放掉吗,然后线程进入对象的等待集合吗?在这里ThreadA中持有b对象的不就是主线程吗?一旦执行到wait方法,主线程不应该挂起吗,他要向继续执行,不得等其他地方执行notify吗,但是现在notify比他先执行了呀,那永远也不会有线程唤醒他了呀,他怎么还会继续执行呢?请高人指点

Answer 1

我现在的问题是,根据每次的输出结果基本上都是ThreadB 能抢到锁,然后去执行,所以我认为
每次都应该是主线程出现无限等待状态才对========================
不是每次都是ThreadB抢到锁啊，你都说基本上是了。还有不要打印那么多，你sleep一下。看的清楚点。public class ThreadA {
public static void main(String[] args) {
ThreadB b = new ThreadB();
b.start();
System.out.println("b is start....");
synchronized (b) {
try {
System.out.println("Waiting for b to complete...");
System.out.println("before wait...");
b.wait();
System.out.println("after wait...");
System.out.println("Completed.Now back to main thread");
} catch (InterruptedException e) {
}
}
System.out.println("Total is :" + b.total);
}
}class ThreadB extends Thread {
int total; public void run() {
synchronized (this) {
System.out.println("ThreadB is running..");
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
total += i;
System.out.println("total is " + total);
}
notify();
System.out.println("ThreadB is finish..");
}
}
}两种情况：
1、主线程在ThreadB执行到run之前，执行到sync块里面了。那这种情况就是：
b is start....
Waiting for b to complete...
before wait...
ThreadB is running..
total is 0
total is 1
total is 3
total is 6
total is 10
total is 15
total is 21
total is 28
total is 36
total is 45
ThreadB is finish..
after wait...
Completed.Now back to main thread
Total is :451、主线程在ThreadB执行到run之后，执行到sync块里面了，这个就无限等待了。b is start....
ThreadB is running..
total is 0
total is 1
total is 3
total is 6
total is 10
total is 15
total is 21
total is 28
total is 36
total is 45
ThreadB is finish..
Waiting for b to complete...
before wait...

Answer 2

针对这一句
一旦执行到wait方法,主线程不应该挂起吗,他要向继续执行,不得等其他地方执行notify吗,但是现在notify比他先执行了呀,那永远也不会有线程唤醒他了呀,他怎么还会继续执行呢?Waiting for b to complete..
b.wait();//这里wait了。后面的有运行么？
System.out.println("Completed.Now back to main thread");