java中创建线程的方式

java中创建线程的方式
以Java中创建线程的方式为标题，我们来探讨一下在Java中如何创建线程。

在Java中，创建线程的方式有两种：一种是继承Thread类，另一种是实现Runnable接口。

1. 继承Thread类
继承Thread类是最简单的创建线程的方式。

我们只需要定义一个继承自Thread类的子类，并重写run()方法，在run()方法中编写线程要执行的代码。

然后，创建该子类的实例，并调用start()方法来启动线程。

下面是一个简单的例子：
```
public class MyThread extends Thread {
@Override
public void run() {
// 线程要执行的代码
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
```
2. 实现Runnable接口
实现Runnable接口是另一种创建线程的方式。

我们需要定义一个实现了Runnable接口的类，并实现接口中的run()方法。

然后，创建该类的实例，并将其作为参数传递给Thread类的构造方法。

最后，调用Thread类的start()方法来启动线程。

下面是一个简单的例子：
```
public class MyRunnable implements Runnable {
@Override
public void run() {
// 线程要执行的代码
}
}
public class Main {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
}
}
```
3. Callable和Future
除了继承Thread类和实现Runnable接口的方式，Java还提供了Callable和Future接口来创建线程。

Callable接口类似于Runnable接口，但是它可以返回一个结果，并且可以抛出一个异常。

而Future接口可以用来获取Callable接口的返回值。

下面是一个简单的例子：
```
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
// 线程要执行的代码
return 1;
}
}
public class Main {
public static void main(String[] args) {
MyCallable callable = new MyCallable();
FutureTask<Integer> futureTask = new FutureT ask<>(callable);
Thread thread = new Thread(futureT ask);
thread.start();
try {
int result = futureTask.get();
System.out.println("线程的返回值为：" + result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
```
通过使用Callable和Future，我们可以在创建线程的同时获取线程的返回值。

总结：
在Java中，创建线程的方式有继承Thread类、实现Runnable接口以及使用Callable和Future。

这些方式各有特点，可以根据具体的需求选择合适的方式来创建线程。

无论哪种方式，都需要重写run()方法，并在其中编写线程要执行的代码。

通过调用start()方法来启动线程，线程会自动执行run()方法中的代码。

另外，通过Callable和Future可以获取线程的返回值。

希望本文能对你理解Java中创建线程的方式有所帮助。