文章目录
- 线程创建方式1——Thread
- 线程创建方式2——Runnable
- 线程创建方式2——匿名内部类
- 线程创建方式3——Callable、FutureTask,带返回值
线程其实是程序中的一条执行路径。
那怎样的程序才是多线程程序呢？ 例如12306网站就是支持多线程的，因为同时可以有很多人一起进入网站购票，而且每一个人互不影响。再比如百度网盘，可以同时下载或者上传多个文件。这些程序中其实就有多条执行路径，每一条执行执行路径就是一条线程，所以这样的程序就是多线程程序。下面会逐一介绍三种常见的线程创建方式。
线程创建方式1——Thread
Java为开发者提供了一个类叫做Thread，此类的对象用来表示线程。创建线程并执行线程的步骤如下
1.定义一个子类继承Thread类，并重写run方法
2.创建Thread的子类对象
3.调用start方法启动线程（启动线程后，会自动执行run方法中的代码）
public class MyThread extends Thread{
// 2、必须重写Thread类的run方法
@Override
public void run() {
// 描述线程的执行任务。
for (int i = 1; i <= 5; i++) {
System.out.println("子线程MyThread输出：" + i);
}
}
}
再定义一个测试类，在测试类中创建MyThread线程对象，并启动线程
public class ThreadTest1 {
// main方法是由一条默认的主线程负责执行。
public static void main(String[] args) {
// 3、创建MyThread线程类的对象代表一个线程
Thread t = new MyThread();
// 4、启动线程（自动执行run方法的）
t.start();
for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出：" + i);
}
}
}
打印结果如下图所示，我们会发现MyThread和main线程在相互抢夺CPU的执行权（注意：哪一个线程先执行，哪一个线程后执行，目前我们是无法控制的，每次输出结果都会不一样）
最后我们还需要注意一点：不能直接去调用run方法，如果直接调用run方法就不认为是一条线程启动了，而是把Thread当做一个普通对象，此时run方法中的执行的代码会成为主线程的一部分。此时执行结果是这样的。
线程创建方式2——Runnable
Java为开发者提供了一个Runnable接口，该接口中只有一个run方法，意思就是通过Runnable接口的实现类对象专门来表示线程要执行的任务。具体步骤如下
1.先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
2.再创建一个Runnable实现类的对象
3.创建一个Thread对象，把Runnable实现类的对象传递给Thread
4.调用Thread对象的start()方法启动线程（启动后会自动执行Runnable里面的run方法）
代码如下：先准备一个Runnable接口的实现类
/**
* 1、定义一个任务类，实现Runnable接口
*/
public class MyRunnable implements Runnable{
// 2、重写runnable的run方法
@Override
public void run() {
// 线程要执行的任务。
for (int i = 1; i <= 5; i++) {
System.out.println("子线程输出 ===》" + i);
}
}
}
再写一个测试类，在测试类中创建线程对象，并执行线程
public class ThreadTest2 {
public static void main(String[] args) {
// 3、创建任务对象。
Runnable target = new MyRunnable();
// 4、把任务对象交给一个线程对象处理。
// public Thread(Runnable target)
new Thread(target).start();
for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出 ===》" + i);
}
}
}
运行上面代码，结果如下图所示**（注意：没有出现下面交替执行的效果，也是正常的）**
线程创建方式2——匿名内部类
这种写法不是新知识，只是换一种写法。刚刚我们的第二种线程的创建方式，需要写一个Runnable接口的实现类，然后再把Runnable实现类的对象传递给Thread对象。
现在如果不想写Runnable实现类，于是可以直接创建Runnable接口的匿名内部类对象，传递给Thread对象。
代码如下
public class ThreadTest2_2 {
public static void main(String[] args) {
// 1、直接创建Runnable接口的匿名内部类形式（任务对象）
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程1输出：" + i);
}
}
};
new Thread(target).start();
// 简化形式1：
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程2输出：" + i);
}
}
}).start();
// 简化形式2：
new Thread(() -> {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程3输出：" + i);
}
}).start();
for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出：" + i);
}
}
}
线程创建方式3——Callable、FutureTask,带返回值
已经有两种了为什么还有要第三种呢？ 这样，我们先分析一下前面两种都存在的一个问题。然后再引出第三种可以解决这个问题。
-
假设线程执行完毕之后有一些数据需要返回，前面两种方式重写的run方法均没有返回结果。
public void run(){ ...线程执行的代码... } -
JDK5提供了Callable接口和FutureTask类来创建线程，它最大的优点就是有返回值。
在Callable接口中有一个call方法，重写call方法就是线程要执行的代码，它是有返回值的
第三种创建线程的方式，步骤如下
1.先定义一个Callable接口的实现类，重写call方法
2.创建Callable实现类的对象
3.创建FutureTask类的对象，将Callable对象传递给FutureTask
4.创建Thread对象，将Future对象传递给Thread
5.调用Thread的start()方法启动线程(启动后会自动执行call方法)
等call()方法执行完之后，会自动将返回值结果封装到FutrueTask对象中
6.调用FutrueTask对的get()方法获取返回结果
代码如下：先准备一个Callable接口的实现类
class MyCallable implements Callable<Integer >{
public int target;
public MyCallable(int s){
target =s;
}
@Override
public Integer call() throws Exception {
int sum=0;
for(int i=0;i<=target;i++){
sum+=i;
}
return sum;
}
}
再定义一个测试类，在测试类中创建线程并启动线程，还要获取返回结果。
public class test_thread2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer>call=new MyCallable(100);
FutureTask<Integer>f1=new FutureTask<>(call);
new Thread(f1).start();
Callable<Integer>call1=new MyCallable(200);
FutureTask<Integer>f2=new FutureTask<>(call1);
new Thread(f2).start();
int res1 = f1.get();
System.out.println(res1);
int res2=f2.get();
System.out.println(res2);
}
}
