线程 - 多线程的创建与线程回调Callable - 《Java 学习笔记》

创建线程有几种方式？
创建线程的方式其实只有一种就是通过Thread类来创建的只是传的参数不同
对于实现Runable接口和实现Callable接口是无法通过实现类来直接创建线程的
通过实现类对象来调用对应的重写方法也是没有办法启动线程的这个方法会被当做普通方法来使用
只有通过Thread类中start方法才能启动一个线程

什么情况下用多线程？

如果想要在同一时间内做更多的事情是可以考虑使用多线程来提高效率的
就比如看视频视频的播放和声音的调节就用到了多线程
不可能因为调节声音而导致视频播放停止
所以在某些场景下合理使用多线程能帮助我们高效的处理事情

串行更快还是并行更快？（是不是多线程效率就一定会很高）
这个不确定需要看每个线程需要消耗多少资源
因为创建线程需要消耗资源切换线程也需要消耗资源
所以如果消耗的资源比较少那串行（单线程）可能会更快

继承Thread和实现Runnable来构造Thread有什么区别？
从结果上来讲没有区别一样的
但是 java是单继承的如果继承了Thead就不能继承别的了
所以继承是很宝贵的实现是很容易的

Runable接口和Callable接口的区别
Runable接口中是run方法无返回值不可以抛异常
Callable接口中是call方法有返回值可以抛异常

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

public static void main(String[] args) {
    MyCall myCall = new MyCall(100000000);
    FutureTask<Long> future = new FutureTask<Long>(myCall);
    //FutureTask类实现了Runable接口 所以能传入Thread中
    Thread thread = new Thread(future);
    thread.start();
    long a = future.get();
        //get方法可以获取返回值  但该方法会阻塞 直到线程执行完拿到结果
    System.out.println("A:" + a);
}
public class MyCall implements Callable<Long> {
    //返回值类型对应接口的泛型 如果不写默认是Object
    private int target;
    public MyCall(int target) {
        this.target = target;
    }
    //拓展
    //对于int类型的计算 返回结果要为long类型的
    //因为计算结果可能会超过int的范围 那么此次得到的结果就会有误
    @Override
    public Long call() throws Exception {
        long result = 0;
        for (int i = 0 ; i <= target ; i ++) {
            result += i;
        }
        return result;
    }
}

为什么实现了Callable方法就能拿到返回值了？

我们在实现Callable接口后不能直接通过实现类传递给Thread来创建线程
还需要通过一个中间类进行转换也就是FutureTask这个类
先将Callable实现类传递给FutureTask来创建一个FutureTask对象

然后再将FutureTask对象传递给Thread来创建线程
而FutureTask这个类实现了Runnable接口且重写了run方法
所以Thread执行的是FutureTask中的run方法
其中 FutureTask 的run方法中执行了我们传入的Callable实现类的call方法
然后将call方法的返回值存到存在outcome对象里（Object类型的）等待被get
get方法如果outcome为空就等待如果不为空就将值返回
所以如果调用了get方法会阻塞

简单仿写一个FutureTask的代码

import java.util.concurrent.Callable;
public class MyFuture<T> implements Runnable{
    private Object outcome;
    private Callable<T> callable;
    public MyFuture(Callable<T> callable){
        this.callable = callable;
    }
    @Override
    public void run() {
        try {
            outcome = callable.call();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public T get(){
        while (true){
            if (outcome!=null){
                return (T)outcome;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

FutureTask的细节

public class TestMain{
    public static void main(String[] args) throws Exception {
        MyCall myCall = new MyCall(100000000);
        FutureTask<Long> futureA = new FutureTask<Long>(myCall);
        Thread threadA = new Thread(futureA);
        threadA.start();
        long a = futureA.get();
        //get方法会阻塞 直到线程执行完 拿到结果
        //所以此时根本没有达到多线程的效果
        //因为程序执行到这里后 get方法只能拿到返回值 后续代码才会执行
        System.out.println("A:" + a);
        FutureTask<Long> futureB = new FutureTask<Long>(myCall);
        Thread threadB = new Thread(futureB);
        threadB.start();
        long b = futureB.get();
        System.out.println("B:" + b);
        //所以要想实现多线程取值 那么需要将取值放在最后
//        long a = futureA.get();
//        System.out.println("A:" + a);
//        long b = futureB.get();
//        System.out.println("B:" + b);
    }
}
class MyCall implements Callable<Long> {
    //返回值类型对应接口的泛型 如果不写默认是Object
    private int target;
    public MyCall(int target) {
        this.target = target;
    }
    //拓展
    //对于int类型的计算 返回结果要为long类型的
    //因为计算结果可能会超过int的范围 那么此次得到的结果就会有误
    @Override
    public Long call() throws Exception {
        long result = 0;
        for (int i = 0 ; i <= target ; i ++) {
            result += i;
        }
        return result;
    }
}