多线程p3

//本节内容为静态代理和线程状态，其中穿插一下lambda表达式

静态代理

代理：让别人帮忙做一些事情

代理模式(Proxy)：为其他对象提供一个代理以控制对这个对象的访问

情景

​ 假如你是一个明星，你只负责唱歌，别人要邀请你去唱歌，不是直接找你叫你来唱歌，而是会找到你的助理，此时你的助理会帮你处理时间、地点、费用等之类的问题，让你可以专注于唱歌本身。在这个情景中，你就是目标对象，助理就是代理对象

特点

​ 静态代理是一种设计模式，要求目标对象和代理对象实现同一接口方法，代理对象中持有目标对象的引用，代理对象中的核心功能由目标对象实现，代理对象负责增强功能部分。

注意:在静态代理中，同一接口起到对目标对象和代理对象的约定和规范作用、在不修改目标对象的功能上，增强其功能。静态代理只适合业务功能不变的情况下！！！

public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();//创建目标对象
        WeddingCompany weddingCompany = new WeddingCompany(you);//给代理对象传入一个目标对象
        weddingCompany.HappyMarry();
    }
}
//接口Marry起到定义代理对象和真实对象共同遵循的规范的作用。
//静态代理接口
interface Marry{
    public void HappyMarry();
}

//真实对象(目标对象)
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("我要结婚啦");
    }
}

//代理对象
class WeddingCompany implements Marry{
    //帮助谁处理事物
    You target;

    public WeddingCompany(You 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("结完婚，收尾款");
    }
}

代码案例出自狂神说https://www.bilibili.com/video/BV1V4411p7EF/?spm_id_from=333.999.0.0&vd_source=f285b177e34b2abd450b1cfb6413ae96

lambda表达式

定义

函数式接口：只有一个抽象方法的接口

对于函数式接口，可以通过lambda来创捷该接口的对象

Object 变量名 = (参数) -> {执行语句}; 
变量名.函数式接口方法();

演化过程

实现类 —> 静态内部类 —> 局部内部类 —> 匿名内部类 —> lambda表达式

创建线程使用lambda表达式

Thread thread = new Thread(()->{
	System.out.println("通过lambda表达式，简化语句");
});

线程状态

• 新建状态：线程一旦创建就进入New状态
• 就绪状态：当调用线程的start()方法，线程立即进入就绪状态，但不意味着立即执行，此时还需等cpu调度
• 运行状态：进入运行状态，线程才真正执行线程代码块
• 阻塞状态：当调用sleep()、wait()等方法时，线程进入阻塞状态，就是该线程的代码块不再往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度使用
• 死亡状态：线程中断或者结束，进入死亡状态。一旦线程进入死亡状态，就不能再次启动。

线程状态演示

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("线程被执行");//进入运行状态，线程才真正执行线程体的代码块
        });//创建一个线程

        //观测状态
        Thread.State state = thread.getState();
        System.out.println(state);//线程一旦创建就进入了New状态


        thread.start();
        //启动线程后观测线程状态
        state = thread.getState();
        System.out.println(state);//当调用start()方法后，线程立即进入就绪状态，但不代表立即调度执行，还需等待cpu调度
        
        //只要线程不终止，就一直输出状态
        while (state != Thread.State.TERMINATED){
            Thread.sleep(500);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

线程方法

方法	说明
void sleep()	让当前正在执行的线程体休眠指定的毫秒数(1000ms = 1s)
void yield()	礼让线程，当前正在执行的线程，放弃cpu资源，进入就绪状态和其他线程一起等待cpu调度
void join()	等待该线程终止
void currentThread()	返回当前正在执行的线程的引用
void getName()	返回此线程的名称
void start()	启动线程，JVM调用此线程的run()方法
void stop()	强制停止该线程(不推荐使用)

方法案例

1.sleep()

/**
 *      本节为为线程休眠内容
 *   sleep(时间)指定当前线程阻塞的毫秒数；
 *   sleep存在异常InterruptedException
 *   sleep时间达到后线程进入就绪状态
 *   sleep可以模拟网络延时，倒计时等
 *   每一个对象都有一把锁，sleep不会释放锁
 * */

//模拟网络延时：放大问题的发生性
public class TestSleep implements Runnable{
    int ticketNum = 20;
    @Override
    public void run() {
        while (true){
            System.out.println(Thread.currentThread().getName() + "抢到了第" + ticketNum-- + "张票");
            if (ticketNum <= 0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        //多个线程操作一个对象不安全
        TestSleep testSleep = new TestSleep();
        new Thread(testSleep,"小王").start();
        new Thread(testSleep,"小李").start();
        new Thread(testSleep,"小张").start();
    }
}

2.倒计时

//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) {
/*        try {
            tenDown();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }*/

        //打印当前时间---每秒获取系统时间并打印
        Date currentDate = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(currentDate));
                currentDate = new Date(System.currentTimeMillis()); //更新系统时间
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }


    }
    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
         Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0){
                break;
            }
        }
    }

}

2.yield():调用该方法后，该线程让出cpu资源，从运行状态进入到就绪状态，等待cpu调度，礼让成不成功看cpu心情

/**
 *      本节为线程礼让内容
 *   礼让(让出)线程，让当前正在执行的线程暂停，但不阻塞，线程从运行状态转为就绪状态
 *      线程a和线程b又在同一起跑线上，等待cpu调度
 *   cpu重新调度，礼让不一定成功！看cpu心情
 *   此结果为礼让成功
 *      a开始执行
 *      b开始执行
 *      a结束执行
 *      b结束执行
 *   此结果为礼让失败
 *      a开始执行
 *      a结束执行
 *      b开始执行
 *      b结束执行
 *
 * */
public class TestYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"结束执行");
    }

    public static void main(String[] args) {
        TestYield testYield = new TestYield();
        new Thread(testYield,"a").start();
        new Thread(testYield,"b").start();
    }
}

3.join() 一般用于主线程等待子线程的终止。主线程中调用到子线程的join()方法，此时执行子线程，主线程等待子线程执行完毕在执行。可以简单的理解为插队

• cpu调用主线程生成并启动子线程，但是子线程需要进行大量耗时的计算，此时主线程往往会比子线程先执行完。如果此时主线程需要用到子线程的处理结果，也就是主线程需要在子线程结束后才能结束，这个时候就是要用到join()方法

/**
 *      本节为测试线程的join方法
 *   Join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
 *   可以想象为插队
 * */
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip来了"+ i);
        }
        System.out.println();
    }

    public static void main(String[] args) throws InterruptedException {
        //创建子线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        //主线程
        for (int i = 1; i <= 200; i++) {
            if (i == 100){
                thread.join();
            }
            System.out.println("main" + i);
        }
    }
}