1. class Ticket implements Runnable//extends Thread
   
2. {
   
3.         private int tick = 100;
   
4.         public void run()
   
5.         {
   
6.                 while (true)
   
7.                 {
   
8.                         if(tick > 0)
   
9.                         {
   
10.                                 System.out.println(Thread.currentThread().getName()+"....sale: " + tick--);
    
11.                         }
    
12.                 }
    
13.         }
    
14. }
    
15. 
    
16. class  TicketDemo
    
17. {
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 Ticket t = new Ticket();
    
21. 
    
22.                 Thread t1 = new Thread(t);//创建了一个线程;
    
23.                 Thread t2 = new Thread(t);//创建了一个线程;
    
24.                 Thread t3 = new Thread(t);//创建了一个线程;
    
25.                 Thread t4 = new Thread(t);//创建了一个线程;
    
26.                 t1.start();
    
27.                 t2.start();
    
28.                 t3.start();
    
29.                 t4.start();
    
30. 
    
31. 
    
32.                 //Ticket t1 = new Ticket();
    
33.                 //t1.start();
    
34.         }
    
35. }

复制代码

补充：为什么实现了Runnable接口，下面就可以创建一个Thread类的子对象，Thread类和Runnable什么关系？

Thread是类，Runnable是接口。
如果一个类继承了其他的类还想多线程怎么办？ java不能多继承。  这时候就用到Runnable接口了。
实现Runnable接口就可以了。

查API  类Thread：
public class Thread extends Object implements RunnableRunnable定义的子类中没有start()方法，只有Thread类中才有
Thread类也是Runnable接口的子类Thread类有一个构造方法：
public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。

伍叶竹 发表于 2014-4-19 22:02
Thread是类，Runnable是接口。
如果一个类继承了其他的类还想多线程怎么办？ java不能多继承。  这时候就用 ...

为什么实现了Runnable接口，就可以创建Thread的对象？不是需要继承Thread后才能创建吗？

LYG 发表于 2014-4-19 22:09
为什么实现了Runnable接口，就可以创建Thread的对象？不是需要继承Thread后才能创建吗？ ...

class Ticket implements Runnable//extends Thread
只改这里的话是不对的。
MyRunnable implements Runable      //实现Runnable接口——>
MyRunnable mr=new MyRunnable();//new实现Runnable接口的类——>
new Thread(mr).start() ;    //看这里。。再看板凳。

5、创建线程的第二种方法是声明实现Runable接口的类，该类然后实现run方法。然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动，代码示例：

//实现Runable接口的类，覆写run方法
class PrimeRun implements Runable
{
    long minPrimeRun;
    PrimeRun(long minPrime)
    {
        this.minPrime = minPrime;
    }
    public void run()
     {
        ...
     }
}
//创建并启动一个线程
    PrimeRun p = new PrimeRun(143);
    new Thread(p).start();         //等效于   Thread t = new Thread(p);   t.start();
                                                 //Thread类中构造方法  Thread(Runable target);  接收Runable接口类型的对象


这是看毕老师视频时做的笔记。给你参考

查看java的api文档就可以知道Thread类的定义是这样的
public class Thread extends Object implements Runnable
也就是说 Thread类也是实现了Runable接口
你想要启动一个线程，就需要调用Thread.start()这个方法，再看API文档中对start方法的定义
public native synchronized void start()  使该线程开始执行; Java 虚拟机调用线程 run 方法
这句话就是说，你调用start方法，实际上就是执行Runnable接口的run方法，而Runnable接口中，仅仅定义了一个run方法
也就是说，你想创建一个Thread类的子对象，你就必须能给的出Runnable接口的run方法的具体实现，而实现这个run方法的方法，要么继承Thread类，因为Thread类继承了Runnable接口，所以子类也就间接继承了Runnable接口；要么就继承Runnable接口，然后定义Thread类的实例时将类对象作为参数传进去。
针对你的疑问：为什么实现了Runnable接口，就可以创建Thread的对象？不是需要继承Thread后才能创建吗
实际上，多线程从根本上来讲，就是实现Runnable接口，你继承Thread实际上也是重写Thread中Runnable接口里定义的run( )方法，只不过如果继承了Thread，你那个类就有了Thread所拥有的start方法什么的，可以直接调用，而继承了Runnable接口，你需要将你的对象作为参数传进Thread的实例中，通过调用Thread的实例的start方法来起线程，因为你自己定义的那个类里没有start方法不是
不知道我这样解释你清楚了不，不明白的话可以问我

