class ThreadDemo
{
        public static void main(String[] args) throws Exception
        {               
                Demo d1=new Demo();               
                Demo d2=new Demo();
                Thread t1=new Thread(d1,"1111111111");
                Thread t2=new Thread(d2,"2222222222");
                t1.start();        
                t1.sleep(3000); 我在这里将t1线程sleep了，按理说t1线程应该不动，
                                 主线程继续向下执行，将t2线程启动，然后t1醒来后继续执行。
                             可结果却是主线程将t1执行完后睡了3秒才执行t2.               
               t2.start();
        }
}
class Demo implements Runnable
{
        public void run()
        {
                for (int x=0; x<100;x++ )
                {
                        System.out.println(Thread.currentThread().getName()+"....."+x);
                }
        }
}
问：我明明是将t1睡了，结果为什么是将主线程将t1启动后主线程被sleep()了？

class ThreadDemo extends Thread
{
                private int time = 0;
                public ThreadDemo(int time, Runnable target, String name){
                        super(target,name);
                        this.time = time;
                }
                public synchronized void start() {
                        if(this.time>0){
                                try {
                                        sleep(time*1000);
                                        System.out.println("time:"+this.time);
                                        super.start();
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        }else{
                                super.start();
                        }
                }
        public void run()
        {
                for (int x=0; x<100;x++ )
                {
                        System.out.println(Thread.currentThread().getName()+"....."+x);
                }
        }

        public static void main(String[] args) throws Exception
        {               
                Demo d1=new Demo();               
                Demo d2=new Demo();
                ThreadDemo t1=new ThreadDemo(3,d1,"1111111111");
                ThreadDemo t2=new ThreadDemo(1,d2,"2222222222");
                t1.start();              
               t2.start();
        }
}
class Demo implements Runnable
{
        public void run()
        {
                for (int x=0; x<100;x++ )
                {
                        System.out.println(Thread.currentThread().getName()+"....."+x);
                }
        }
}
帅哥，给你调试了一下，应该是在运行的线程开始前进行睡眠。

杜鹏云 发表于 2012-8-11 21:41
sleep的用法：Thread.sleep(time);
sleep伟Thread中的静态方法。一般不用对象来调用。
sleep只是睡眠当前的 ...

我刚才写的代码中的类最后少了一个}。请检查一下。这个思路我觉得还是可行的。就是延迟调用start方法。请用eclipse或myeclipse来检验下代码。

杜鹏云 发表于 2012-8-11 21:41
sleep的用法：Thread.sleep(time);
sleep伟Thread中的静态方法。一般不用对象来调用。
sleep只是睡眠当前的 ...

我用你写的方法怎么编译不通过啊，你确定是这样的吗？

想法是不错，线程是抢资源的，那把cpu想得太忙了，当你的线程1一启动，cpu就执行了，当你cpu把你线程1执行完了，你的程序才读到sleep（），cpu执行速度是非常快的~~~

sleep的用法：Thread.sleep(time);
sleep伟Thread中的静态方法。一般不用对象来调用。
sleep只是睡眠当前的线程，与对象无关。
如果你想静止3秒在运行t2的话，写法：
Class Demo extends Thread{
public void run(){}
private int time=0;
public Demo(int time){
this.time = time;
}
public synchronized void start(){
if(this.time>0)sleep(time);
super.start();
}

围观学习中........

class ThreadDemo
{
        public static void main(String[] args) throws Exception
        {               
                Demo d1=new Demo();               
                Demo d2=new Demo();
                Thread t1=new Thread(d1,"1111111111");
                Thread t2=new Thread(d2,"2222222222");
                t1.start();        
                t1.sleep(3000); 我在这里将t1线程sleep了，按理说t1线程应该不动，
                                 主线程继续向下执行，将t2线程启动，然后t1醒来后继续执行。
                             可结果却是主线程将t1执行完后睡了3秒才执行t2.               
               t2.start();//sleep()是一个静态方法，也就是说，它只对当前对象有效。t1.sleep(3000);想让t1对象进入sleep
   //这样的做法是错误的，它只会使当前线程被sleep，而不是t1线程
        }
}
class Demo implements Runnable
{
        public void run()
        {
                for (int x=0; x<100;x++ )
                {
                        System.out.println(Thread.currentThread().getName()+"....."+x);
                }
        }
}
问：我明明是将t1睡了，结果为什么是将主线程将t1启动后主线程被sleep()了？
这是个很典型的错误
sleep()是一个静态方法，也就是说，它只对当前对象有效。t1.sleep(3000);想让t1对象进入sleep
这样的做法是错误的，它只会使当前线程被sleep，而不是t1线程