线程简介2——理解什么是静态代理和真实对象，了解lamda表达式，线程状态和线程停止及线程休眠

线程简介

静态代理

• 静态代理：就是一个真实对象实现的事情使用其他的类去实现，并且将那个类称作代理。
• 静态代理中的代理和真实对象都需要继承同一个接口，并且都需要对接口中的方法进行重写。

  • 使用结婚这件事作为对象探讨什么是代理，什么是真实对象

    1. 去结婚的这个人，就是新郎或者新娘就是真实对象，结婚这件事情是由他们两个去实现的
    2. 在新人的结婚过程中，婚礼前后的布置可以交付给婚庆公司，让婚庆公司帮助你去实现结婚这个事情，婚庆公司就是代理。

  • 使用代码示例来对结婚中的代理和真实对象进行解释。

package com.XianCheng.StaticProxy;
//使用结婚来探讨什么是静态代理和真实对象
//静态代理和真实对象都需要对接口中的方法进行重写
public class StaticProxy {

    public static void main(String[] args) {
        //创建一个代理的对象，并且将目标对象传递给代理
        MarryProxy marryProxy = new MarryProxy(new getMarried());
        marryProxy.Marry();

    }
}
//真实对象，真正的实现这件事的对象，再这是新郎，是一个单独的类
//同时真实对象只需要实现结婚这个事情，其他的事情交由代理对象实现
class getMarried implements StaticProxyInterface{
    @Override
    public void Marry() {
        System.out.println("你要结婚了，新郎不是我！");
    }
}

//代理对象
class MarryProxy implements StaticProxyInterface{
    private getMarried tar;

    public MarryProxy(getMarried tar) {
        this.tar = tar;
    }

    @Override
    public void Marry() {
        //结婚前工作，有代理进行
        befor();
        //结婚，直接调用真实对象执行
        this.tar.Marry();
        //结婚后工作，代理进行
        after();
    }

    private void after() {
        System.out.println("婚后");
    }

    private void befor() {
        System.out.println("婚前");
    }
}

lamda表达式实现接口

• 使用lamda表达式必须要求接口是函数式接口，即接口中只有一个方法需要实现。
• 任何接口，如果他定义了一个抽象方法那么他就是函数式接口。
• 通过代码理解接口实现的一步步简化

package com.XianCheng.lamda;
//用于体现接口实现的一步步简化，将展现接口的实现是如何转变为lamda表达式
public class Lamda {
    //2.静态内部类实现接口
    static class two implements Love{
        @Override
        public void Love() {
            System.out.println("我是静态内部类的接口实现");
        }
    }
    public static void main(String[] args) {
        //3.局部内部类
        class three implements Love{
            @Override
            public void Love() {
                System.out.println("我是局部内部类的接口实现");
            }
        }
        //通过接口实例化对象
        Love love=new first();
        love.Love();
        Love love1=new two();
        love1.Love();
        Love love2=new three();
        love2.Love();
        //4. 匿名内部类的接口实现
        Love love3=new Love() {
            @Override
            public void Love() {
                System.out.println("我是匿名内部类的接口实现");
            }
        };
        love3.Love();
        //5.使用lamda表达式实现接口
        Love love4=()->{
            System.out.println("我是最完整的lamda表达式的实现方式");
        };
        love4.Love();
        //但实现接口只需要一行代码时，lamda表达式可以简写为一行
        Love love5=()-> System.out.println("我是最简单的lamda表达式");
        love5.Love();
        //带参类型的接口实现使用lamda表达式
        Man man=a -> System.out.println("我是带参的lamda表达式的最简"+a);
        man.man(2);
        //带多个参数的接口实现的lamda表达式的最简
        Woman woman=(a,b)-> System.out.println("我是带多个参数的lamda表达式"+a+b);
        woman.woman(1,2);

    }

}

// 创建一个接口，只能有一个方法。
interface Love{
    void Love();
}
//1. 最原始的接口实现
class first implements Love{
    @Override
    public void Love() {
        System.out.println("我是最原始的接口实现");
    }
}
interface Man{
    void man(int a);
}
interface Woman{
    void woman(int a,int b);
}

线程状态

• 话不多说直接上图：
  

线程停止：

• 通过给线程设置标志位，改变标志位的真假值来停止线程。
  • 直接代码：

package com.XianCheng;
//通过标志位控制线程的停止
public class ThreadStop implements Runnable {
    //设置标志位的值
    private Boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("线程还没有停，我是第"+i++ );
        }
    }
    //设置外部停止方法
    public  void STOP(){
        this.flag=false;
    }

    public static void main(String[] args) {
        //创建线程对象
        ThreadStop threadStop = new ThreadStop();
        //创建线程
        new Thread(threadStop).start();
        for (int i = 0; i < 500; i++) {
            System.out.println("main"+i);
           if (i==200){
                threadStop.STOP();//改变标志位
                System.out.println("该线程停止了");
            }
        }

    }
}

线程休眠——sleep

• sleep能够使线程到达当前状态后进入就绪状态，等待时间到达后进入活动状态。
• 代码又来了：

package com.XianCheng.sleep;

import java.text.SimpleDateFormat;
import java.util.Date;

//使用Sleep模拟倒计时
public class Sleep {

    public static void TenDown() throws InterruptedException {
        int i=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(i--);
            if (i<=0){
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TenDown();
        //获取字体系统当前时间
        Date date = new Date(System.currentTimeMillis());//获取系统当前实现
        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            //更新时间
            date = new Date(System.currentTimeMillis());
        }
    }

}