java中使用多线程有两种方法

第一种：继承Thread类
步骤：
1 定义类继承Thread
2 复写Thread类中的run方法
      （Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法）
3 调用start方法

第二种：实现Runnable接口

步骤：
1 定义实现Runnable接口
2 覆盖Runnable接口中的run方法
3 通过Thread类建立线程对象
4 将Runnable类接口的子类对象作为实际参数传递给Thread类的构造函数
5 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

为什么要将Runnable接口的子类对象传递给Thread的构造函数？
    因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法；就必须明确该方法所属的对象

Runnable接口中只有一个run方法，使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

实现方式和继承方式有什么区别？
实现方式好处在于：避免了单继承的局限性，在定义线程时，建议使用实现形式

两种方式的另一区别：
继承Thread类：线程代码存放在Thread子类run方法中
实现Runnable：线程代码存放在接口子类的run方法中

package com.isoftstone.interview;

public class Ticket implements Runnable {

        private int ticket = 100;

        public void run() {
                        //线程 RUN 方法，
                while (true) {
                        if (ticket > 1) {
                                System.out.println(Thread.currentThread().getName() + " "
                                                + ticket--);

                        } else {
                                break;   // 一个判断，
                        }
                }

        }
}


package com.isoftstone.interview;

public class TicketDemo {
        public static void main(String[] args) {
                Ticket t = new Ticket();

                Thread t1 = new Thread(t);// 创建了一个线程;
                Thread t2 = new Thread(t);// 创建了一个线程;
                Thread t3 = new Thread(t);// 创建了一个线程;
                Thread t4 = new Thread(t);// 创建了一个线程;
                // 4个线程一起 调用 ticket类 中，100ticket 参数，
                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }

}

Thread 是类 一个类继承了Thread类就可以new 对象创建线程。但是java是单继承的  如果你想实现线程 有想 实现继承 假设如果你继承了Thread还如何去继承别的类呢 ？  所以java 给我们提供了另一种创建类的方法 就是一个类实现Runnable 接口 然后去new 对象然后去创建线程， 还可以去继承其想继承的类 。 不过一般情况下 推荐通过一个类实现Runnable接口 来创建线程，不推荐你使用Thread  new对象的方法。原因我也说不清楚 不过还是感觉 通过类实现Runnable接口来床见线程比较好

忘川 发表于 2014-4-19 22:59
查看java的api文档就可以知道Thread类的定义是这样的
public class Thread extends Object implements Run ...

好像都不是我要的答案，不过谢谢你们啦，毕老师的我看过才发问的，黏贴笔记的下来给我就不用啦，我自己每节都有记笔记。
谢谢你的回答啦，哥们！

Thread是类，只能单继承。而Runnable接口，Thread 类实现了 Runnable。。为什么有了继承还要提供继承了？那是因为假如有一个类，而且它是继承了某一个类，此时就不能在继承thread类了，这是单继承的局限性。。所以就要使用接口来完成。。
步骤：
1，定义一个类实现Runnable接口。
2，覆盖Runnable接口中的run方法。
        将线程要运行的代码存储到run方法中。
3，创建该接口的子类对象。
4，通过Thread类进行线程的创建，并将Runnable接口的子类对象作为Thread类的构造函数的实参进行传递。
        为什么要传递呢？
        让线程对象创建时，就要明确要运行哪个run方法，而这个run方法是需要被对象调用的，
        所以将run方法所属的对象传递给Thread类的构造函数。
5，调用Thread类中的start方法开启线程。