Java基础-创建线程的三种方法及其对比

1.继承Thread类

1）定义Thread类的子类，并重写run方法，run方法就是线程要执行的任务，将其称为执行体。

2）创建Thread类子类的对象，即创建了线程对象。

3）调用线程对象的start()方法来启动该线程。

public class MyThread extends Thread {
    
    public MyThread(){}

    // set name
    public MyThread(String name){
        super(name);
    }

    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}

2.创建实现runnable接口的类对象

1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

3）调用线程对象的start()方法来启动该线程

   与Thread方法相比较，1）Runnable方法更加灵活，避免了单继承的局限性：Thread方法不能继承其他类。实现Runnable接口后，还可以继续继承其他类

　　　　　　　　　　　2）增强了程序的扩展性，降低了程序的耦合性：实现了设置线程任务和开启线程进行了分离(解耦)，实现类中，重写了run方法

　　　　　　　　　　　3）如果要访问当前线程，则必须使用Thread.currentThread()方法，而继承方法只需要使用this方法即可访问当前线程

class RunnableImpl implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 20; i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

public class Test04 {
    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        Thread t = new Thread(run);
        t.start();

        for (int i = 0;i < 20;i++){
            System.out.println(Thread.currentThread().getName() + "-->"+i);
        }
    }
}

3.匿名内部类实现创建Thread

　　此处使用匿名内部类主要作用是简化代码，将子类继承父类重写方法，创建子类对象，合并为一步完成。

　　JDK1.8发布以后，可以用lambda表达式代替内部类达到简化代码的目的

public class InnerClassThread {
    public static void main(String[] args) {

        // InnerClass implement
        new Thread(){
            @Override
            public void run(){
                for (int i=0; i < 20;i++){
                    System.out.println(Thread.currentThread().getName()+"-->"+"Ben");
                }
            }
        }.start();

        Runnable r = new Runnable() { // Polymorphism
            @Override
            public void run() {
                for (int i = 0;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"-->"+"Allen");
                }
            }
        };
        new Thread(r).start();

        // InnerClass implement use interface Runnable
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 20;i++){
                    System.out.println(Thread.currentThread().getName() + "-->"+"Amy");
                }
            }
        }).start();
        
        // Lambda Implements
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "-->"+"Bob");
        }).start();
    }
}