这个java程序，为什么一个notify唤醒了3个wait

0 0

这个java程序，为什么一个notify唤醒了3个wait0

//主程序
class Demo6
{
public static void main(String[] args)
{

Go1 q=new Go1();
Go2 qq=new Go2(q);
Go3 qqq=new Go3(q);
Come w=new Come(q);

q.start();
qq.start();
qqq.start();
w.start();

}
}
//线程1，打印1，等待，唤醒后打印一
class Go1 extends Thread
{
public void run()
{

synchronized (this)
{
System.out.println("1");
try
{
wait();
}
catch (Exception e)
{
}
}
System.out.println("一");

}

}
//线程2，打印2，等待，唤醒后打印二
class Go2 extends Thread
{
Go1 g;
Go2(Go1 g)
{
this.g=g;

}
public void run()
{

synchronized (g)
{
System.out.println("2");
try
{
g.wait();
}
catch (Exception e)
{
}
}
System.out.println("二");
}
}
//线程3，打印3，等待，唤醒后打印三
class Go3 extends Thread
{
Go1 g;
Go3(Go1 g)
{
this.g=g;

}
public void run()
{

synchronized (g)
{
System.out.println("3");
try
{
g.wait();
}
catch (Exception e)
{
}
}
System.out.println("三");
}
}
//唤醒线程
class Come extends Thread
{
Go1 r;

Come(Go1 r)
{
this.r=r;
}
public void run()
{
try
{
sleep(100);
}
catch (Exception e)
{
}
synchronized (r)
{
r.notify();
System.out.println("lock open");
}
}
}

Java

2012年10月22日 21:36

冰羽1
30
0 0 2

5个答案按时间排序按投票排序

0 0

synchronized (g) 锁定的都是同一个Go1，r.notify();会解除synchronized (g) 和synchronized (this)的锁，当然有三个线程被唤醒了，如果每个线程都是不同Go1实例，就不会了。

2012年10月24日 22:10

opnmzxcvb
35
0 0 4

添加评论

0 0

如果一个线程对象最为锁对象,当线程执行完成后,会 notifyAll(); 其他线程.

原因:

Thread.exit() 方法

/**
     * This method is called by the system to give a Thread
     * a chance to clean up before it actually exits.
     */
    private void exit() {
	if (group != null) {
	    group.remove(this);
	    group = null;
	}
	// ...
    }

其中的 group.remove(this);

/**
     * Removes the specified Thread from this group.
     * @param t the Thread to be removed
     * @return if the Thread has already been destroyed.
     */
    void remove(Thread t) {
	synchronized (this) {
	    //...
	    if (nthreads == 0) {
		notifyAll();
	    }
            // ...
	}
    }

以上结论均为目测,无官方文档证实~~~~~~~

测试代码:

public class Test
{
	public static Lock	lock	= new Lock();

	public static void main(String[] args)
	{
		A a = new A();
		B b = new B();

		a.start();
		b.start();

		try
		{
			TimeUnit.SECONDS.sleep(3);
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}

		synchronized(lock)
		{
			try
			{
				System.out.println("catch lock");
				lock.start();
				System.out.println("notifyall");
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
		}
	}

	static class A extends Thread
	{

		@Override
		public void run()
		{

			synchronized(lock)
			{
				System.out.println("a");
				try
				{
					lock.wait();
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
				System.out.println("aa");
			}
		}
	}

	static class B extends Thread
	{

		@Override
		public void run()
		{

			synchronized(lock)
			{
				System.out.println("b");
				try
				{
					lock.wait();
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
				System.out.println("bb");
			}

		}
	}

	static class Lock extends Thread
	{

	}
}

2012年10月23日 12:19

suene
17
0 0 6

添加评论

0 0

原因是共用的对象本身也是一个线程，所以notify的时候，如果被唤醒的是Go1的线程，那么Go2和Go3中的g.wait();也会跟着返回，所以相当于Go1,Go2,Go3都被唤醒，然后一起争夺锁。把共用的对象换成一个普通的对象就没有问题了。代码如下：

class  Demo6 
{ 

	public static void main(String[] args) 
	{ 
		Go g = new Go();
		Go1 q=new Go1(g); 
		Go2 qq=new Go2(g); 
		Go3 qqq=new Go3(g); 
		Come w=new Come(g); 

		q.start(); 
		qq.start(); 
		qqq.start(); 
		w.start(); 
	} 
}


class Go{
	
	
}



class Go1 extends Thread 
{ 
	Go g;
	Go1(Go g) 
	{ 
		this.g=g; 
	} 
	
	public void run() 
	{ 

		synchronized (g) 
		{ 
			System.out.println("1"); 
			try 
			{ 
				g.wait(); 
			} 
			catch (Exception e) 
			{ 
			} 
		} 
		System.out.println("一"); 
	} 
} 

class Go2 extends Thread 
{ 
	Go g; 
	Go2(Go g) 
	{ 
		this.g=g; 
	} 

	public void run() 
	{ 
		synchronized (g) 
		{ 
			System.out.println("2"); 
			try 
			{ 
				g.wait(); 
			} 
			catch (Exception e) 
			{ 
			} 
		} 
		System.out.println("二"); 
	} 
} 

class Go3 extends Thread 
{ 
	Go g; 
	Go3(Go g) 
	{ 
		this.g=g; 
	} 
	public void run() 
	{ 
		synchronized (g) 
		{ 
			System.out.println("3"); 
			try 
			{ 
				g.wait(); 
			} 
			catch (Exception e) 
			{ 
			} 
		} 
		System.out.println("三"); 
	} 
} 
 
class Come extends Thread 
{ 
	Go r; 

	Come(Go r) 
	{ 
		this.r=r; 
	} 
	public void run() 
	{ 
		try 
		{ 
			sleep(100); 
		} 
		catch (Exception e) 
		{ 
		} 
		synchronized (r) 
		{ 
			r.notify(); 
			System.out.println("lock open"); 
		} 
	} 
}

2012年10月23日 11:21