定义了如下3个类，大致情况的主进程同时启动两个test2和test3线程。
test2和test3的run方法内部都添加了synchronized模块，当两个模块中的参数互指或互不指，即test2种模块参数指向test3同时test3的参数指向test2，或test2和test3的参数都指向自己this时，运行结果为2个test2，test3线程互相等待但test2和test3线程同时运行：
new test()
t2 0
t3 0
t3 1
t2 1
t3 2
t2 2
t2 3
t3 3
t3 4
t2 4
t3 5
t2 5
t2 0
t3 6
t2 1
t3 7
t3 8
t2 2
t2 3
t3 9
t2 4
t3 10
t2 5
t3 0
t3 1
t3 2
t3 3
t3 4
t3 5
t3 6
t3 7
t3 8
t3 9
t3 10
当test2的参数指向test3，test3的参数指向自己this；或者test2的参数指自己，test3的参数指test2时，运行结果是4个test2，test3线程互相等待，同时只有一个线程运行：
new test()
t2 0
t2 1
t2 2
t2 3
t2 4
t2 5
t3 0
t3 1
t3 2
t3 3
t3 4
t3 5
t3 6
t3 7
t3 8
t3 9
t3 10
t2 0
t2 1
t2 2
t2 3
t2 4
t2 5
t3 0
t3 1
t3 2
t3 3
t3 4
t3 5
t3 6
t3 7
t3 8
t3 9
t3 10
并且不论synchronized块的参数是什么，同一个对象的运行是被锁住了，即两个test2和两个test3之间只能同时运行一个。
想问下高手jvm如何产生这个特性的原理是什么，这个参数又有什么方面的应用啊？
public class test implements Runnable{
Thread t;
Thread t1;
test2 t2=new test2() ;
test3 t3=new test3();
Thread T3;
Thread TT3;
test()
{
System.out.println("new test()");
t=new Thread(this);
t1=new Thread(this);
t2.t3=t3;
t3.t2=t2;
t.start();
t1.start();
T3=new Thread(t3);
TT3=new Thread(t3);
T3.start();
TT3.start();
}
public void run()
{
t2.speak();
}
public static void main(String[] args)
{
// TODO Auto-generated method stub
new test( );
}
}
public class test2
{
test3 t3;
public void speak()
{
synchronized(t3){ //test2中参数指向test3线程
for(int i=0;i<=5;i++)
{
System.out.println("t2 "+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class test3 implements Runnable{
test2 t2;
public void run()
{
synchronized(this){ //synchronized参数指向自己
for(int i=0;i<=10;i++)
{
System.out.println("t3 "+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
