多线程08：深度剖析Thread类，静态代理

静态代理：

代理，大家应该都不陌生，就是我帮你去做一些事情。比如说，结婚。

现在结婚，大家都去找婚庆公司，谁结婚啊，是不是你结婚啊。你结婚，但是你，你什么都不用去做，婚庆公司帮你。帮你布置现场，帮你去把所有人招过来。帮你选地址，给你布置场景，等等。反正是它帮你做的。

最后，结婚的人是你，你就是一个真实角色。

结婚呢，结婚是你们两都要去做的事情。

 

用代码给大家说一下什么叫代理模式：

思路：

你：真实角色

婚庆公司：代理角色，帮你处理结婚的事

结婚：都实现结婚的接口即可

package com.thread.proxystatic;

public class StaticProxy {
    public static void main(String[] args) {
        //用婚庆公司去结婚，婚庆公司调用了一个方法，叫HappyMarry()，但是结婚的人是你，
        //并没有通过你去直接调，而是通过婚庆公司，它代理你去结婚，但是结婚的人还是你
        //new WeddingCompany(new You()).HappyMarry();
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

interface Marry {
    //人间四大喜事:
    //久旱逢甘露，
    //他乡遇故知。
    //洞房花烛夜，
    //金榜题名时。
    public abstract void HappyMarry();
}

//真实角色，你去结婚
class You implements Marry {

    @Override
    public void HappyMarry() {
        System.out.println("你要结婚了，超级开心");
    }
}

//代理角色，帮助你结婚
class WeddingCompany implements Marry {
    //代理谁-->真实角色
    private Marry target;//创建一个变量，通过构造方法把真实对象传进去

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

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这是真实对象，调用一个结婚
        after();
    }

    private void before() {
        System.out.println("结婚之前，布置婚礼现场");
    }

    private void after() {
        System.out.println("结婚之后，收尾款");
    }


}

结果：
结婚之前，布置婚礼现场
你要结婚了，超级开心
结婚之后，收尾款

静态代理总结：

1. 真实对象(目标对象)和代理对象都要实现同一个接口
2. 代理对象要代理真实角色，真实角色就是你
3. 代理对象必须要有个参数，创建一个变量，通过构造方法， 把真实对象传进去
4. 传进去后，调用HappyMarry()这个方法。
5. 于是乎，你们就结婚了
6. 结婚用不着你干，你只要把你交给婚庆公司，你只要花钱。
7. 婚庆公司呢，结婚之前布置一下现场。结婚之后呢，收一下尾款。

好处：

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

 

静态代理对比Thread

Thread就相当于婚庆公司，代理中间的真实的一个Runnable接口，调用了一个start()，start()是Thread类弄的，他们都有一个共同的run()

婚庆公司WeddingCompany，代理你You，你调用了一个结婚方法HappyMarry(),结婚方法是接口中的

new Thread(()-> System.out.println("我爱你")).start();
new WeddingCompany(new You()).HappyMarry();