创建多线程的几种方式(java实现多线程的几种方式)

1.方式一:继承Thread类

1.1流程:1.2优缺点:1.3代码:1.4运行结果: 2.方式二:实现Runnable接口

2.1流程:2.2优缺点:2.3代码:2.4运行结果: 3.方式三:实现Callable接口

3.1流程:3.2优缺点:3.2代码:3.4运行结果:

1.定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法.
2.创建MyThread类的对象
3.调用线程对象的start()方法启动线程.

1.优点:编码简单
2.缺点:线程类已经继承Thread，无法继承其他类，不利于扩展。

public class ThreadDemo01 {
    public static void main(String[] args) {
//        3.创建线程对象
        Thread th = new MyThread();
        th.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }
}

//1.定义一个线程类继承Thread类
class MyThread extends Thread {
//    2.重写run方法,定义线程行为

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出:"+i);
        }
    }
}

1.定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
2.创建MyRunnable任务对象
3.把MyRunnable任务对象交给Thread处理。
4.调用线程对象的start()方法启动线程

1.优点:线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
2.缺点:编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

public class ThreadDemo02 {
    public static void main(String[] args) {
//        3.创建任务对象
        Runnable target = new MyRunnable();
//        4.把任务对象交给Thread处理
        Thread th = new Thread(target);
//        5.启动线程
        th.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }

}
//1.定义一个线程任务类,实现Runnable接口
class MyRunnable implements Runnable {
//    2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出:"+i);
        }
    }
}

1.得到任务对象:
①定义类实现Callable接口，重写call方法，封装要做的事情。
②用FutureTask把Callable对象封装成线程任务对象。
2.把线程任务对象交给Thread处理。
3.调用Thread的start方法启动线程，执行任务
4.线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

1.优点:
①线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
②可以在线程执行完毕后去获取线程执行的结果。
2.缺点:编码复杂

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        3.创建任务对象
        Callable call = new MyCallable(100);
//        4.把callable任务对象交给FutureTask对象
        //FutureTask对象的作用1:是Runnable的对象,实现了Runnable接口,可以传递给Thread对象
        //FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask f1 = new FutureTask<>(call);
//        5.交给线程处理
        Thread th1 = new Thread(f1);
        th1.start();
        String rs1 = f1.get();
        System.out.println("线程1结果:"+rs1);


//        线程2
        Callable call2 = new MyCallable(200);
        FutureTask f2 = new FutureTask<>(call2);
        Thread th2 = new Thread(f2);
        th2.start();
        String rs2 = f2.get();
        System.out.println("线程2结果:"+rs2);

        //线程3
        Callable call3 = new MyCallable(50);
        FutureTask f3 = new FutureTask<>(call3);
        Thread th3 = new Thread(f3);
        th3.start();
        String rs3 = f3.get();

        System.out.println("线程3结果:"+rs3);



    }

}
//1.定义一个任务类,实现Callable接口,声明线程任务执行完毕后的结果数据类型
class MyCallable implements Callable{
    private int n;
    public MyCallable(int n){
        this.n = n;
    }
//    2.重写call方法
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0;i 
3.4运行结果: