Java--多线程--静态代理模式、lambda表达式、线程停止、线程休眠、线程礼让、线程强制执行

Java–多线程–静态代理模式、lambda表达式、线程停止、线程休眠、线程礼让、线程强制执行

静态代理模式

package com.zy.thread;

/**
 *description: Java--多线程--静态代理模式
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-21 21:14
 */
public class StaticProxy {

    /*
    静态代理模式：
        真实对象和代理对象都要实现同一个接口；
        代理对象要代理真实对象。
        代理对象可以做很多真实对象做不了的事；
        真实对象就专注做自己的事。
     */

    public static void main(String[] args) {

        new WeddingCompany(new Marrier()).marry();

    }
}

interface Marry{
    void marry();
}

/**
 * @Description 真实角色：结婚的人
 * @author zy
 * @date 2023-3-21 21:16
 */
class Marrier implements Marry{

    @Override
    public void marry() {
        System.out.println("要结婚啦，超开心！！！");
    }
}

/**
 * @Description 代理角色：婚庆公司
 * @author zy
 * @date 2023-3-21 21:17
 */
class WeddingCompany implements Marry{

    private Marry marrier;

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

    @Override
    public void marry() {
        before();
        // 真实目标对象
        marrier.marry();
        after();
    }

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

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

lambda表达式

package com.zy.thread;

/**
 *description: Java--lambda表达式--推导lambda表达式
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-21 21:35
 */
public class StudyLambda {

    // 3.静态内部类
    static class LambdaTwoImpl implements Lambda{

        @Override
        public void lambda() {
            System.out.println("学习lambda2表达式λ");
        }
    }

    public static void main(String[] args) {

        new LambdaOneImpl().lambda();

        new LambdaTwoImpl().lambda();

        // 4.局部内部类
        class LambdaThreeImpl implements Lambda{

            @Override
            public void lambda() {
                System.out.println("学习lambda3表达式λ");
            }
        }

        new LambdaThreeImpl().lambda();

        // 5.匿名内部类：没有类的名称，必须借助接口或者父类
        new Lambda(){
            @Override
            public void lambda() {
                System.out.println("学习lambda4表达式λ");
            }
        }.lambda();

        // 6.JDK8：lambda表达式简化
        Lambda lambda = ()-> System.out.println("学习lambda5表达式λ");
        lambda.lambda();
    }
}

// 1.定义一个函数式接口：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
interface Lambda{
    void lambda();
}

// 2.实现类
class LambdaOneImpl implements Lambda{

    @Override
    public void lambda() {
        System.out.println("学习lambda表达式λ");
    }
}

线程停止

package com.zy.thread;

/**
 *description: Java--多线程--线程停止
 * 1.建议线程正常停止：利用次数，不建议死循环
 * 2.建议使用标志位：设置一个标志位
 * 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-21 22:18
 */
public class StudyThreadStop implements Runnable {

    // 1.设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i=0;
        while (flag){
            i++;
            System.out.println("线程运行---》"+i);
        }
    }

    // 2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        StudyThreadStop threadStop = new StudyThreadStop();
        new Thread(threadStop).start();

        for (int i = 0; i < 6666278; i++) {
            if(i == 6666277){
                // 调用自定义stop方法切换标志位停止线程
                threadStop.stop();
                System.out.println("线程停止---》"+i);
            }
        }
    }
}

线程休眠

package com.zy.thread;

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

/**
 *description: Java--多线程--线程休眠
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-21 22:35
 */
public class StudyThreadSleep {

    /*
    每个对象都有一个锁，sleep不会释放锁
     */

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

    public static void main(String[] args) {
        try {
            // 倒计时
            tenDown();
            // 打印当前系统时间
            Date startTime = new Date(System.currentTimeMillis());
            while (true){
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                // 更新当前时间
                startTime = new Date(System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程礼让

package com.zy.thread;

/**
 *description: Java--多线程--线程礼让
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-21 22:45
 */
public class StudyThreadYield {

    /*
    礼让线程，让当前正在执行的线程暂停，但不阻塞；
    将线程从运行状态转为就绪状态；
    让cpu重新调度，礼让不一定成功，看cpu调度
     */

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

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"==>线程开始运行");
        // 线程礼让
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"==>线程停止运行");
    }
}

线程强制执行

package com.zy.thread;

/**
 *description: Java--多线程--线程强制执行
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-21 22:53
 */
public class StudyThreadJoin implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 启动线程
        Thread thread = new Thread(new StudyThreadJoin());
        thread.start();

        // 主线程
        for (int i = 0; i < 500; i++) {
            if(i == 200){
                // 插队：强制执行，阻塞其它线程
                thread.join();
            }
            System.out.println("主线程运行"+i);
        }
    }
}