为什么用Runnable 接口创建线程 ,建立了一个对象,能跑起来多条线程呢???而Thread 类建立,一个对象只能跑一条线程.

如果仍有问题，请继续追问，如果问题已解决，请将分类改为已解决，谢谢

以下是我的理解，看代码：
class MyThread1 extends Thread  
{
        public void run()
        {
                //线程运行代码
        }
}
class MyThread2 implements Runnable
{
        public void run()
        {
                //线程运行代码
        }
}
class MyThreadDemo
{
        public static void main(String[] args)
        {

                //采用继承Thread的方式创建线程       //线程是怎么创建和运行的
                MyThread1 mt1 = new MyThread1(); //new一个Thread才是创建一个线程，因为run方法定义在Thread类中
                                                                           //调用run方法线程才会运行，当然在这之前你得先开启它。
                mt1.start();                                         //虽然调用了两次start方法，但是只new了一个MyThread对象，而MyThread是Thread的子类。
                mt1.start();                                         //实际上也就是只调用了一次run方法中的功能，这里只能跑一个线程。

                MyThread1 mt1 = new MyThread();   //new了4个MyThread对象，每个对象都是Thread的子类，也就是创建了4个线程。
                MyThread2 mt2 = new MyThread();  //每个MyThread对象都分别复写了Thread类的run方法，只是复写的内容一样。
                MyThread3 mt3 = new MyThread();  //每个对象分别调用了自己的start方法，这里可以跑4个线程。
                MyThread4 mt4 = new MyThread();
                mt1.start();
                mt2.start();
                mt3.start();
                mt4.start();

                //采用实现Runnable接口的方式创建线程
                MyThread2 mt2 = new MyThread2();    //这个不多说，虽然只创建了一个MyThread对象，
                Thread t1 = new Thread(mt2);      
                Thread t2 = new Thread(mt2);           //但是new了4个Thread对象，而每个Thread对象都分别接收了mt2,
                Thread t3 = new Thread(mt2);           //这里4个线程也能跑起来
                Thread t4 = new Thread(mt2);
                t1.start();
                t2.start();
                t3.start();
                t4.start();        }
}

Runnable是待执行的任务，Thread 负责执行任务, 自然一个Thread对象一次就只能执行一个Runnable，而一个任务却可以给多个Thread对象执行

1. public class Demo {
   
2.           public static void main(String[] args)
   
3.       {
   
4.                   /*
   
5.                    * 每个线程拥有自己的对象
   
6.                    */
   
7.                   Threadd1 t1 = new Threadd1();
   
8.                   Threadd1 t2 = new Threadd1();
   
9.                   Threadd1 t3 = new Threadd1();
   
10.                   t1.start();
    
11.                   t2.start();
    
12.                   t3.start();
    
13.                   
    
14.                   /*
    
15.                    * 多条线程在操作同一个对象，可实现资源的共享，但要考虑同步
    
16.                    */
    
17.                   Threadd2 tt = new Threadd2();
    
18.                   tt.start();
    
19.                   Thread tt1 = new Thread(tt);
    
20.                   Thread tt2 = new Thread(tt);
    
21.                   Thread tt3 = new Thread(tt);
    
22.                   tt1.start();
    
23.                   tt2.start();
    
24.                   tt3.start();
    
25.       }
    
26. }
    
27. 
    
28. class Threadd1 extends Thread{
    
29.         public void run(){
    
30.                 System.out.println("Thread,线程要运行的代码");
    
31.         }
    
32. }
    
33. 
    
34. class Threadd2 implements Runnable{
    
35.         public void run(){
    
36.                 System.out.println("Runnable，线程要运行的代码");
    
37.         }
    
38.         public void start(){
    
39.                 System.out.println(Thread.currentThread().getName()+"这是开启线程么？");                //输出：main这是开启线程么？
    
40.         }
    
41. }

复制代码

1，继承Thread类，每创建一个线程，就会有一个对应的对象产生。
2，Runnable接口内部就定义了一个run方法，也就是说，如果类实现Runnable接口，不能通过像继承Thread类那样，通过start开启线程(内部没有start方法，即便自定义，也属功能调用，调用该功能的也是main线程)，所以，就需要将其子类对象传递给Thread类的构造函数，可以实现多条线程在操作同一个对象。当然，你也可以像继承Thread类那样，new一个对象，传递给Thread的构造函数，开启一个线程，只不过，这样就很麻烦。