【多线程】三种实现方案

目录

1.多线程中的并发和并行概念

2.多线程中的进程和线程概念

3.多线程的实现方案

3.1.方式1:继承Thread类的方式进行实现：

3.2.方式2:实现Runnable接口

3.3.方式3：Callble和Future（可以获取返回结果）

---

14天阅读挑战赛
努力是为了不平庸~

1.多线程中的并发和并行概念

并行：在同一时间，有多个指令在多个CPU上同时执行

并发：在同一时刻，有多个指令在单个CPU上交替执行

2.多线程中的进程和线程概念

进程:是正在运行的软件

独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位

动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的

并发性：任何进程都可以同其他进程一起并发执行

--------------------------------------------------------------------------------------------------------------------------

线程：是进程中的单个顺序控制流，是一条执行路径

单线程:一个线程如果只有一条执行路径，则称为单线程程序

多线程：一个线程如果有多条执行路径，则称为多线程程序

3.多线程的实现方案

3.1.方式1:继承Thread类的方式进行实现：

3.1.1.定义一个MyThread继承Thread类

3.1.2.在MyThread类中重写run()方法

3.1.3.创建MyThread类对象

3.1.4.启动线程

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("MyThread线程方法执行" + i);
        }
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

3.1.5.执行结果：

问题：

3.1.6.为什么要重写run()方法？

因为run()是用来封装被线程执行的代码。

3.1.7.run()方法和start()的区别

run()：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程

start()：启动线程；然后由JVM调用此线程的run()方法

3.2.方式2:实现Runnable接口

定义一个类MyRunnable实现Runnable接口

在MyRunnable类中重写run()方法

创建MyRunnable类的对象

创建Thread类的对象，把MyRunnable对象作为构造方法的参数

启动线程

public class MyRunnable implements Runnable{
    @Override
    public void run() {
for (int i=0;i<10;i++){
    System.out.println("线程方法执行"+i);
}
    }
    public static void main(String[] args) {
        //创建了一个参数对象
        MyRunnable myRunnable = new MyRunnable();
        //创建了一个线程对象，并把参数传递给这个线程
        //在线程启动后，执行的就是参数里面的run方法
        Thread thread = new Thread(myRunnable);
        //run方法
        thread.start();
    }
}

运行结果：

 

3.3.方式3：Callble和Future（可以获取返回结果）

定义一个类MyCallable实现Callable接口

在MyCallable类中重写call()方法

创建MyCallable类的对象

创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

创建Thread类的对象，把FutureTask对象作为构造方法的参数

启动线程

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
for (int i=0;i<100;i++){
    System.out.println("MyCallable运行次数"+i);
}
        //返回值就是表示线程运行之后的结果
        return "你好";
    }

    public static void main(String[] args) {
        //线程开启之后需要执行里面的call方法
        MyCallable myCallable = new MyCallable();
        //可以获取线程执行完毕之后的结果，也可以作为参数传递给Thread对象
        FutureTask<String> futureTask = new FutureTask<String>(myCallable);
        //创建线程对象
        Thread thread = new Thread(futureTask);
        //开启线程
        thread.start();

        try {
            //获取返回结果
            String s = futureTask.get();
            System.out.println(s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

调用get方法，就可以获取线程结束之后的结果，必须在线程结束之后才能获取否则只能死等线程

以上就是实现线程的三种方案