关于线程 对象锁的问题
class ThreadTest implements Runnable
{
public void run()
{
print();
}
public synchronized void print()
{
System.out.println("name="+Thread.currentThread().getName());
try
{
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"............");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
/*ThreadTest t1=new ThreadTest();
t1.setName("t1");
ThreadTest t2=new ThreadTest();
t2.setName("t2");
t1.start();
t2.start();*/
//////////////
ThreadTest t=new ThreadTest();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
////////////////
}
运行上面的程序，结果是：
name=t2
t2............
name=t1
t1............
由于print()使用了同步方法，所以当t2进入print()是，获得了对象锁，t1只有等到t2跳出print()是才可执行。
但是把implements Runnable换成 extends Thread时，并把注释的打开，把//////////之间的注释掉。
结果为：
name=t2
name=t1
t2............
t1............
我也大概能理解，进入print()同步方法的不是同一个对象。我的疑惑是，所谓的同一个对象，到底指的是哪个对象，如果通过继承Thread方法，怎么才能得到同一个对象，显然
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
这段代码的t1与t2是两个对象。如何得到同一个对象呢？？？？刚开始看多线程，求高手解惑！！！！！！！！！
[最优解释]
楼主的代码,那个同步对象就是你生成的对象 t.
在类里，实际上就是this.
如果换成继承Thread类，可以改一下代码，楼主试试：
class ThreadTest1126 extends Thread
{
private Object lock;//设一个用于同步的对象.
public ThreadTest1126(Object lock)//创建一个构造方法,初始化同步对象.
{
this.lock=lock;
}
public void run()
{
synchronized(lock)//改修饰方法为修饰代码块.
{
print();
}
}
public void print()//这去掉同步.
{
System.out.println("name="+Thread.currentThread().getName());
try
{
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"............");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
Object lock=new Object();//产生一个用于同步的对象.
ThreadTest1126 t1=new ThreadTest1126(lock);//用这同一个同步对象,创建两个线程对象.
t1.setName("t1");
ThreadTest1126 t2=new ThreadTest1126(lock);
t2.setName("t2");
t1.start();
t2.start();
}
}
[其他解释]
public class ThreadTest2 extends Thread
{
private Object obj;
public ThreadTest2(Object obj)
{
this.obj=obj;
}
@Override
public void run()
{
print();
}
private void print()
{
synchronized(obj)
{
System.out.println("name= "+Thread.currentThread().getName());
try
{
Thread.sleep(5000);
}
catch(Exception e )
{
e.printStackTrace();
}
System.out.println("name2= "+Thread.currentThread().getName());
}
}
}
这个也行，只要是锁住一个对象
[其他解释]
public synchronized void print()//这句代码加锁的是对象，也就是this
楼主 加个static就可以啦
public synchronized static void print()//表示锁住的是类
[其他解释]
实现runnable接口可以达到资源的共享，而继承Thread类则不能,所以用继承的话，那个synchronized对它没用
[其他解释]
楼上说的很对！对象是有同步方法的那个对象，不是线程对象1
[其他解释]
nmyangym，
[其他解释]
public class ThreadInner
{
/**
* @param args
*/
public static void main(String[] args)
{
// TODO Auto-generated method stub
ThreadInner in=new ThreadInner();
ThreadInner.T t1=in.new T();
ThreadInner.T t2=in.new T();
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
class T extends Thread
{
public void run()
{
print();
}
}
public synchronized void print()
{
try
{
System.out.println(Thread.currentThread().getName());
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"...........");
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
刚刚看了一个例子，用内部类也可以实现
[其他解释]
+1.
[其他解释]
top top top