黑马程序员技术交流社区

标题: 多线程的创建问题???? [打印本页]
作者: 康嘉    时间: 2013-4-1 22:59
标题: 多线程的创建问题????
为什么用Runnable 接口创建线程 ,建立了一个对象,能跑起来多条线程呢???而Thread 类建立,一个对象只能跑一条线程.
作者: 赵家阳    时间: 2013-4-2 00:57
  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. }

  28. class Threadd1 extends Thread{
  29.         public void run(){
  30.                 System.out.println("Thread,线程要运行的代码");
  31.         }
  32. }

  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的构造函数，开启一个线程，只不过，这样就很麻烦。

作者: 谢达    时间: 2013-4-2 09:29
Runnable是待执行的任务，Thread 负责执行任务, 自然一个Thread对象一次就只能执行一个Runnable，而一个任务却可以给多个Thread对象执行
作者: 吴林飞    时间: 2013-4-2 11:35
以下是我的理解，看代码：
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();        }
}

作者: 黄玉昆    时间: 2013-4-5 08:20
如果仍有问题，请继续追问，如果问题已解决，请将分类改为已解决，谢谢



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2