1. public class b implements Runnable {
   
2.         Demo1 demo1 = new Demo1();
   
3.         @Override
   
4.         public void run() {
   
5.                 synchronized (demo1) {
   
6.                         demo1.method();
   
7.                         try {
   
8.                                 Thread.sleep(5000);
   
9.                         } catch (Exception e) {
   
10.                                 // TODO Auto-generated catch block
    
11.                                 System.out.println(e.toString());
    
12.                         }
    
13.                 }
    
14.         }
    
15.         public static void main(String args[]) {
    
16.                 Thread t1 = new Thread(new b());
    
17.                 Thread t2 = new Thread(new b());
    
18.                 t1.start();
    
19.                 t2.start();
    
20.         }
    
21. }
    
22. class Demo1 {
    
23. 
    
24.         public void method() {
    
25.                 System.out.println(Thread.currentThread().getName() + "正在运行。。。");
    
26.         }
    
27. }

复制代码

/*
* 说明下我的想法是t1，t2启动，先打印“Thread-0正在运行 ”　等到5秒钟后再打印“Thread-1在运行。。。” 可是为什么他们同时打印出来 才停5秒呢
* synchronized不是把对象锁定了吗5秒后才释放的？请各位指点下　谢谢
*/

synchronized关键字是解决线程共享资源冲突时用的,你上面虽然定义了两个线程单没有同时访问demo1变量，因为demo1是类中的局部变量不存在共享的问题，因此加synchronized关键字就没效果了

      楼主你好，这个你的想法很清晰，不过没有体现在代码上。很明显，在你的程序中，两个线程完全没有分别，都是先打印“正在运行。。。”，然后停了5s。
    要实现你的想法我知道的有两种方法，一个是启动了线程一之后，主线程停止5s再启动线程二；另一个是创建两个不同的类对象，实现的run方法一个是直接打印“正在运行。。”，另一个是先停止5s再打印。由于第二种方法很麻烦也不实用，我只修改了第一种方法的代码。希望对你有所帮助。
public class b implements Runnable {
        Demo1 demo1 = new Demo1();
        @Override
        public void run() {  
                                demo1.method();
        }
        public static void main(String args[]) {
                Thread t1 = new Thread(new b());
                Thread t2 = new Thread(new b());
                t1.start();
                try                                                  //线程0启动之后，主线程停5s再启动线程1
                {   
                        Thread.sleep(5000);
                }
                catch (Exception e)
                {
                        // TODO Auto-generated catch block
                        System.out.println(e.toString());
                }
                t2.start();
        }
}
class Demo1 {

        public void method() {
                System.out.println(Thread.currentThread().getName() + "正在运行。。。");
        }
}
已测试。

把这两个修改一下：
Thread t1 = new Thread(new b());
  Thread t2 = new Thread(new b());
//修改
b b = new b();
Thread t1 = new Thread(b);
Thread t2 = new Thread(b);
结论应是你锁的对象其实不同一个。

这样写就行了:
public class b implements Runnable {

        Demo1 demo1 = null;
        public b(Demo1 demo1){
                this.demo1=demo1;
        }
        @Override
        public void run() {

                synchronized (demo1) {

                        demo1.method();

                        try {
                               
                                Thread.sleep(2000);
                                System.out.println("休眠2s结束...");

                        } catch (Exception e) {

                                System.out.println(e.toString());

                        }

                }

        }

        public static void main(String args[]) {
                Demo1 demo=new Demo1();
                Thread t1 = new Thread(new b(demo));
                Thread t2 = new Thread(new b(demo));
               
                t1.start();
                t2.start();

        }

}

class Demo1{
        public void method() {
                System.out.println(Thread.currentThread().getName() + "正在运行。。。");
        }
}

想实现你的目的
其实 只要把你要所的对象做到全局静态就可以了
Demo1 demo1 = new Demo1();
改成
static  Demo1 demo1 = new Demo1();
你试一下看看

陈丽莉 发表于 2013-1-15 16:49
楼主你好，这个你的想法很清晰，不过没有体现在代码上。很明显，在你的程序中，两个线程完全没有分别 ...

我试下　谢谢你哦

yong230 发表于 2013-1-15 17:01
这样写就行了:
public class b implements Runnable {

恩　谢谢