代码：

1. class MyThread implements Runnable{ // 继承Thread类，作为线程的实现类
   
2. private int ticket = 5 ;  // 表示一共有5张票
   
3. public void run(){ // 覆写run()方法，作为线程 的操作主体
   
4.   for(int i=0;i<100;i++){
   
5.    if(this.ticket>0){
   
6.     System.out.println("卖票：ticket = " + ticket--) ;
   
7.    }
   
8.   }
   
9. }
   
10. };
    
11. public class RunnableDemo02{
    
12. public static void main(String args[]){
    
13.   MyThread mt = new MyThread() ;  // 实例化对象
    
14.   new Thread(mt).run() ; // 调用线程主体
    
15.   new Thread(mt).run() ; // 调用线程主体
    
16.   new Thread(mt).run() ; // 调用线程主体
    
17. }
    
18. };
    
19. 为什么这样启动三个线程，我用如下方法启动结果就不对了，为什么呢？
    
20. MyThread mt1 = new MyThread() ;  // 实例化对象
    
21.   MyThread mt2 = new MyThread() ;  // 实例化对象
    
22.   MyThread mt3 = new MyThread() ;  // 实例化对象
    
23.   new Thread(mt1).start() ; // 调用线程主体
    
24.   new Thread(mt2).start() ; // 调用线程主体
    
25.   new Thread(mt3).start() ; // 调用线程主体

复制代码

你这下面有问题的方法不能这样写，换成如下写法应该就没问题了：
MyThread mt1 = new MyThread() ;         // 实例化对象
MyThread mt2 = new MyThread() ;         // 实例化对象
MyThread mt3 = new MyThread() ;         // 实例化对象

mt1.run() ;        // 调用线程主体
mt2.run() ;        // 调用线程主体
mt3.run() ;        // 调用线程主体

顺便一提，这样的实现Runnable接口有着明显的优势:
1.适合多个相同程序的代码去处理同意资源
2.可以避免单继承带来的局限性
3.增强了程序的健壮性,代码能够被多个程序共享,代码和数据是独立的

11.public class RunnableDemo02{

12.public static void main(String args[]){

13.  MyThread mt = new MyThread() ;  // 实例化对象，此时实例化一个对象，在本例中也就是有了一个车站，同时有了5张票。 14.  new Thread(mt).start() ; // 启动线程

15.  new Thread(mt).start() ; // 启动线程

16.  new Thread(mt).start() ; // 启动线程         这时有三个窗口卖。



如果按你这样写的话： 实例化了三次，那么就等于三个车站了，然后一个车站一个售票口
这是我的理解，你试着想一下。

20.MyThread mt1 = new MyThread() ;  // 实例化对象


21.  MyThread mt2 = new MyThread() ;  // 实例化对象

22.  MyThread mt3 = new MyThread() ;  // 实例化对象

23.  new Thread(mt1).start() ; // 调用线程主体

24.  new Thread(mt2).start() ; // 调用线程主体

25.  new Thread(mt3).start() ; // 调用线程主体

MyThread mt = new MyThread() ;  // 实例化对象
  new Thread(mt).run() ; // 调用线程主体
  new Thread(mt).run() ; // 调用线程主体
  new Thread(mt).run() ; // 调用线程主体
上面的代码段，run方法都是在main线程中运行，创建的线程没有启动，单线程。

MyThread mt1 = new MyThread() ;  // 实例化对象
  MyThread mt2 = new MyThread() ;  // 实例化对象
  MyThread mt3 = new MyThread() ;  // 实例化对象
  new Thread(mt1).start() ; // 调用线程主体
  new Thread(mt2).start() ; // 调用线程主体
  new Thread(mt3).start() ; // 调用线程主体

这样的话，第一个线程中运行mt1中的run方法，第二个线程中运行mt2中的run方法，第三个线程中运行mt3中的run方法。不是多线程了，是单线程（对同一个对象）运行。
就好比北京西站、广州站、西安站各自卖5张，但是他们都是中国的火车站这个大类中的一个实例对象，并且每个站只开了一个窗口。多线程应当是一个火车站
共卖5张票，开3个窗口共同卖这五张票。