传统的线程技术

线程并不是java1.5以后的新技术，在（java1.5之前）传统的线程创建有两种方式：1）继承Thread类；2）实现Runnable接口。

1）继承Thread类：

　　　　Thread thread1 = new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                        System.out.println(Thread.currentThread().getId());
                }
            }
        };
        thread1.start();

这种方式是创建Thread的子类，并且覆盖Thread类的run方法。当调用thread的start方法时会执行run方法内的内容。

2）实现Runnable接口：

　　　　　Thread thread2 = new Thread(new Runnable() {    
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            }
        });
        thread2.start();

在查看Thread的源码的时候，发现Thread类的实现源代码会发现Thread类是实现了Runnable接口，其run方式实现如下：

 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

run方法中的target对象在Thread的构造方法中引入：

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
}

所以继承runnable方法调用的也是run方法。

3）线程创建的扩展：

如果将线程子线程同时覆盖run方法和设置runnable参数如下：

　　　　　　Thread thread3 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("runnable"+Thread.currentThread().getName());
                }
            }
        }){

            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("thread"+Thread.currentThread().getName());
                }
            }
            
        };
        thread3.start();

在线程执行中会执行run方法，因为run方法是Thread的子类覆盖父类的方法，于父类run方法没有关系，所有会执行子类的run方法，如果子类没有覆盖父类的run方法，那么就会去执行runnable的run方法。

注意：run方法直接调用并不会创建新的线程，而是在主线程中直接运行run方法，跟普通的方法调用没有任何区别。在实际应用中，实现runnable接口的方式更加常用，因为直接继承Thread类的话，可能比实现Runnable接口看起来更加简洁，但是由于Java只允许单继承，所以如果自定义类需要继承其他类，则只能选择实现Runnable接口。并且实现runnable接口更加符合面向对象编程时思想。