继承  package thread;
class Ticket extends Thread
{
        private static int tike=100;
        public void run()
        {
                while(tike>0)
                {
                       try {
                                sleep(20);                 // 不用Thread.就能调用
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                                System.out.println(Thread.currentThread().getName()+"    run "+tike--);
                }
        }
}
public class TicketDemo {
        /**
         * @param args
         */
        public static void main(String[] args) {
                Ticket ti=new Ticket();
                Ticket t1=new Ticket();
                Ticket t2=new Ticket();
                Ticket t3=new Ticket();
                ti.start();
                t1.start();
                t2.start();
                t3.start();       
        }
}

实现package thread;
class Ticke implements Runnable
{
        private int tik=100;
        public void run() {
                while(tik>0)
                {
                        try {
                                Thread.sleep(20);            // 必须Thread. 来调用
.                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"   run="+tik--);
                }
        }
}
public class Runnable_1 {
        /**
         * @param args
         */
        public static void main(String[] args) {
                Ticke t=new Ticke();
                new Thread(t).start();
                new Thread(t).start();
                new Thread(t).start();
                new Thread(t).start();
        }
}
  
问什么在实现Runnable中，sleep（）必须由Thread. 来调用

根据继承的访问规则，子类继承了父类，可以直接访问父类中的方法，如果重写了要想访问父类的方法需要关键字super，本例中继承了Thread类，所以能够直接访问Tread类中方法sleep（）；
第二个实现Runnable接口，是在Thread类外，并且不是继承自Thread的子类中对Thread进行访问，本例中采用的是类名调用形式，

希望对你有帮助；

Thread具有sleep()方法，静态的。Runnable没有sleep()方法。

因为 Runnable 接口中只定义了 run() 方法用来装同步代码。
而 sleep 方法是Thread类中的。所以当通过 实现Runnable 接口来实现多线程时，要通过Thread来调用sleep() 方法。

希望我的回答能帮助到你{:soso_e128:}

在java程序中要创建一个线程有两种方法，一种是extends Thread；另一种是implements Runnable；

但是当我们要在一个线程中使用sleep()方法时，如果使用extends Thread方法去创建类那么可以直接使用sleep()方法，

如果使用的是implements Runnable创建类，那么必须是Thread.sleep()的格式，否则编译器报错。

我从另外的方面讲，代码
Ticke t=new Ticke();
new Thread(t).start();指向了thread类， 是因为在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。但是Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。
对于Thread.sleep(20); ，Runnable的接口也是没有sleep（）方法的，所以我们要使用类名来调用...

在继承Thread类中能只接写sleep，在实现Runnable接口中要写Thread.sleep。楼上各位都分析得很清楚。
另外建议：
1，在实际的应用中尽量使用Runnable来实现任务，这样有助于代码重用。
2，java5.0及之后在java.util.concurrent包中有很多线程工具类都能按受Runnable，如java.util.concurrent.ExecutorService。

还有问题的话继续追问~  么有了就将帖子分类改成【已解决】~

因为 Runnable中有run（）方法没有sleep（）方法  当class Ticke implements Runnable时需要用Thread 调用它的静态发方法sleep（）。
如果直接继承Thread就直接用就可以了。