Thread、Runnable和Callable

在Java中，Thread、Runnable和Callable是用于实现多线程的三种主要方式。

1. Thread：Thread是Java的一个内置类，用于表示一个线程。当我们直接继承Thread类并覆盖其run()方法时，就可以创建一个新的线程。 

        创建线程的方法：

        （1）创建一个自定义类使用extends继承Thread

          (2)重写run()方法

        （3）创建线程对象，调用start()方法启动线程。

class MyThread extends Thread {
@Override
public void run() {
// 线程执行的代码
}
}

// 线程对象调用start()方法
MyThread myThread = new MyThread();
myThread.start();
 

2. Runnable：Runnable是一个接口，它定义了一个run()方法，当线程开始执行时，run()方法将被调用。与Thread类不同，Runnable不继承Thread类，而是将Runnable接口传递给Thread构造函数。

       创建线程方法：

    （1）创建类实现Runnable接口

      （2） 重写run()方法，编写线程执行的代码

      （3）创建线程对象，启动start()方法

class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的代码
}
}

// 线程对象调用start()方法
Thread thread = new Thread(new MyRunnable());
thread.start();
 

Callable：Callable也是一个接口，与Runnable类似，它定义了一个call()方法，当线程开始执行时，call()方法将被调用。与Runnable不同的是，Callable可以返回结果，并且可以抛出异常。为了获取Callable任务的结果，我们需要使用FutureTask类或者Future和ExecutorService接口。
创建线程方法：
方式一：FutureTask类
（1）创建类实现Callable接口，需要返回值类型

（2）重写call()方法，编写线程执行的代码

（3）创建线程对象

（4）创建Future类，用于处理异步计算

（5）通过调用start（）方法开启线程

（6）通过Future的get()方法获取返回值

方式二：

(1)创建类实现Callable接口，需要返回值类型

（2）重写call（）方法，编写线程执行代码

（3）创建线程对象

（4）创建执行服务：ExecutorService executor=Executors.newFixedThreadPool(1);

(5)提交执行：Future<Integer> future=execotor.submit(new MyCallable())

(6)获取结果：Integer result=future.get();

(7)关闭服务：executor.shutdown();

 

class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
System.out.println(Thread.currentThread() + "正在计算：" + i);
}
return sum;
}
}

// 方式一：
// 准备线程1
MyCallable myCallable1 = new MyCallable();
FutureTask<Integer> futureTask1 = new FutureTask<>(myCallable1);
// 准备线程2
MyCallable myCallable2 = new MyCallable();
FutureTask<Integer> futureTask2 = new FutureTask<>(myCallable2);
// 开启线程1
new Thread(futureTask1).start();
// 开启线程2
new Thread(futureTask2).start();
// 获取返回值
Integer result1 = futureTask1.get();
System.out.println("任务1：" + result1 );
Integer result2 = futureTask2.get();
System.out.println("任务2：" + result2 );

// 方式二：
class MyCallable implements Callable<Integer> {
public Integer call() throws Exception {
// 线程执行的代码
return result;
}
}
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<Integer> future = executor.submit(new MyCallable());
Integer result = future.get(); // 获取任务结果
executor.shutdown();

 

4.还有一种方式，匿名内部类：
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("匿名内部类：" + i);
}
}
}).start();

for (int i = 0; i < 100;i++) {
System.out.println("main：" + i);
}
}