传统线程机制的回顾

创建线程的两种传统方式
1、在Thread子类覆盖的run方法中编写运行代码
2、在传递给Thread对象的Runnable对象的run方法中编写代码

  总结：查看Thread类的run()方法的源代码，可以看到其实这两种方式都是在调用Thread对象的run方法，如果Thread类的run方法没有被覆盖，并且为该Thread对象设置了一个Runnable对象，该run方法会调用Runnable对象的run方法。
问题：如果在Thread子类覆盖的run方法中编写了运行代码，也为Thread子类对象传递了一个Runnable对象，那么，线程运行时的执行代码是子类的run方法的代码？还是Runnable对象的run方法的代码：调用子类的。

package cn.itcast.thread;

public class TraditionalThread {
    /**
     *
     * @param args
     */
    public static void main(String []args){
        /*
         * 如果在Thread子类覆盖的run方法中编写了运行代码，也为Thread子类对象传递了一个Runnable对象，
         * 那么，线程运行时的执行代码是子类的run方法的代码？还是Runnable对象的run方法的代码？
         * 调用子类的方法
         * new Thread(
                new Runnable(){
                    public void run(){
                        while(true){
                            try {
                                Thread.sleep(2000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println(Thread.currentThread().getName());

                        }
                    }
                }
        )
        {
            @Override
            public void run(){
                while(true){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //System.out.println(Thread.currentThread().getName());
                    System.out.println("子类："+this.getName());
                }
            }
        }.start();*/

        new Thread(){
            @Override
            public void run(){
                while(true){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //System.out.println(Thread.currentThread().getName());

                    System.out.println("子类："+this.getName());
                }
            }
        }.start();

        /*
         * 一个是线程，一个是线程所要运行的代码，
         * 更加面向对象，推荐用这种
         */
        new Thread(new Runnable(){
            public void run(){
                while(true){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("实现Runnable:"+Thread.currentThread().getName());
                    //System.out.println(this.getName());这里不能用this,这里this指代Runnable对象是线程的宿主，

                    //不是线程

                }
            }
        }).start();
        System.out.println("Thread.currentThread().getName()就是获得当前所有线程的名字："+Thread.currentThread().getName());
    }
}

输出：
Thread.currentThread().getName()就是获得当前所有线程的名字：main
子类：Thread-0
实现Runnable:Thread-1
子类：Thread-0
实现Runnable:Thread-1