JAVA-多线程

什么是线程？

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

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

多线程是什么？

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

如何在程序中创建出多条线程？

Java是通过java.lang.Thread 类的对象来代表线程的。

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

1、定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

/**
 * 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);
        }
    }
}

2、创建MyThread类的对象

3、调用线程对象的start()方法启动线程（启动后还是执行run方法的）

/**
 * 目标：掌握线程的创建方式一:继承Thread类
 */
public class ThreadTest1 {
    // main方法是由一条默认的主线程负责执行。
    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);
        }
    }
}

 方式一优缺点：

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

多线程的注意事项

1、启动线程必须是调用start方法，不是调用run方法。

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。

只有调用start方法才是启动一个新的线程执行。

2、不要把主线程任务放在启动子线程之前。

这样主线程一直是先跑完的，相当于是一个单线程的效果了。

方式二：实现Runnable接口

1、定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

2、创建MyRunnable任务对象

3、把MyRunnable任务对象交给Thread处理。

4、调用线程对象的start()方法启动线程

/**
 * 目标：掌握多线程的创建方式二：实现Runnable接口。
 */
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);
        }
    }
}

方式二的优缺点

优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。

缺点：需要多一个Runnable对象。

方式三：利用Callable接口、FutureTask类来实现。

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

如何解决

JDK 5.0提供了Callable接口和FutureTask类来实现（多线程的第三种创建方式）。

这种方式最大的优点：可以返回线程执行完毕后的结果。

1、创建任务对象

1.1、定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。

1.2、把Callable类型的对象封装成FutureTask（线程任务对象）。

2、把线程任务对象交给Thread对象。

3、调用Thread对象的start方法启动线程。

4、线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。

FutureTask的API

/**
 * 目标：掌握线程的创建方式三：实现Callable接口。
 */
public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        // 3、创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        // 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);
        FutureTask<String> f2  = new FutureTask<>(call2);
        new Thread(f2).start();


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

        String rs2 = f2.get();
        System.out.println(rs2);
    }
}

 

线程创建方式三的优缺点：

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。

缺点：编码复杂一点。

总结：