java 创建线程的四种方式

1、继承Thread类方式

这种方式适用于执行特定任务,并且需要获取处理后的数据的场景。

举例:一个用于累加数组内数据的和的线程。

public class AdditionThread extends Thread {

private int sum = 0;

private int[] nums;

public AdditionThread(int[] nums, String threadName) {

super(threadName);

this.nums = nums;

}

@Override

public void run() {

for (int num : nums) {

sum += num;

}

}

public int getSum() {

return sum;

}

}

调用方式:

public class Main {

public static void main(String[] args) throws InterruptedException {

int[] nums = {10, 12, 15, 200, 100};

AdditionThread thread = new AdditionThread(nums, "AdditionThread");

thread.start();

thread.join();

System.out.println("sum=" + thread.getSum());

}

}

2、Runnable 接口方式

定义一个实现Runnable接口的类,或者直接创建一个匿名内部类,并覆盖 run() 方法。最后作为参数传给Thread的构造函数。

public class Main {

public static void main(String[] args) {

// 自定义的 Runnable

Runnable runnable = new MyRunnable();

Thread thread = new Thread(runnable, "Runnable-Thread");

thread.start();

// 自定义匿名内部类

new Thread(() -> {

System.out.println("Inner class");

}).start();

}

static class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println("MyRunnable");

}

}

}

3、 Callable 接口方式

Callable 接口与 Runnable 接口的区别:

(1)Callable 的方法为call(),Runnable的方法为run()。

(2)Callable 的方法由返回值,Runnable 没有。

(3)Callable 的方法声明的Exception,Runnable的没有。

public class Main {

public static void main(String[] args) {

MyCallable myCallable = new MyCallable();

FutureTask<String> task = new FutureTask<>(myCallable);

Thread thread = new Thread(task, "FutureTask");

thread.start();

try {

// 通过get方法获取返回值

String result = task.get();

System.out.println(result);

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

}

static class MyCallable implements Callable<String> {

@Override

public String call() throws Exception {

// 模拟超时操作

Thread.sleep(1000);

return "OK";

}

}

}

4、线程池方式

我们可以通过 ThreadPoolExecutor 类的构造函数来创建线程池,也可以通过Executors工厂方法来创建,如

// 创建固定线程数的线程池

Executors.newFixedThreadPool();

// 创建只有一个核心线程的线程池

Executors.newSingleThreadExecutor();

// 创建一个没有核心线程,但可以缓存线程的线程池

Executors.newCachedThreadPool();

// 创建一个适用于执行定时任务的线程池

Executors.newScheduledThreadPool();

在创建线程池时,最好传入 ThreadFactory 参数,指定线程池所创建线程的名称。这样有利于分析定位可能存在的问题。

public class Main {

private static final ExecutorService SERVICE =

Executors.newFixedThreadPool(5, new BasicThreadFactory("My-Thread"));

public static void main(String[] args) {

// 打印线程的名字

System.out.println("main thread name:" + Thread.currentThread().getName());

SERVICE.execute(() -> {

System.out.println("Hello thread pool.");

// 打印线程池里的线程的名字

System.out.println("thread name:" + Thread.currentThread().getName());

});

}

static class BasicThreadFactory implements ThreadFactory {

private final AtomicInteger threadNumber = new AtomicInteger(0);

private final String basicName;

public BasicThreadFactory(String basicName) {

this.basicName = basicName;

}

@Override

public Thread newThread(Runnable runnable) {

Thread thread = new Thread(runnable);

String name = this.basicName + "-" + threadNumber.incrementAndGet();

thread.setName(name);

return thread;

}

}

}

以上是 java 创建线程的四种方式 的全部内容, 来源链接: utcz.com/z/335792.html

回到顶部