创建线程的几种方式总结

创建线程的方式

1.继承Thread

创建继承Thread的方法

package com.example.threadTest01;

public class ExThread extends Thread {

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

启动线程测试：

package com.example.threadTest01;

public class ExThreadTest {
    public static void main(String[] args) {
        new ExThread().start();
    }
}

2.实现Runnable接口

2.1 实现Runnable接口的实现类

package com.example.threadTest01;

public class ImRunnable implements Runnable {

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

相应的测试:

package com.example.threadTest01;

public class ImRunnableTest {

    public static void main(String[] args) {
        new Thread(new ImRunnable()).start();
    }
}

2.2 匿名内部类的方式

package com.example.threadTest01;

/**
 * 匿名内部类的方式
 */
public class ThreadTest01 {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();
    }
}

2.3 使用lambda表达式

package com.example.threadTest01;

public class LambdaTest {

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        }).start();
    }
}

2.4 使用线程池

package com.example.threadTest01;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolTest {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName());
        });
        executorService.shutdown();
    }
}

匿名内部类，lambda表达式，ExecutorService线程池这三种我的理解为可以是实现Runnable接口创建线程的一种方式，本质都是实现Runnable接口的run()方法。

3.实现callable接口

创建callable接口的实现类，并实现call方法，结合FutureTask类包装Callable对象，实现多线程
优点：有返回值，拓展性也高
缺点： jdk5以后才支持，需要重写call方法，结合多个类比如FutureTask和Thread类

import java.util.concurrent.Callable;

public class MyTask implements Callable<Object> {
    @Override
    public Object call() throws Exception {

        System.out.println("通过Callable实现多线程，名称："+Thread.currentThread().getName());

        return "这是返回值";
    }
}

public static void main(String[] args) {
    MyTask myTask = new MyTask();
    FutureTask<Object> futureTask = new FutureTask<>(myTask);
  
    // FutureTask继承了Runnable接口，可以放在Thread中启动执行
    Thread thread = new Thread(futureTask);
    thread.setName("taskDemo");
    thread.start();
    System.out.println("主线程名称："+Thread.currentThread().getName());
    
    try {
        System.out.println(futureTask.get());
    } catch (InterruptedException e) {
        // 阻塞等待中被中断，则抛出
        e.printStackTrace();
    } catch (ExecutionException e) {
        // 执行过程发送异常被抛出  
        e.printStackTrace();
    }
}

4.通过线程池

自定义Runnable接口，实现run方法，创建线程池，调用执⾏方法并传入对象
优点：安全高性能，复用线程
缺点: jdk5后才支持，需要结合Runnable进行使用

public class ImRunnableTest {
    public static void main(String[] args) {
        new Thread(new ImRunnable()).start();
    }
}

public static void main(String[] args) {
    
    ExecutorService executorService1 = Executors.newFixedThreadPool(5);
    executorService1.execute(new ImRunnable());
    System.out.println("主线程名称："+Thread.currentThread().getName());
    // 关闭线程池
    executorService1.shutdown();
}

## 上面创建线程的地方加个循环做测试
for (int i = 0; i < 12; i++) {
    executorService1.execute(new ImRunnable());
}

运行结果：

Runnable接口实现类，线程名：pool-1-thread-2
Runnable接口实现类，线程名：pool-1-thread-5
主线程名称：main
Runnable接口实现类，线程名：pool-1-thread-4
Runnable接口实现类，线程名：pool-1-thread-1
Runnable接口实现类，线程名：pool-1-thread-3
Runnable接口实现类，线程名：pool-1-thread-1
Runnable接口实现类，线程名：pool-1-thread-4
Runnable接口实现类，线程名：pool-1-thread-5
Runnable接口实现类，线程名：pool-1-thread-2
Runnable接口实现类，线程名：pool-1-thread-4
Runnable接口实现类，线程名：pool-1-thread-1
Runnable接口实现类，线程名：pool-1-thread-3

Process finished with exit code 0

如有不对，请大家指出共同学习。