java实现多线程的有甚么方法

Java实现多线程的方法有以下几种：
1. 继承Thread类：创建一个继承自Thread类的子类，并重写run方法，通过调用start方法启动线程。
```java
class MyThread extends Thread {
public void run() {
// 线程履行的代码
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
```
2. 实现Runnable接口：创建一个实现了Runnable接口的类，并实现run方法，通过创建Thread对象并将其作为参数传递，然后调用start方法启动线程。
```java
class MyRunnable implements Runnable {
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：创建一个实现了Callable接口的类，并实现call方法，通过创建ExecutorService线程池对象，调用submit方法提交任务并返回Future对象，通过调用Future对象的get方法获得线程履行结果。
```java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
class MyCallable implements Callable {
public Integer call() {
// 线程履行的代码
return 0;
}
}
public class Main {
public static void main(String[] args) {
MyCallable callable = new MyCallable();
ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(callable);
try {
Integer result = future.get();
System.out.println(result);
} catch (Exception e) {
e.printStackTrace();
}
executor.shutdown();
}
}
```
4. 使用线程池：创建一个ExecutorService线程池对象，通过调用execute方法提交任务，线程池会自动管理线程的创建和烧毁。
```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
executor.execute(new Runnable() {
public void run() {
// 线程履行的代码
}
});
}
executor.shutdown();
}
}
```