多线程的创建_没有操作系统创建多线程-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_59855900/article/details/136758851

什么是线程?

线程(Thread)是一个程序内部的一条执行流程。

程序中如果只有一条执行流程，那这个程序就是单线程的程序。

多线程是什么?

多线程是指从软硬件上实现的多条执行流程的技术(多条线程由CPU负责调度执行)

消息通信、12306、网盘、淘宝、京东系统都离不开多线程技术。

如何在程序中创建出多条线程? Java是通过java.lang.Thread 类的对象来代表线程的。

多线程的创建方式一:继承Thread类

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

/**
 * 目标：掌握线程的创建方式1：继承Thread类
 */
public static void main(String[] args) {
        //3.必须创建一个（MyThread）线程类的对象才能代表一个线程
        Thread t = new MyThread();//多态写法
        //4.启动线程（自动执行run方法的）
        t.start();// main线程 t线程
        //主线程
        for (int i = 1; i <=5 ; i++) {
            System.out.println("主线程main线程输出：" + i);
        }

    }

/**
 * 1.让子类继承Thread线程类
 */
public class MyThread extends Thread{
    //2必须重写Thread类的run方法
    @Override
    public void run() {
    //描述线程的执行任务
        for (int i = 1; i <=5 ; i++) {
            System.out.println("MyThread子线程输出：" + i);
        }
    }
}

方式一优缺点:

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

多线程的注意事项
1、启动线程必须是调用start方法，不是调用run方法。（线程对象当作普通的Java对象来调run方法，会导致永远是run方法里面代码先执行完，再执行后面的，相当于执行单线程；start方法其实是向我们的操作系统主要是向cpu去注册线程类的对象作为一个单独的执行流程，cpu就会知道把t这个线程对象当作一个单独的执行流程来执行，最终注册之后cpu调度的时候还是会执行run方法的。start意义不一样是向操作系统向cpu注册这个线程，而调run方法只是会把他当作一个普通的对象，没有实行多线程。）
2、不要把主线程任务放在启动子线程之前。

多线程的创建方式二:实现Runnable接口

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

方式二的优缺点：

优点:任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强
缺点:需要多一个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);
        }
    }
}

/**
 * 掌握多线程的创建方式2：实现Runnable接口
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        //3.创建任务对象
        Runnable target = new MyRunnable();
        //new MyRunnable()就会得到线程的任务对象，将其交个任务类型的变量
        //注意：任务对象是没有start方法的，是属于线程对象独有的
        //4.把任务对象交给一个线程对象来处理，相当于得到一个线程来处理任务对象
        // public Thread(Runnable target)
        new Thread(target).start();

        for (int i = 1; i < 5; i++) {
            System.out.println( "主线程输出 --->" + i);
        }
    }
}

线程创建方式二的匿名内部类写法

可以创建Runnable的匿名内部类对象。
再交给Thread线程对象。
再调用线程对象的start()启动线程。

/**
 * 目标：掌握多线程创建方式二的匿名内部类写法
 */
public class ThreadTest2_2 {
    public static void main(String[] args) {
        //1.直接创建Runnable接口的匿名内部类形式（任务对象）
        //Runnable是接口不能直接new他的对象要用匿名内部类形式
        //Runnable接口的匿名内部类形式不光是一个匿名内部类同时也是一个对象，代表的就是线程的任务对象
        Runnable target = new Runnable() {//Runnable是函数式接口意味着匿名内部类形式可以用Lambda表达式进行简化
            @Override
            public void run() {
                //任务对象里边就要描述一下干什么事情
                for (int i = 1; i < 5; i++) {
                    System.out.println( "子线程1输出 --->" + i);
                }
            }
        };
        //接着要创建线程对象,再把任务对象交给线程对象来处理，然后启动线程
        new Thread(target).start();//一旦线程启动就会去找任务对象里的run方法来执行

        //简化形式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( "主线程输出 --->" + i);
        }
    }
}

多线程的创建方式三:实现Callable接口

前两种线程创建方式都存在的一个问题

假如线程执行完毕后有一些数据需要返回，他们重写的run方法均不能直接返回结果

怎么解决这个问题?

JDK 5.0提供了Callable接口和FutureTask类来实现(多线程的第三种创建方式)
这种方式最大的优点:可以返回线程执行完毕后的结果

多线程的第三种创建方式:利用Callable接口、FutureTask类来实现。

创建任务对象（①定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据②把Callable类型的对象封装成FutureTask(线程任务对象)）
把线程任务对象交给Thread对象。
调用Thread对象的start方法启动线程，
线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。

线程创建方式三的优缺点

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

import java.util.concurrent.Callable;

/**
 * 1.让这个类实现Callable接口
 */
public class MyCallable implements Callable<String> {
    private int n;//定义一个成员变量

    //通过有参构造器把这个n的值接进来
    public MyCallable(int n) {
        this.n = n;
    }

    //2.重写call方法
    @Override
    public String call() throws Exception {
        //描述线程的任务，返回线程执行返回后的结果
        //需求：求1-n的和
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "线程求出了1-" + n + "的和是：" + sum;
    }
}

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

/**
 * 目标：掌握线程的创建方式3：实现Callable接口
 */
public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        //3.需要创建一个Callable的对象（不是任务对象不能直接把他直接交给线程对象）
        Callable<String> call =  new MyCallable(100);//传给Callable类型的变量
        //4.需要把Callable对象封装成FutureTask对象——》才是任务对象
        // 未来任务对象的作用?
        // 1、是一个任务对象，实现了Runnable对象
        // 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。
        FutureTask<String> f1 = new FutureTask<>(call);
        //5.把任务对象交给Thread线程对象
        new Thread(f1).start();

        Callable<String> call2 =  new MyCallable(200);//传给Callable类型的变量
        FutureTask<String> f2 = new FutureTask<>(call2);
        new Thread(f2).start();


        //6、获取线程执行完毕后返回的结果。
        // 注意:如果执行到这儿，假如上面的线程还没有执行完毕
        // 这里的代码会暂停，等待上面线程执行完毕后才会获取结果。
        System.out.println(f1.get());
        System.out.println(f2.get());

    }
}