Java进阶之多线程：Callable接口 + 静态代理

学习狂神的第三天

Java进阶之多线程：Callable接口 + 静态代理

---

---

前言

众所周知，多线程有三种方法可以实现。我们今天学习第三种，Callable接口实现。

---

一、Callable接口

Callable接口与Runnable类似，但是要注意的是，callable接口需要返回参数，并且抛出异常。而Runnable不用。

二、使用步骤

1.创建线程

step1：创建一个Callable接口的实现类，需要返回值类型（Boolean等）
step2：重写call方法，注意：需要抛出异常
step3：创建目标对象
step4：创建执行服务
step5：提交执行
step6：获取结果
step7：关闭服务

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.apache.commons.io.FileUtils;

public class Thread5 implements Callable<Boolean>{
    private String url;     // 地址
    private String name;    // 保存的文件名

    public Thread5(String url,String name)
    {
        this.url = url;
        this.name = name;
        
    }
    public Boolean call()
    {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downloader(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }
    
    public static void main(String[] args) throws InterruptedException, ExecutionException
    {
        Thread5 t1 = new Thread5("https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/04/09/kuangstudy7f75f7f2-1a87-43a1-9d7d-ab8855b6a981.png","1.jpg");
        Thread5 t2 = new Thread5("https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/04/09/kuangstudy7f75f7f2-1a87-43a1-9d7d-ab8855b6a981.png","2.jpg");
        Thread5 t3 = new Thread5("https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/04/09/kuangstudy7f75f7f2-1a87-43a1-9d7d-ab8855b6a981.png","3.jpg");
        
        // 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        // 提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        // 获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        // 返回值
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        // 关闭服务
        ser.shutdown();
    }
}

// 下载器
class WebDownLoader
{
    public void downloader(String url,String name)
    {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
            } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

2.结果

---

静态代理

介绍

如何理解这里的静态代理呢？
这里狂神举了个例子：婚庆公司
你要结婚，但是你有点懒，或者你还有其他事情要做，所以自己忙不过来
要将结婚这件事情安排给婚庆公司，自己只需要到场就行了。
这里，你自己就是真实对象。
而婚庆公司则是代理对象。

步骤

1.定义一个接口及其实现类；
2.创建一个代理类同样实现这个接口
3.将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。
这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

public class StaticProxy {
    public static void main(String[] args){
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

interface Marry{

    void HappyMarry();

}

// 真实对象
class You implements Marry{

    @Override
    public void HappyMarry() {
        // TODO Auto-generated method stub
        System.out.println("秦老师要结婚了，超开心");
    }
}

// 代理对象
class WeddingCompany implements Marry{

    private Marry target;

    public WeddingCompany(Marry target){
        this.target = target;
    }

    public void HappyMarry()
    {
        before();
        this.target.HappyMarry();
        after();
    }

    private void before(){
        System.out.println("婚礼开始");
    }

    private void after(){
        System.out.println("婚礼结束");
    }

}

结果

总结

1.真实对象要和代理对象都要实现同一个接口
2.代理对象要代理真实角色
好处：
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情