“21天好习惯”第一期-15

21天养成好习惯_第十五天

今天继续学习Java的多线程方面的知识

静态代理模式

静态代理模式: 百度词条

代理模式的优点：

被代理类只需要专注于自己的核心代码即可，剩下的交给代理类就可以了，使得代码更加简洁，分工明确

实例

package Thread_Study.ThreadDome1;

public class StaticProxy {

    public static void main(String[] args) {
        You you = new You();
        new Thread( ()-> System.out.println("我爱你") ).start();

        new WeddingCompany(new You()).HappyMarry();
    }
}


interface Marry{
    //先创建一个接口
    void HappyMarry();
}

class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("BUPALAOYE 要结婚了..");
    }
}

//代理角色
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("结婚之后...");
    }


}

运行结果:

小总结

简单来说就是特意用一个类包装一个接口,
对于这个类来说只在乎接口是不是匹配,而不要求是同一个类
便于多态的实现…
并且代理对象可以利用不同对象的接口做同一种操作, 极大得便利了程序员的工作

线程方法

线程的这些方法并没有什么特别的地方 可能比较难理解的方法是join方法

参考资料: join()方法

实例:

package Thread_Study.ThreadDome1;


//join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：
//程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕
//所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会
public class TestJoin implements Runnable{


    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP : " + Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动我们的子线程(vip)
        TestJoin testJoin = new TestJoin();
         Thread thread1 =  new Thread(testJoin," aaa " );
         thread1.start();

         //主线程
        for (int i = 0; i < 500; i++) {
            if(i == 200){
                thread1.join();//main函数等待thread1运行完, 同步进度
            }
            System.out.println("main : "+i );
        }
    }
}

运行结果:(中途等待thread1运行完)

利用标志位让线程停止

package Thread_Study.ThreadDome1;

//让线程停止
//1.建议线程正常停止--->利用次数,不建议死循环
//2.建议使用标志位---->设置一个标志位
//3.不要用stop或destroy等过时, jdk不建议使用的方法(有划线的)
public class TestStop implements Runnable{

    //1.设置一个标志位
    private boolean flag = true ;
    @Override
    public void run() {
        int i = 0;
        while (flag ){
            System.out.println("Running.... Thread : " + i++);
        }
    }

    //2.设置一个公开的方法停止线程,转化标志位
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {
//            System.out.println("main : " + i);
            if (i == 900){
                //调用stop方法切换标志位,让线程停止
                testStop.stop();
                System.out.println("线程停止...");
            }
        }
    }
}

运行结果: