线程创建方式

一、继承Thread类，重写run方法

public class MyThread1 extends Thread {
    @Override
    public void run() {
        String threadName = super.getName();
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
                System.out.println(threadName + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public MyThread1(String name) {
        super(name);
    }
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1("第一个线程");
        myThread1.start();
        MyThread1 myThread2 = new MyThread1("第二个线程");
        myThread2.start();
    }
}

二、实现Runnable接口，实现run方法

public class MyThread2 implements Runnable {
    public String name;

    public MyThread2(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
                System.out.println(name + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyThread2("第一个线程"));
        thread1.start();
        Thread thread2 = new Thread(new MyThread2("第二个线程"));
        thread2.start();
    }
}

实现Runnable接口相比第一种继承Thread类的方式，使用了面向接口，将任务与线程进行分离，有利于解耦

三、匿名内部类的方式

public class MyThread3 {
    public static void main(String[] args) {
        //方式1：Thread作为匿名内部类
        new Thread(){
            @Override
            public void run() {
                System.out.println("匿名类方式创建线程1");
            }
        }.start();

        //方式2:Runnable作为匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名类方式创建线程2");
            }
        }).start();
    }
}

• 上面的匿名内部类可以用Lambda（基于jdk1.8）表示

public class MyThread3 {
    public static void main(String[] args) {
        //方式1：Thread作为匿名内部类
        new Thread(() -> System.out.println("匿名类方式创建线程1")).start();

        //方式2:Runnable作为匿名内部类
        new Thread(() -> System.out.println("匿名类方式创建线程2")).start();
    }
}

四、实现Callable接口，实现call方法，call返回值为接口的泛型V

public class MyThread4 implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("正在执行新建线程任务");
        Thread.sleep(2000);
        return "新建线程睡了2s后返回执行结果";
    }

    public static void main(String[] args) {
        try {
            FutureTask<String> task = new FutureTask<>(new MyThread4());
            Thread t = new Thread(task);
            t.start();
            System.out.println("提前完成任务...");
            String result = task.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

五、线程池创建线程

• 统一管理线程，降低了创建线程和销毁线程的时间开销和资源浪费

public class MyThread5 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        executorService.shutdown();
    }
}