JavaThread 04 Callable&&静态代理模式

2.1 Callable&&静态代理模式

---

2.1.1 Callable 接口 的实现

1. 实现 Callable 接口，需要有 返回值类型
2. 重写 里面的 call 方法，还需要 抛出 异常
3. 创建 目标对象
4. 创建 执行服务：ExecutorService ser = Executors.newFixedThreadPool(线程的数目);//用 Executors 创建一个新的线程池
5. 提交执行：Future result1 =ser.submit(t1);
6. 获取结果：boolean r1 = result1.get();
7. 关闭服务：ser.shutdownNow()；

这个接口非常的严谨，所以很复杂。多了个 开启服务 和 关闭 服务。

package www.muquanyu.leeson02;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.*;

public class CallableDemo implements Callable<Boolean> {

    private URL url;
    private File fileName;

    public CallableDemo(String url,String String) throws MalformedURLException {
        this.url = new URL(url);
        this.fileName = new File(String);
    }
    @Override
    public Boolean call() throws Exception {

        //这个事务的任务 就是 下载图片呗
        FileUtils.copyURLToFile(url, fileName);
        System.out.println(fileName+"-->已被下载完毕！");

        return true;
    }

    public static void main(String[] args) throws MalformedURLException, ExecutionException, InterruptedException {

        CallableDemo c1 = new CallableDemo("https://i0.hdslb.com/bfs/sycp/creative_img/202107/aaf812b9efe50634c04b16725d93e88c.jpg@880w_388h_1c_95q", "4.jpg");
        CallableDemo c2 = new CallableDemo("https://i0.hdslb.com/bfs/sycp/creative_img/202107/aaf812b9efe50634c04b16725d93e88c.jpg@880w_388h_1c_95q", "5.jpg");
        CallableDemo c3 = new CallableDemo("https://i0.hdslb.com/bfs/sycp/creative_img/202107/aaf812b9efe50634c04b16725d93e88c.jpg@880w_388h_1c_95q", "6.jpg");

        //其实线程池 并不是 用 这个 玩意 来创建的
        /*线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
  允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
  允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。*/

        ExecutorService ser = Executors.newFixedThreadPool(3);

        //提交这些事务 并且 执行
        Future<Boolean> r1 = ser.submit(c1);
        Future<Boolean> r2 = ser.submit(c2);
        Future<Boolean> r3 = ser.submit(c3);

        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

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

---

2.1.2 静态代理模式

1. 静态代理

什么叫代理呀，就是我帮你 做一些事情，这就叫代理。

• 你：是个真实的角色（真实对象）
• 婚庆公司：代理你，帮你处理结婚的很多事情，当然不包括 洞房。
• 结婚：都实现结婚接口即可。

• 先举个 静态代理的 例子

package www.muquanyu.leeson02;

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

//全局普通类（接口）

interface Marry{
    //基本上结婚的人，就是 负责洞房花烛夜！
    public void HappyMarry();
}

class You implements Marry{

    @Override
    public void HappyMarry(){
        System.out.println("我正在快乐的 洞房花烛夜！");
    }
}

class Proxy implements Marry{
    private Marry target;
    
    public Proxy(Marry target)
    {
        this.target = target;
    }
    
    @Override
    public void HappyMarry(){
        before();
        this.target.HappyMarry();
        after();
    }

    public void before()
    {
        System.out.println("为你婚前布置！");
    }

    public void after()
    {
        System.out.println("提醒你收尾款");
    }

}

理解和分析：

1. 你和代理都需要 去做一个大事情，那就 结婚。
2. 但是你俩对于结婚这个大事，做的小事情 还不一样。
3. 你自己 是 需要在 结婚这个大事情的基础下，进行洞房花烛夜和享受的。
4. 代理 是 需要在 结婚这个大事情的基础下，帮你布置前奏和后奏的尾款处理。
5. 而 这个 代理，也就是 你找来的代理。它处理的 事情 都是 你 结婚 这个 大事 里面的 小事情。这就是 静态代理。

代理的好处：

1. 代理对象可以坐很多真实对象做不了的事情。
2. 真实对象就可以 专注于 做 自己的事情了。