线程的静态代理和join

//静态代理总结：真实对象和代理对象都要实现同一个接口，
//代理对象要代理真实对象
//好处：代理对象可以做很多真实对象做不了的事情
package Test;

public class TestStaticProxy {
    public static void main(String[] args) {

        new Thread(()-> System.out.println("线程")).start();
        new MyZyj(new Zyj()).goodRest();
//        MyZyj myZyj=new MyZyj(new Zyj());
//        myZyj.goodRest();
    }
}

interface Rest{
    void goodRest();
}

//真实角色
class Zyj implements Rest{
    @Override
    public void goodRest() {
        System.out.println("zyj is resting");
    }
}

//代理角色,帮助真实角色做事情
class MyZyj implements Rest{

    //真实目标角色
    private Rest target;

    public MyZyj(Rest target) {
        this.target=target;
    }

    @Override
    public void goodRest() {
        time();
        this.target.goodRest();
        could();
    }

    public void time(){
        System.out.println("enough time to have a rest");
    }

    public void could(){
        System.out.println("times up");
    }
}

package Test;

//测试join方法，想象成插队
public class Testjoin implements Runnable{

    //线程体
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i==10){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("test join");
        }
    }

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

        //启动我们的线程
        Testjoin testjoin=new Testjoin();
        Thread thread=new Thread(testjoin);


        thread.start();
        //主线程
        for (int i = 0; i < 500; i++) {

            if(i==180) {
                thread.join();
            }
            System.out.println("main thread is running "+i);
        }
    }
}