先启动服务端，再启动客户端三、PostMan调用3.1、Websocket在线模拟请求工具访问访问地址：http://www.jsons.cn/websocket/具有进行连接、断开、模拟发送数据等功能。（请求时注意连接格式为 ws://IP或域名:端口（示例 ws://127.0.0.1:8089/websocket/devices） 3.2、Postman使用新版的Postman1、建立 WebSocket 连接在 File–> New 页面，选择 WebSocket Request，即可创建一个 WebSocket 模拟请求。2、模拟数据交互在地址栏中输入相应的 WebSocket 请求地址，点击地址栏右侧的 “Connect” 按钮，即可建立连接。连接建立成功后，在 Message 的信息栏中输入模拟数据，点击 “Send” 按钮，即可与服务端进行数据交互。优势：支持多种数据格式如：Text、JSON、XML、HTML、Binary等；支持对交互信息进行格式化显示如：Text、JSON、XML、HTML等；支持对交互数据进行模糊搜索、筛选过滤、清空等操作；交互数据按照时间倒序显示，更便于查看最新的数据。3、断开 WebSocket 连接如果调试结束，点击地址栏右侧的 “Disconnect” 按钮，即可断开与 WebSocket 服务端的连接————————————————原文链接：https://blog.csdn.net/MinggeQingchun/article/details/142757957

最近在学习dify方面的知识，过程遇到的一些小困难，记录一下。java调用的代码主要参考这个基于 Spring Boot 和 Dify 实现流式响应输出_springboot dify-CSDN博客当然，你可能做点修改如果你直接部署dify，没有进行其他相关配置，那么在通过java调用后，应该会输出以下的内容流式结果：StreamResponse(event=message, id=44f74b98-22bf-43e6-916c-f738e5704d79, task_id=d05f7e19-640c-4292-bb2b-de1681e803cf, message_id=44f74b98-22bf-43e6-916c-f738e5704d79, answer=这是根据您需求生成的文件：[a0277b8185f64150bbecd372b7023c8a.xlsx](/files/tools/28f48078-8dbc-4954-aff2-ec8bc8fd7ded.xlsx?timestamp=1746515049&nonce=da4ed54481aad55f8c8d71afe5b784af&sign=VMiX1jCevCsyCQIt8dSfszA5jJCCX5An9dD3Z6wl8lE=), created_at=1746514907, conversation_id=f41acbdb-54b7-4318-82de-e7d7448928c5, data=null)主要看/files/tools/当我们在dify的页面下载文件时，也就是这时候其他访问的是127.0.0.1:80/files/tools/.....；所以能下载文件，dify默认启动端口就是80，，当用java代码调用时返回的只有/files/tools.....,然后前端点击时，会判断你这个地址正不正确，/files/tools...,没有http://或者https://,也没有端口，此时你点击访问的路径会是你前端的路径+/files/tools，例如http://localhost:1002/files/tools....,所以会访问不到，这时后只要我们修改一下。env文件就行了，找到你安装dify目录的docker目录，里面可以找到.env文件不同版本内容可能有所差异，我的是dify1.3，FILES_URL本来是空的，这里加上dify的路径就行，我是运行在80端口，所以我这里没加端口，如果你修改了运行的端口，这里记得要加上，修改完后在dify的docker目录下命令行执行docker-compose down && docker-compose up -d即可，如果你直接在这里停止又启动，大概率没效果，起码我是没有，所以用上面的命令启动，完成之后再次调用，此时返回的就是http://127.0.0.1/files/tools/......此时我们在自己的页面点击就能下载文件了。当然，获取方式有很多种，这只是其中一种而已。其他的就自行研究了————————————————原文链接：https://blog.csdn.net/qq_58983013/article/details/147740125

前言想象一下，如果你的电脑只能一次执行一个任务，那会是多么的低效。幸运的是，Java提供了一种强大的机制，允许程序同时执行多个任务。这就是我们今天要探讨的主题——Java中的Thread类。目录Thread 类创建线程的方式线程终止一. Thread 类1. Thread 类的初识对于线程的概念， 本身是 操作系统内核提出的概念 。如果要执行并发编程， 就需要掌握不同的系统 api (例如 window 系统api ， Linux 系统api ) 等… 这种 不同系统的api 是不一样的。对于我们 Java程序猿 来说， Java的api 早已分装好 对应的系统api ， 我们这只需要学习 Java的api 即可。而进行并发编程的 Java最重要的api 就是 标准库中 Thread 类 。通过这个类， 我们可以实现对于 线程的创建 ， 以及利用每个线程进行 业务逻辑和任务 的执行。鱼式疯言并且 Thread 是 java.lang 下面的一个库， 是 不需要手动导包 的。二. 创建线程的方式1. 创建线程<1>. 代码展示/** * 创建线程： * 继承 Thread * 重写 run 方法 */public class MyThread extends Thread{    @Override    public void run() {        while (true) {            System.out.println("MyThread的run线程 正在运行...");            try {                MyThread.sleep(10000);            } catch (InterruptedException e) {                throw new RuntimeException(e);            }        }    }    public static void main(String[] args) throws InterruptedException {        MyThread myThread =new MyThread();        // 创建一个线程        myThread.start();        // 主方法        while (true) {            System.out.println("main线程 正在运行...");            MyThread.sleep(10000);        }    }}AI生成项目java运行<2>. 创建流程首先创建一个先 继承Thread 类 ， 并重写 run 方法在 main 方法 中 实例化一个 MyThread 类 。调用start() 方法来 创建线程 ， 并执行run 方法里面的 业务逻辑。鱼式疯言补充总结：由于我们在执行程序时， 系统就会分配资源， 自动创建进程 ， 并且程序是需要 调度执行 ， 所以 main 方法自身就是一个线程： 主线程所以上述过程中， 可以认为 在 主线程 中又 创建了一个线程 。<3>. 逻辑分析run 中写着的是这个线程需要执行的 各种代码逻辑 ， 相当于在 main方法 中的 代码同等含义。虽然在上述代码中 ， 没有直接调用重写 的run 方法 ， 但是当我们调用 start（） 方法后， 在 Java代码中会重新调用我们重写的 run 方法 。如果只是单纯的调用 run 方法 ， 并 不能创建线程 。对于上述过程有两个线程： 主线程 和 myThread ， 都是分布在同一个系统资源下的， 所以需要 并发执行 : 两个死循环都 不会相互制约 ， 各自执行各自的 。 抢占执行: 不能确定是哪个线程先执行到对应的逻辑。鱼式疯言补充细节 ：上诉代码中， 我们用到了 sleep() 方法，这个方法是 Thread 中的静态方法 （类方法） 。 可以让程序 休眠一段时间 ， 调用这个目的： 就是让程序猿好 观察程序的执行过程 。() 内参数 指定的是多少 毫秒（ms） ， 用于 指定休眠多少时间 ， 其中 1000 ms = 1s 换算进制。调用sleep（） 和 创建线程的过程 ， 都是需要 抛出： InterruptedException 这个异常的2. 创建线程的其他方式对于创建线程的方式：除了上述 继承 Thread 重写run方法 之外还有其他常见四种方式实现 Runnable 接口 ， 重写 run 方法；使用 匿名内部类 ， 对 Thread 类 重写 run 方法 ；使用 匿名内部类 ， 实现 Runnable 接口 重写run 方法 ；使用 lambda 表达式 ， 对 匿名内部类 进行简化 。<1>. 实现 Runnable 接口/** * 方法二： * 继承 Runnable * 实现 run 方法 * */class  MyThread1 implements  Runnable {    @Override    public void run() {        while (true) {            System.out.println("Runnable 中run线程 正在运行...");            try {                MyThread.sleep(1000);            } catch (InterruptedException e) {                throw new RuntimeException(e);            }        }    }    public static void main(String[] args) throws InterruptedException {        Thread myThread1 = new Thread(new MyThread1());        myThread1.start();        // 接口        while (true) {            System.out.println("main线程 正在运行");            MyThread.sleep(1000);        }    }}AI生成项目java运行对于这种方式的实现主要的流程还是在实例化Thread 对象之前 ：首先 创建一个类 MyThread1 用于 实现 Runnable 接口重写 run 方法最终 new出对象 MyThread1 作为 Thread（） 的参数 进行传入进行 实例化Thread 对象 即可。后面的过程就和上面相同了， 小编在这里就不赘述了 <2>. 匿名内部类—— 重写 Thread 的 run 方法/** * * 方法四： Thread 的匿名内部类 * 在匿名内部类中重写 Run 方法 * */class  MyThread3 {    public static void main(String[] args) throws InterruptedException {        Thread myThread3 = new Thread(){            @Override            public void run() {                while (true) {                    System.out.println("匿名类 MyThread的run线程 正在运行...");                    try {                        MyThread.sleep(1000);                    } catch (InterruptedException e) {                        throw new RuntimeException(e);                    }                }            }        };        // 创建线程        myThread3.start();        // 输出主线程        while (true) {            System.out.println("main 线程正在运行...");            MyThread.sleep(1000);        }    }}AI生成项目java运行我们知道， 对于 匿名内部类 来说， 是一种不带引用的一种对象， 也就是说当实例化 Thread 类对象 时， 我们使用匿名内部类的方式就是在 Thread () 后面 加上 { } ， 并在{ } 内部 重写 run 方法 。以上就是唯一的区别 ， 其他操作都一样。<3>. 匿名内部类 —— 实现 Runnable 接口的 run 方法 /*** 方法三 : Runnable 的匿名内部类* 在匿名内部类中 实现 Run 方法**/class  MyThread2 {   public static void main(String[] args) {       Thread myThread2 = new Thread(new Runnable() {           @Override           public void run() {               while (true) {                   System.out.println("内部类Runnable 中 Run方法正在执行...");                   try {                       MyThread.sleep(1000);                   } catch (InterruptedException e) {                       throw new RuntimeException(e);                   }               }           }       });       // 创建线程       myThread2.start();       while (true) {           System.out.println("主线程方法正在调用....");           try {               Thread.sleep(1000);           } catch (InterruptedException e) {               throw new RuntimeException(e);           }       }   }}AI生成项目java运行对于 匿名内部类 而已 ， 使用的方式和 上面一种方式相同 ， 而在这里唯一的区别就在于 ， 上面 new 出了 new Runnable 作为参数 进行 传入到 Thread 对象中。而本方式中 ， 则是在 Thread 后面 直接 重写 run 方法 。<4>. 使用 lambda 表达式 简化匿名内部类/** * 方法五：  使用 lambda 表达式简化 匿名内部类 * */ class  MyThread4 {    public static void main(String[] args) throws InterruptedException {        Thread myThread4 = new Thread(()->{            while (true) {                System.out.println("lambda 匿名类 MyThread的run线程 正在运行...");                try {                    MyThread.sleep(1000);                } catch (InterruptedException e) {                    throw new RuntimeException(e);                }            }        });        // 创建线程        myThread4.start();        // 输出主线程        while (true) {            System.out.println("main 线程正在运行...");            MyThread.sleep(1000);        }    }}AI生成项目java运行对于 lambda 表达式 来说，最核心的部分就是 ：把 new Runnable() {} 就是简化成 （）-> {} 来使用， 其实本质上还是通过 匿名内部类 实现 Runnable 接口 的一种 简化版本 。鱼式疯言对于 lambda 表达的使用， 一定要注意一点的是： 必须是 函数式接口 ， 也就是只有 一个抽象方法的接口才能使用 lambda 。对于 start 创建线程 来说， 当调用 start 方法后， 系统内核会生成 PCB 并且添加链表， 创建新的线程。 所以当 多次调用 start 方法 时， 就会抛出异常， 因为对于一个Thread 对象来说， 只能start 一次， 也就是说 只能创建一个线程 ， 这个原因也是为了 JVM 方便管理 ， 否则 一个Thread 对象对应多个线程 就会管理起来很复杂。例如上述过程， 就会 抛出异常 : IllegalThreadStateException上述总共 五种创建线程 的方式， 都是蛮重要的 ， 小伙伴们务必多操练多熟悉里面的 代码流程和逻辑 哦~三. 线程终止1. 线程终止的初识线程终止的方式有很多种终止的方式， 有粗暴的， 也有温柔的 。像粗暴的 ：让 执行到一半的线程 直接终止像温柔的： 让 线程执行完整个任务 才终止对于Java 来说， 我们是下面这种方式， 让 线程执行完所有的任务 才终止。下面就让我们来瞧瞧呗 2. Java线程终止的简易版public class MyThread1 {   public static boolean state = true;    public static void main(String[] args) throws InterruptedException {        Thread t  = new Thread(() -> {            while(state) {                System.out.println("hello Thread1");                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    throw new RuntimeException(e);                }            }        });//        创建线程            t.start();        Thread.sleep(3000);        state = false;    }}AI生成项目java运行对于上述的流程主要是：首先定义一个布尔变量， 用来确定 线程的状态 为 true 线程正在运行， 为 false 线程结束 。其次在主线程中修改 线程状态， 让线程结束。 注意这种结束的方式是让线程中的 任务都执行结束 了 ， 当需要再次执行任务的时候才 置为 false 的 ， 是一种 比较温柔 的做法。鱼式疯言补充细节 ： 入上图， 如果把 布尔类型放在 main 方法的内部呢？其实就会有问题， 这归咎于我们的Java语法中有个小知识点： 变量捕获其实这种变量捕获是对于 lambda 表达式 来说的， 如果要在 lambda 表达式 中使用 同一作用域下的变量 ， 这个变量是 不可以被修改的 。也就是说在上面 的 state = false 出现了 修改 ， 所以 lambda 中就会 编译失败 。那么出现这种问题的比较好的解决方案就是把 这个变量定义为 成员变量 ， 这样 两种的作用域就不相同 了， 也从另外一个角度来看， 内部的方法调用外部的成员 是没有问题的，天经地义的3. Java 自身的线程终止方法class Thread2 {    public static void main(String[] args) {        Thread t = new Thread(() -> {            // 先获取当前线程            Thread currentThread = Thread.currentThread();//            判断线程状态            while(!currentThread.isInterrupted()) {                System.out.println("hello thread1");                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    break;                }            }        });//        创建线程        t.start();        try {            Thread.sleep(3000);        } catch (InterruptedException e) {            throw new RuntimeException(e);        }//        修改线程状态        t.interrupt();    }}AI生成项目java运行上述代码的流程主要分为 以下几步：实例化Thread对象， 在 run方法中 使用 currentThread 方法 来 获取当前线程获取当前线程后 ， 使用 isInterrupted 判断当前线程的状态，自身返回 false 代表 线程正在进行， true 代表 线程结束 。创建线程，并 休眠指定时间 ， 使用 interrupted 来修改 isInterrupted 为 true， 让线程终止。在 try catch{ } 在 catch 中 添加 break ， 直接跳出循环 。4. 代码分析对于上述代码小编还有很多话想和小伙伴们唠唠， 因为我个人觉得还是比较重要的， 小伙伴们可不要嫌我烦哦~ 如果 catch 中不添加 break ，而是按照平常的写法： throw new RuntimeException(e); 直接抛出新的异常呢？情况就会变成这样， 原因很简单， 对于线程执行的时间来说， 大部分时间是处于 sleep 的休眠状态 ， 一旦有 外面的线程来修改线程的状态 ， sleep 就会 被打破休眠的状态 ， 这时就会 抛出异常， 这时被 try catch { } 捕获到 ， 就会执行 throw new RuntimeException(e); 抛出新的异常， 由于这个 异常没有及时处理 ，编译器就会自动交给 JVM 来处理。 所以我们不需要在 catch { } 写 throw new RuntimeException(e);的方法。居然写throw new RuntimeException(e); 会抛出新的异常， 那么 catch 中什么都不写， break 也不写。 会发生什么呢？如上图， 就会出现 即使我们使用 interrupted 来修改， 但是线程还是会继续的情况。其实大家有所不知的是： 对于 休眠方法 sleep 是比较特殊的， 一旦被唤醒， 就会清除 isInterrupted 修改后的 true 状态, 重新还原到 false 状态 ， 这时线程就会 继续执行 了。所以这里如果我们要终止线程的话， 就需要 添加 break 来跳出 。相比小伙伴们还是一头雾水吧 ， 就算理解了也不知道它为啥要这样做吧 ？ ？ ？下面削小编来举个栗子吧假如有一天小编和女神去海边浪此时小编这时坐在沙滩上打游戏突然女神过来和说： 我口渴了， 你去买杯奶茶呗~这时就凸显我以后的家庭地位了， 我就有三种选择：我听到之后没有理会， 继续打我的游戏， 从中就凸显我的 “家庭帝位” ；我立马停下手中的游戏， 马上给女神买奶茶去 ，从中就凸显我的 “家庭弟位” ；我和她说： 等我这把游戏打完， 就给你去买， 从中就凸显我的 “家庭中位” 。而上述的栗子从中也反映了： 终止线程过程中， 虽然 sleep 能够清除 isInterrupt 修改后的状态， 但是也为我们在 catch 中提供了 多方面的选择， 如果我们需要 跳出就break ， 如果需要 继续执行就什么都不写 ， 如果需要 执行别的业务逻辑就添加进入即可 。总结Thread 类： 对于 Thread 类 而已是 Java封装 的一种 给 系统创建线程 的一个类的概念以及使用。创建线程的方式： 掌握创建线程的主要流程和逻辑代码 ， 以及熟悉这 五种线程创建的方式。线程终止： 对于线程终止的两种方式： 强行终止的粗暴方式， 等待任务结束的温柔方式 。 Java的终止线程的方式是 比较温柔并且操作空间是很大 的。————————————————原文链接：https://blog.csdn.net/mgzdwm/article/details/142483482

本博客将带大家一起学习基本数据结构之一——栈（Stack），虽然Java当中的Stack集合已经被Deque（双端队列）替代了，但是他的基本思想和实现还是有必要学习的。一.初识栈1.基本概念        堆栈又名栈（stack），它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。        向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；        从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。简单来讲，栈就是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 如下是它在Java集合框架中的位置： ps：由于Vector设计过时，所以继承自他的Stack也被替代了。2.特性LIFO：即Last In First Out，后进先出原则。类似于坐电梯，先走进去的人后出来；或者上子弹，最先进弹夹的子弹最后打出。3.核心操作入栈（push）、出栈（pop）、查看栈顶（peek）二.栈的模拟实现老规矩，先看源码：  我们不难发现栈的实现相当简单，底层就是一个数组，同时Stack类也相当简单，仅仅只有140余行。接下来我们不考虑泛型与io，存储的数据默认为int，来实现一个简单的栈，以理解栈的底层原理。1.经典实现最经典的就是基于数组的实现：（1）基本结构public class MyStack {    private int[] elements; // 存储元素的数组    private int top;        // 栈顶指针（初始为-1）    private static final int DEFAULT_CAPACITY = 10;     // 构造方法    public MyStack() {        this(DEFAULT_CAPACITY);    }     public MyStack(int initialCapacity) {        if (initialCapacity <= 0) {            throw new IllegalArgumentException("容量必须为正数");        }        this.elements = new int[initialCapacity];        top = -1;    }        ......AI生成项目java运行说明：由于是基于数组实现的，所以不得不考虑动态扩容机制。我们提供2种构造方法，一种指定初始容量，另一种不指定，使用默认容量，即DEFAULT_CAPACITY这一静态变量。我们提供一个指针来指示栈顶，即top。（2）动态扩容// 动态扩容private void resize(int newCapacity) {    int[] newArray = new int[newCapacity];    System.arraycopy(elements, 0, newArray, 0, top + 1);    elements = newArray;}AI生成项目java运行说明：System.arraycopy(elements, 0, newArray, 0, top + 1);AI生成项目java运行复制数组参数（原数组，复制起始位置，复制目的地，目的地起始位置，复制长度）（3）入栈（push）// 入栈（带动态扩容）public void push(int value) {    // 检查是否需要扩容    if (top == elements.length - 1) {        resize(2 * elements.length);    }    elements[++top] = value;}AI生成项目java运行（4）出栈（pop）// 出栈public int pop() {    if (isEmpty()) {        throw new IllegalStateException("栈为空");    }    return elements[top--];}AI生成项目java运行（5）查看栈顶（peek）// 查看栈顶元素public int peek() {    if (isEmpty()) {        throw new IllegalStateException("栈为空");    }    return elements[top];}AI生成项目java运行（6）其他// 判断是否为空public boolean isEmpty() {    return top == -1;} // 获取元素数量public int size() {    return top + 1;}AI生成项目java运行（7）完整实现与测试public class MyStack {    private int[] elements; // 存储元素的数组    private int top;        // 栈顶指针（初始为-1）    private static final int DEFAULT_CAPACITY = 10;     // 构造方法    public MyStack() {        this(DEFAULT_CAPACITY);    }     public MyStack(int initialCapacity) {        if (initialCapacity <= 0) {            throw new IllegalArgumentException("容量必须为正数");        }        elements = new int[initialCapacity];        top = -1;    }     // 入栈（带动态扩容）    public void push(int value) {        // 检查是否需要扩容        if (top == elements.length - 1) {            resize(2 * elements.length);        }        elements[++top] = value;    }     // 出栈    public int pop() {        if (isEmpty()) {            throw new IllegalStateException("栈为空");        }        return elements[top--];    }     // 查看栈顶元素    public int peek() {        if (isEmpty()) {            throw new IllegalStateException("栈为空");        }        return elements[top];    }     // 判断是否为空    public boolean isEmpty() {        return top == -1;    }     // 获取元素数量    public int size() {        return top + 1;    }     // 动态扩容    private void resize(int newCapacity) {        int[] newArray = new int[newCapacity];        System.arraycopy(elements, 0, newArray, 0, top + 1);        elements = newArray;    }     // 测试代码    public static void main(String[] args) {        MyStack stack = new MyStack(3);         // 测试入栈和扩容        stack.push(10);        stack.push(20);        stack.push(30);        stack.push(40);  // 触发扩容到6         System.out.println("栈顶元素: " + stack.peek()); // 输出40        System.out.println("元素数量: " + stack.size()); // 输出4         // 测试出栈        System.out.println("出栈: " + stack.pop()); // 40        System.out.println("出栈: " + stack.pop()); // 30        System.out.println("剩余元素数量: " + stack.size()); // 2    }}AI生成项目java运行2.链表实现除了使用数组存储数据，使用链表也是可以的，并且使用链表不用考虑动态扩容。（1）基本结构public class MyLinkedStack {    private static class Node {        int data;        Node next;         Node(int data) {            this.data = data;        }    }     private Node top;   // 栈顶节点    private int size;   // 元素数量     ......AI生成项目java运行（2）入栈（push）public void push(int value) {    Node newNode = new Node(value);    newNode.next = top; // 新节点指向原栈顶    top = newNode;     // 更新栈顶    size++;}AI生成项目java运行（3）出栈（pop）public int pop() {    if (isEmpty()) {        throw new IllegalStateException("栈为空");    }    int value = top.data;    top = top.next; // 移动栈顶指针    size--;    return value;}AI生成项目java运行特别注意栈为空时会报错，所以要检查栈是否为空。（4）查看栈顶（peek）public int peek() {    if (isEmpty()) {        throw new IllegalStateException("栈为空");    }    return top.data;}AI生成项目java运行（5）其他public boolean isEmpty() {    return top == null;} public int size() {    return size;}AI生成项目java运行（6）完整实现与测试public class MyLinkedStack {    private static class Node {        int data;        Node next;         Node(int data) {            this.data = data;        }    }     private Node top;   // 栈顶节点    private int size;   // 元素数量     public void push(int value) {        Node newNode = new Node(value);        newNode.next = top; // 新节点指向原栈顶        top = newNode;     // 更新栈顶        size++;    }     public int pop() {        if (isEmpty()) {            throw new IllegalStateException("栈为空");        }        int value = top.data;        top = top.next; // 移动栈顶指针        size--;        return value;    }     public int peek() {        if (isEmpty()) {            throw new IllegalStateException("栈为空");        }        return top.data;    }     public boolean isEmpty() {        return top == null;    }     public int size() {        return size;    }     // 测试代码    public static void main(String[] args) {        MyLinkedStack stack = new MyLinkedStack();        stack.push(100);        stack.push(200);        System.out.println(stack.pop()); // 200        System.out.println(stack.peek()); // 100    }}AI生成项目java运行三.栈的使用请见以下代码:import java.util.Stack; public class StackDemo {    public static void main(String[] args) {        // 1. 创建栈对象        Stack<Integer> stack = new Stack<>();         // 2. 压栈操作（push）        System.out.println("----- 压栈操作 -----");        stack.push(10);        stack.push(20);        stack.push(30);        System.out.println("当前栈内容: " + stack);  // 输出: [10, 20, 30]         // 3. 查看栈顶（peek）        System.out.println("\n----- 查看栈顶 -----");        System.out.println("栈顶元素: " + stack.peek()); // 输出: 30        System.out.println("查看后栈内容: " + stack);    // 保持原样         // 4. 弹栈操作（pop）        System.out.println("\n----- 弹栈操作 -----");        System.out.println("弹出元素: " + stack.pop());  // 输出: 30        System.out.println("弹出后栈内容: " + stack);    // 输出: [10, 20]         // 5. 检查空栈（empty）        System.out.println("\n----- 检查空栈 -----");        System.out.println("栈是否为空? " + stack.empty()); // 输出: false                // 6. 搜索元素（search）        System.out.println("\n----- 搜索元素 -----");        int target = 20;        int position = stack.search(target);        System.out.println("元素 " + target + " 的位置: " + position);  // 输出: 1（栈顶为1）         // 7. 清空栈        System.out.println("\n----- 清空栈 -----");        while (!stack.empty()) {            System.out.println("弹出: " + stack.pop());        }        System.out.println("清空后栈是否为空? " + stack.empty()); // 输出: true    }}AI生成项目java运行更多信息请见官方文档说明：Stack (Java Platform SE 8 )四.栈的典型应用1.括号匹配算法该算法能自动检验输入的字符串中括号是否正确匹配：import java.util.Stack; public class BracketMatcher {    public static boolean isValid(String s) {        Stack<Character> stack = new Stack<>();         for (char c : s.toCharArray()) {            // 遇到左括号时，将对应的右括号压入栈            switch (c) {                case '(':                    stack.push(')');                    break;                case '[':                    stack.push(']');                    break;                case '{':                    stack.push('}');                    break;                default:                    // 遇到右括号时，检查栈顶是否匹配                    if (stack.isEmpty() || stack.pop() != c) {                        return false;                    }            }        }        // 最终栈必须为空才表示完全匹配        return stack.isEmpty();    }}AI生成项目java运行原理请见LeetCode：20. 有效的括号 - 力扣（LeetCode）2.逆波兰表达式（计算机的算数运算）import java.util.Stack; public class ReversePolishNotation {    public static int evalRPN(String[] tokens) {        Stack<Integer> stack = new Stack<>();                for (String token : tokens) {            // 遇到运算符时进行计算            if (isOperator(token)) {                int b = stack.pop();                int a = stack.pop();                stack.push(calculate(a, b, token));            }             // 遇到数字时压栈            else {                stack.push(Integer.parseInt(token));            }        }        return stack.pop();    }     // 判断是否是运算符    private static boolean isOperator(String s) {        return s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/");    }     // 执行运算（注意操作数顺序）    private static int calculate(int a, int b, String op) {        switch (op) {            case "+": return a + b;            case "-": return a - b;            case "*": return a * b;            case "/": return a / b;  // 题目通常要求整数除法向零取整            default: throw new IllegalArgumentException("非法运算符");        }    }     public static void main(String[] args) {        // 测试案例        String[][] testCases = {            {"2","1","+","3","*"},      // (2+1)*3=9            {"4","13","5","/","+"},      // 4+(13/5)=6            {"10","6","9","3","+","-11","*","/","*","17","+","5","+"} // 10*(6/((9+3)*-11))+17+5        };         for (String[] testCase : testCases) {            System.out.println("表达式: " + String.join(" ", testCase));            System.out.println("结果: " + evalRPN(testCase) + "\n");        }    }}AI生成项目java运行详情请见：150. 逆波兰表达式求值 - 力扣（LeetCode）结语关于用Deque替代Stack的事————————————————原文链接：https://blog.csdn.net/2401_88030885/article/details/146369622

 树树形结构：树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti (1 <= i <= m)又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。树是递归定义的。注意：树形结构中，子树之间不能有交集，否则就不是树形结构。树的概念：结点的度：一个结点含有子树的个数称为该结点的度； 如上图：A的度为6树的度：一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为6叶子结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I...等节点为叶结点双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点根结点：一棵树中，没有双亲结点的结点；如上图：A结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推树的高度或深度：树中结点的最大层次； 如上图：树的高度为4树的以下概念只需了解，在看书时只要知道是什么意思即可：非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等节点为分支结点兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙森林：由m（m>=0）棵互不相交的树组成的集合称为森林 二叉树概念：一棵二叉树是结点的一个有限集合，该集合：1. 或者为空2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。二叉树不存在度大于2的结点。 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。对于任意的二叉树都是由以下几种情况复合而成的： 两种特殊的二叉树：1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵二叉树的层数为K，且结点总数是 2的k次方-1 ，则它就是满二叉树。2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n 个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。  二叉树的性质：1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 (i>0)个结点2. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 (k>=0)3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋14. 具有n个结点的完全二叉树的深度k为 上取整5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i 的结点有：若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点若2i+1，左孩子序号：2i+1，否则无左孩子若2i+2，右孩子序号：2i+2，否则无右孩子创建一个简单的二叉树：public class Main {    public static void main(String[] args) {        TreeNode<Character>a=new TreeNode<>('A');        TreeNode<Character>b=new TreeNode<>('B');        TreeNode<Character>c=new TreeNode<>('C');        TreeNode<Character>d=new TreeNode<>('D');        TreeNode<Character>e=new TreeNode<>('E');         a.left=b;        a.right=c;        b.left=d;        b.right=e;         System.out.println(a.left.left.element);    }     public static class TreeNode<E>{        public E element;        public TreeNode<E> left,right;         public TreeNode(E element){            this.element=element;        }    }} //输出DAI生成项目java运行二叉树的遍历所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结 点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容、节点内容加 1)。 遍历是二叉树上最重要的操作之一，是二叉树上进行其它运算之基础。 前序遍历：打印根节点前序遍历左子树前序遍历右子树public class Main {    public static void main(String[] args) {        TreeNode<Character>a=new TreeNode<>('A');        TreeNode<Character>b=new TreeNode<>('B');        TreeNode<Character>c=new TreeNode<>('C');        TreeNode<Character>d=new TreeNode<>('D');        TreeNode<Character>e=new TreeNode<>('E');        TreeNode<Character>f=new TreeNode<>('F');        TreeNode<Character>g=new TreeNode<>('G');        TreeNode<Character>h=new TreeNode<>('H');         a.left=b;        a.right=c;        b.left=d;        b.right=e;        e.left=h;        c.left=f;        c.right=g;         preOrder(a);    }     public static void preOrder(TreeNode<Character> root){        if(root==null)return;        System.out.print(root.element+" ");        preOrder(root.left);        preOrder(root.right);    }     public static class TreeNode<E>{        public E element;        public TreeNode<E> left,right;         public TreeNode(E element){            this.element=element;        }    }}//输出A B D E H C F GAI生成项目java运行 ABDEHCFG中序遍历：中序遍历左子树打印结点中序遍历右子树public static void inOrder(TreeNode<Character>root){        if(root==null)return;        inOrder(root.left);        System.out.print(root.element+" ");        inOrder(root.right);    }//输出D B H E A F C G AI生成项目java运行DBEHAFCG后序遍历：后序遍历左子树后序遍历右子树打印结点    public static void postOrder(TreeNode<Character>root){        if(root==null)return;        postOrder(root.left);        postOrder(root.right);        System.out.print(root.element+" ");    }//输出D H E B F G C A AI生成项目java运行DHEBFGCA层序遍历：利用队列来实现层序遍历，首先将根节点存入队列中，接着循环执行以下步骤：进行出队操作，得到一个结点，并打印结点的值将此结点的左右孩子结点依次入队    public static void levelOrder(TreeNode<Character>root){        LinkedQueue<TreeNode<Character>> queue=new LinkedQueue<>(); //创建一个队列        queue.offer(root); //将根结点丢进队列        while (!queue.isEmpty()){ //如果队列不为空，就一直不断的取出来            TreeNode<Character>node=queue.poll();  //取一个出来            System.out.print(node.element+" ");  //打印            if (node.left!=null)queue.offer(node.left);  //如果左右孩子不为空，直接将左右孩子丢进队列            if (node.right!=null)queue.offer(node.right);        }    }//输出A B C D E F G H AI生成项目java运行 二叉查找树和平衡二叉树二叉查找树：二叉查找树也叫二叉搜索树或二叉排序树左子树中所有结点的值，均小于其根结点的值右子树中所有结点的值，均大于其根结点的值二叉搜索树的子树也是二叉搜索树平衡二叉树：在插入结点时要尽可能避免一边倒的情况，引入平衡二叉树的概念，在插入时如果不维护二叉树的平衡，某一边只会无限制的延伸下去，出现极度不平衡的情况。平衡二叉树一定是一颗二叉查找树任意结点的左右子树也是一颗平衡二叉树从根结点开始，左右子树高度差都不能超过1，否则视为不平衡二叉树上结点的左子树高度 减去 右子树高度，得到的结果称为该节点的平衡因子失衡情况的调整：1、LL型调整（右旋）2、RR型调整（左旋）3、RL型调整（先右旋再左旋）4、LR型调整（先左旋再右旋）红黑树红黑树也是二叉查找树的一种，结点有红有黑。规则1：每个结点可以是黑色或红色规则2：根结点一定是黑色规则3：红色结点的父结点和子结点不能为红色（不能有两个连续的红色）规则4：所有的空结点都是黑色（空结点视为null，红黑树中是将空结点视为叶子结点）规则5：每个结点到空结点路径上出现的黑色结点的个数都相等哈希表散列表散列（Hashing）通过散列函数（哈希函数）将需要参与检索的数据与散列值（哈希值）关联起来，生成一种便于搜索的数据结构，我们称其为散列表（哈希表）。散列函数也加哈希函数，哈希函数可以对一个目标计算出其对应的哈希值，并且，只要是同一个目标，无论计算多少次，得到的哈希值都是一样的结果，不同的目标计算出的结果几乎都不同，哈希函数在现实生活中应用十分广泛，比如很多下载网站都提供下载文件的MD5码校验，可以用来判别文件是否完整，哈希函数多种多样，目前应用最为广泛的是SHA-1和MD5。我们可以利用哈希值的特性，设计一张全新的表结构，这种表结构是专门为哈希设立的，我们称其为哈希表。我们可以将这些元素保存到哈希表中，而保存的位置则与其对应的哈希值有关，哈希值是通过哈希函数计算得到的，我们只需要将对应元素的关键字（一般是整数）提供给哈希函数就可以进行计算了，一般比较简单的哈希函数就是取模操作，哈希表长度是多少（长度最好是一个素数），模就是多少。保存的数据是无序的，哈希表在查找时只需要进行一次哈希函数计算就能直接找到对应元素的存储位置，效率极高。public class HashTable<E> {    private final int TABLE_SIZE=10;    private final Object[]TABLE=new Object[TABLE_SIZE];     //插入    public void insert(E obj){        int index=hash(obj);        TABLE[index]=obj;    }     //判断是否包含    public boolean contains(E obj){        int index=hash(obj);        return TABLE[index]==obj;    }     private int hash(E obj){ //哈希函数，计算出存放的位置        int hashCode=obj.hashCode();        //每一个对象都有一个独一无二的哈希值，可以通过hashCode方法得到（极小概率出现相同情况）        return hashCode%TABLE_SIZE;    }} import com.test.collection.HashTable;     public static void main(String[] args) {        HashTable<String>table=new HashTable<>();        String str="AAA";        System.out.println(table.contains(str));        table.insert(str);        System.out.println(table.contains(str));    } //输出false//trueAI生成项目java运行通过哈希函数计算得到一个目标的哈希值，但是在某些情况下哈希值可能会出现相同的情况，称为哈希碰撞（哈希冲突）常见的哈希冲突解决方案是链地址法，当出现哈希冲突时，我们依然将其保存在对应的位置上，我们可以将其连接为一个链表的形式：package com.test.collection; public class HashTable<E> {    private final int TABLE_SIZE=10;    private final Node[]TABLE=new Node[TABLE_SIZE];     //放入头结点    public HashTable(){        for (int i = 0; i < TABLE_SIZE; i++)            TABLE[i]=new Node<>(null);    }     //插入    public void insert(E obj){        int index=hash(obj);        Node<E>head=TABLE[index];        Node<E>node=new Node<>(obj);        node.next=head.next;        head.next=node;    }     //判断是否包含    public boolean contains(E element){        int index=hash(element);        Node<E>node=TABLE[index].next;        while (node!=null){            if(node.element==element)                return true;            node=node.next;        }        return false;    }     private int hash(E obj){ //哈希函数，计算出存放的位置        int hashCode=obj.hashCode();        //每一个对象都有一个独一无二的哈希值，可以通过hashCode方法得到（极小概率出现相同情况）        return hashCode%TABLE_SIZE;    }     public String toString(){        StringBuilder builder=new StringBuilder();        for (int i = 0; i < TABLE_SIZE; i++) {            Node<E>head=TABLE[i].next;            while (head!=null){                builder.append(head.element+"->");                head=head.next;            }            builder.append("\n");        }        return builder.toString();    }      private static class Node<E>{        private final E element;        private Node<E> next;         private Node(E element){            this.element=element;        }    }}AI生成项目java运行    public static void main(String[] args) {         HashTable<Integer>table1=new HashTable<>();        for (int i = 0; i < 100; i++)            table1.insert(i);         System.out.println(table1);    } /*输出90->80->70->60->50->40->30->20->10->0->91->81->71->61->51->41->31->21->11->1->92->82->72->62->52->42->32->22->12->2->93->83->73->63->53->43->33->23->13->3->94->84->74->64->54->44->34->24->14->4->95->85->75->65->55->45->35->25->15->5->96->86->76->66->56->46->36->26->16->6->97->87->77->67->57->47->37->27->17->7->98->88->78->68->58->48->38->28->18->8->99->89->79->69->59->49->39->29->19->9->————————————————原文链接：https://blog.csdn.net/PluMage11/article/details/147387863 

向现实世界要答案现实世界里，账户转账操作是支持并发的，而且绝对是真正的并行，银行所有的窗口都可以做转账操作。只要我们能仿照现实世界做转账操作，串行的问题就解决了。我们试想在古代，没有信息化，账户的存在形式真的就是一个账本，而且每个账户都有一个账本，这些账本都统一存放在文件架上。银行柜员在给我们做转账时，要去文件架上把转出账本和转入账本都拿到手，然后做转账。这个柜员在拿账本的时候可能遇到以下三种情况：文件架上恰好有转出账本和转入账本，那就同时拿走；如果文件架上只有转出账本和转入账本之一，那这个柜员就先把文件架上有的账本拿到手，同时等着其他柜员把另外一个账本送回来；转出账本和转入账本都没有，那这个柜员就等着两个账本都被送回来。上面这个过程在编程的世界里怎么实现呢？其实用两把锁就实现了，转出账本一把，转入账本另一把。在transfer()方法内部，我们首先尝试锁定转出账户this（先把转出账本拿到手），然后尝试锁定转入账户target（再把转入账本拿到手），只有当两者都成功时，才执行转账操作。这个逻辑可以图形化为下图这个样子。 两个转账操作并行示意图而至于详细的代码实现，如下所示。经过这样的优化后，账户A 转账户B和账户C 转账户D这两个转账操作就可以并行了。class Account {  private int balance;  // 转账  void transfer(Account target, int amt){    // 锁定转出账户    synchronized(this) {      // 锁定转入账户      synchronized(target) {        if (this.balance > amt) {          this.balance -= amt;          target.balance += amt;        }      }    }  }} 运行本项目没有免费的午餐上面的实现看上去很完美，并且也算是将锁用得出神入化了。相对于用Account.class作为互斥锁，锁定的范围太大，而我们锁定两个账户范围就小多了，这样的锁，上一章我们介绍过，叫 细粒度锁。 使用细粒度锁可以提高并行度，是性能优化的一个重要手段。这个时候可能你已经开始警觉了，使用细粒度锁这么简单，有这样的好事，是不是也要付出点什么代价啊？编写并发程序就需要这样时时刻刻保持谨慎。的确，使用细粒度锁是有代价的，这个代价就是可能会导致死锁。在详细介绍死锁之前，我们先看看现实世界里的一种特殊场景。如果有客户找柜员张三做个转账业务：账户A 转账户B 100元，此时另一个客户找柜员李四也做个转账业务：账户B 转账户A 100 元，于是张三和李四同时都去文件架上拿账本，这时候有可能凑巧张三拿到了账本A，李四拿到了账本B。张三拿到账本A后就等着账本B（账本B已经被李四拿走），而李四拿到账本B后就等着账本A（账本A已经被张三拿走），他们要等多久呢？他们会永远等待下去…因为张三不会把账本A送回去，李四也不会把账本B送回去。我们姑且称为死等吧。​转账业务中的“死等”现实世界里的死等，就是编程领域的死锁了。 死锁 的一个比较专业的定义是： 一组互相竞争资源的线程因互相等待，导致“永久”阻塞的现象。上面转账的代码是怎么发生死锁的呢？我们假设线程T1执行账户A转账户B的操作，账户A.transfer(账户B)；同时线程T2执行账户B转账户A的操作，账户B.transfer(账户A)。当T1和T2同时执行完①处的代码时，T1获得了账户A的锁（对于T1，this是账户A），而T2获得了账户B的锁（对于T2，this是账户B）。之后T1和T2在执行②处的代码时，T1试图获取账户B的锁时，发现账户B已经被锁定（被T2锁定），所以T1开始等待；T2则试图获取账户A的锁时，发现账户A已经被锁定（被T1锁定），所以T2也开始等待。于是T1和T2会无期限地等待下去，也就是我们所说的死锁了。class Account {  private int balance;  // 转账  void transfer(Account target, int amt){    // 锁定转出账户    synchronized(this){     ①      // 锁定转入账户      synchronized(target){ ②        if (this.balance > amt) {          this.balance -= amt;          target.balance += amt;        }      }    }  }} 运行本项目关于这种现象，我们还可以借助资源分配图来可视化锁的占用情况（资源分配图是个有向图，它可以描述资源和线程的状态）。其中，资源用方形节点表示，线程用圆形节点表示；资源中的点指向线程的边表示线程已经获得该资源，线程指向资源的边则表示线程请求资源，但尚未得到。转账发生死锁时的资源分配图就如下图所示，一个“各据山头死等”的尴尬局面。 转账发生死锁时的资源分配图如何预防死锁并发程序一旦死锁，一般没有特别好的方法，很多时候我们只能重启应用。因此，解决死锁问题最好的办法还是规避死锁。那如何避免死锁呢？要避免死锁就需要分析死锁发生的条件，有个叫Coffman的牛人早就总结过了，只有以下这四个条件都发生时才会出现死锁：互斥，共享资源X和Y只能被一个线程占用；占有且等待，线程T1已经取得共享资源X，在等待共享资源Y的时候，不释放共享资源X；不可抢占，其他线程不能强行抢占线程T1占有的资源；循环等待，线程T1等待线程T2占有的资源，线程T2等待线程T1占有的资源，就是循环等待。反过来分析， 也就是说只要我们破坏其中一个，就可以成功避免死锁的发生。其中，互斥这个条件我们没有办法破坏，因为我们用锁为的就是互斥。不过其他三个条件都是有办法破坏掉的，到底如何做呢？对于“占用且等待”这个条件，我们可以一次性申请所有的资源，这样就不存在等待了。对于“不可抢占”这个条件，占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源，这样不可抢占这个条件就破坏掉了。对于“循环等待”这个条件，可以靠按序申请资源来预防。所谓按序申请，是指资源是有线性顺序的，申请的时候可以先申请资源序号小的，再申请资源序号大的，这样线性化后自然就不存在循环了。我们已经从理论上解决了如何预防死锁，那具体如何体现在代码上呢？下面我们就来尝试用代码实践一下这些理论。1. 破坏占用且等待条件从理论上讲，要破坏这个条件，可以一次性申请所有资源。在现实世界里，就拿前面我们提到的转账操作来讲，它需要的资源有两个，一个是转出账户，另一个是转入账户，当这两个账户同时被申请时，我们该怎么解决这个问题呢？可以增加一个账本管理员，然后只允许账本管理员从文件架上拿账本，也就是说柜员不能直接在文件架上拿账本，必须通过账本管理员才能拿到想要的账本。例如，张三同时申请账本A和B，账本管理员如果发现文件架上只有账本A，这个时候账本管理员是不会把账本A拿下来给张三的，只有账本A和B都在的时候才会给张三。这样就保证了“一次性申请所有资源”。 通过账本管理员拿账本对应到编程领域，“同时申请”这个操作是一个临界区，我们也需要一个角色（Java里面的类）来管理这个临界区，我们就把这个角色定为Allocator。它有两个重要功能，分别是：同时申请资源apply()和同时释放资源free()。账户Account 类里面持有一个Allocator的单例（必须是单例，只能由一个人来分配资源）。当账户Account在执行转账操作的时候，首先向Allocator同时申请转出账户和转入账户这两个资源，成功后再锁定这两个资源；当转账操作执行完，释放锁之后，我们需通知Allocator同时释放转出账户和转入账户这两个资源。具体的代码实现如下。class Allocator {  private List<Object> als =    new ArrayList<>();  // 一次性申请所有资源  synchronized boolean apply(    Object from, Object to){    if(als.contains(from) ||         als.contains(to)){      return false;    } else {      als.add(from);      als.add(to);    }    return true;  }  // 归还资源  synchronized void free(    Object from, Object to){    als.remove(from);    als.remove(to);  }} class Account {  // actr应该为单例  private Allocator actr;  private int balance;  // 转账  void transfer(Account target, int amt){    // 一次性申请转出账户和转入账户，直到成功    while(!actr.apply(this, target))      ；    try{      // 锁定转出账户      synchronized(this){        // 锁定转入账户        synchronized(target){          if (this.balance > amt){            this.balance -= amt;            target.balance += amt;          }        }      }    } finally {      actr.free(this, target)    }  }} 运行本项目2. 破坏不可抢占条件破坏不可抢占条件看上去很简单，核心是要能够主动释放它占有的资源，这一点synchronized是做不到的。原因是synchronized申请资源的时候，如果申请不到，线程直接进入阻塞状态了，而线程进入阻塞状态，啥都干不了，也释放不了线程已经占有的资源。你可能会质疑，“Java作为排行榜第一的语言，这都解决不了？”你的怀疑很有道理，Java在语言层次确实没有解决这个问题，不过在SDK层面还是解决了的，java.util.concurrent这个包下面提供的Lock是可以轻松解决这个问题的。关于这个话题，咱们后面会详细讲。3. 破坏循环等待条件破坏这个条件，需要对资源进行排序，然后按序申请资源。这个实现非常简单，我们假设每个账户都有不同的属性 id，这个 id 可以作为排序字段，申请的时候，我们可以按照从小到大的顺序来申请。比如下面代码中，①~⑥处的代码对转出账户（this）和转入账户（target）排序，然后按照序号从小到大的顺序锁定账户。这样就不存在“循环”等待了。class Account {  private int id;  private int balance;  // 转账  void transfer(Account target, int amt){    Account left = this            Account right = target;        if (this.id > target.id) {       left = target;                 right = this;                }                              // 锁定序号小的账户    synchronized(left){      // 锁定序号大的账户      synchronized(right){        if (this.balance > amt){          this.balance -= amt;          target.balance += amt;        }      }    }  }} 运行本项目总结当我们在编程世界里遇到问题时，应不局限于当下，可以换个思路，向现实世界要答案， 利用现实世界的模型来构思解决方案，这样往往能够让我们的方案更容易理解，也更能够看清楚问题的本质。但是现实世界的模型有些细节往往会被我们忽视。因为在现实世界里，人太智能了，以致有些细节实在是显得太不重要了。在转账的模型中，我们为什么会忽视死锁问题呢？原因主要是在现实世界，我们会交流，并且会很智能地交流。而编程世界里，两个线程是不会智能地交流的。所以在利用现实模型建模的时候，我们还要仔细对比现实世界和编程世界里的各角色之间的差异。我们今天这一篇文章主要讲了 用细粒度锁来锁定多个资源时，要注意死锁的问题。这个就需要你能把它强化为一个思维定势，遇到这种场景，马上想到可能存在死锁问题。当你知道风险之后，才有机会谈如何预防和避免，因此， 识别出风险很重要。预防死锁主要是破坏三个条件中的一个，有了这个思路后，实现就简单了。但仍需注意的是，有时候预防死锁成本也是很高的。例如上面转账那个例子，我们破坏占用且等待条件的成本就比破坏循环等待条件的成本高，破坏占用且等待条件，我们也是锁了所有的账户，而且还是用了死循环 while(!actr.apply(this, target)); 方法，不过好在apply()这个方法基本不耗时。 在转账这个例子中，破坏循环等待条件就是成本最低的一个方案。所以我们在选择具体方案的时候，还需要 评估一下操作成本，从中选择一个成本最低的方案。————————————————原文链接：https://blog.csdn.net/2402_87298751/article/details/150211720

前言在使用GitHub时，看到好的项目或想给某个项目做贡献，此时通常会将代码仓库fork到自己的账号下。如果在此期间，如果源仓库的代码发生了变动，就需要与源仓库代码进行同步。这里实操一下，如何实现这一操作。 配置项目的上游仓库首先需要大家将fork的仓库代码clone到本地，后面的所有操作都是基于本地代码库来进行操作的。比如，可以通过git clone先将fork的代码下载到本地：git clone git@github.com:secbr/nacos.git后续的一步步操作，都是基于本地仓库来进行操作。 进入到本地仓库目录通过cd操作，进入到clone下来的本地仓库根目录：cd /Users/apple/develop/nacos-request/nacos后续的操作无特殊说明，都是在这个本地仓库的目录下进行操作。 查看远程仓库路径执行命令 git remote -v 查看远程仓库的路径：appledeMacBook-Pro-2:nacos apple$ git remote -vorigin https://github.com/secbr/nacos.git (fetch)origin https://github.com/secbr/nacos.git (push)如果只显示2行内容，说明该项目还未设置upstream（中文叫：上游代码库），一般情况下，设置好一次upstream后就无需重复设置。通过显示远程仓库的路径和clone时的路径对照，会发现，此时远程仓库的路径还是fork项目的路径。 添加upstream路径执行命令 git remote add upstream https://xxx.git，把fork的源仓库设置为 upstream 。这里项目是从alibaba的nacos仓库fork过来的，因此对应的upstream就是alibaba的源仓库地址。执行上述命令，在此执行git remote -v 检查是否成功。appledeMacBook-Pro-2:nacos apple$ git remote add upstream https://github.com/alibaba/nacos.gitappledeMacBook-Pro-2:nacos apple$ git remote -vorigin https://github.com/secbr/nacos.git (fetch)origin https://github.com/secbr/nacos.git (push)upstream https://github.com/alibaba/nacos.git (fetch)upstream https://github.com/alibaba/nacos.git (push)通过上面的输出可以看出，多了两项upstream的地址，说明添加upstream成功。 检查本地代码状态由于实例是直接从仓库clone下来的，本地还没有修改代码。如果本地项目已经修改了一些代码，不确定是否提交了代码，就需要执行git status来检查一下。appledeMacBook-Pro-2:nacos apple$ git statusOn branch developYour branch is up to date with 'origin/develop'. nothing to commit, working tree clean上面显示，本地没有需要提交的（commit）的代码。如果本地有修改，需要先从本地仓库推送到GitHub仓库。然后，再执行一次 git status 检查。对应推送到GitHub仓库的基本操作步骤如下：git add -A 或者 git add filenamegit commit -m "your note"git push origin mastergit status完成上面的基本操作之后，确认代码都已经提交，便可以开始执行源仓库与本地仓库的merge操作了。 抓取源仓库的更新经过上面步骤的准备之后，可以进行源仓库的代码更新了。执行命令 git fetch upstream 抓取原仓库的更新：appledeMacBook-Pro-2:nacos apple$ git fetch upstreamremote: Enumerating objects: 2646, done.remote: Counting objects: 100% (2593/2593), done.remote: Compressing objects: 100% (1157/1157), done.remote: Total 2646 (delta 731), reused 2404 (delta 682), pack-reused 53Receiving objects: 100% (2646/2646), 1.67 MiB | 1.47 MiB/s, done.Resolving deltas: 100% (734/734), completed with 37 local objects.From https://github.com/alibaba/nacos* [new branch] 0.2.1 -> upstream/0.2.1* [new branch] 0.2.2 -> upstream/0.2.2* [new branch] 0.3.0 -> upstream/0.3.0//...省略一部分执行上述命令之后，上游仓库的更新（commit）会本存储为本地的分支，通常名称为：upstream/BRANCHNAME。比如上面的upstream/0.3.0。 切换分支完成了上游仓库分支的拉取之后，先来核查一下本地仓库当前处于哪个分支，也就是需要更新合并的分支。比如，这里需要将develop分支的内容更新到与上游仓库代码一致。则先切换到develop分支：appledeMacBook-Pro-2:nacos apple$ git checkout developAlready on 'develop'Your branch is up to date with 'origin/develop'.上面提示已经是develop分支了。 执行合并执行命令 git merge upstream/develop 合并远程的develop分支。比如合并的可能是master，可根据需要将develop的名称替换成对应的master。appledeMacBook-Pro-2:nacos apple$ git merge upstream/developRemoving test/src/test/java/com/alibaba/nacos/test/naming/DeregisterInstance_ITCase.java// ...省略一部分Removing naming/src/test/java/com/alibaba/nacos/naming/core/PushServiceTest.javaAuto-merging client/src/main/java/com/alibaba/nacos/client/naming/remote/http/NamingHttpClientProxy.javaCONFLICT (content): Merge conflict in client/src/main/java/com/alibaba/nacos/client/naming/remote/http/NamingHttpClientProxy.javaRemoving client/src/main/java/com/alibaba/nacos/client/naming/core/HostReactor.javaRemoving .editorconfigAutomatic merge failed; fix conflicts and then commit the result.执行完上述命令之后，会发现上游代码指定分支的修改内容已经反映到本地代码了。 上传代码到fork分支执行完上一步的合并操作之后，往后还有一些后续处理，比如代码冲突。如果本地修改了内容，上游仓库也修改了对应的代码，则可能会出现冲突。这时就需要对比代码进行修改。本人更习惯使用IDEA中可视化的插件进行代码冲突解决，也可以选择喜欢的方式进行解决。解决完冲突之后，就可以执行正常的代码add、commit和push操作了。这里的一系列操作都是针对自己fork的仓库的，对应操作实例如下：appledeMacBook-Pro-2:nacos apple$ git add .appledeMacBook-Pro-2:nacos apple$ git commit -m 'merge from nacos'[develop 8601c1791] merge from nacos appledeMacBook-Pro-2:nacos apple$ git pushEnumerating objects: 4, done.Counting objects: 100% (4/4), done.Delta compression using up to 12 threadsCompressing objects: 100% (2/2), done.Writing objects: 100% (2/2), 281 bytes | 281.00 KiB/s, done.Total 2 (delta 1), reused 0 (delta 0), pack-reused 0remote: Resolving deltas: 100% (1/1), completed with 1 local object.To https://github.com/secbr/nacos.git76a4dcbb1..8601c1791 develop -> develop上述操作，通过add、commit、push一系列操作，将源仓库中的修改内容，提交到自己fork的分支当中了。此时再查看自己fork的GitHub仓库，可以发现代码已经更新。 

在Java开发的复杂生态中，尤其是当使用Spring框架来构建强大的应用程序时，异常情况就像隐藏在暗处的荆棘，随时可能阻碍开发进程。其中，org.springframework.beans.factory.BeanCreationException这个异常犹如一位不速之客，常常在Bean的创建阶段引发混乱。它的出现意味着在Spring容器尝试创建Bean的过程中遇到了严重问题，而这些问题可能隐藏在看似简单的配置或者复杂的代码逻辑之中。这不仅让开发者们感到困惑，也可能影响整个应用程序的正常启动和运行。那么，如何才能像经验丰富的侦探一样，迅速找出问题所在并解决这个令人头疼的报错呢？本文将为您详细剖析这个异常，提供一系列实用的解决方案。一、问题描述1.1 报错示例以下是一个简单但具有代表性的场景，可能导致org.springframework.beans.factory.BeanCreationException异常的出现：假设我们有一个简单的Java类，代表一个用户信息的实体类：1234567891011121314151617package com.example.model;public class User {    private String username;    private int age;    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}然后，我们创建一个Spring的配置文件（beans.xml）来配置这个User类的Bean：12345678910<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean id="user" class="com.example.model.User">        <property name="username" value="John Doe"/>        <property name="age" value="abc"/> <!-- 这里故意设置一个错误的值类型，应为整数 -->    </bean></beans>最后，我们创建一个简单的测试类来获取这个Bean：1234567891011package com.example.test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import com.example.model.User;public class Main {    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");        User user = (User) context.getBean("user");        System.out.println("Username: " + user.getUsername() + ", Age: " + user.getAge());    }}在这个示例中，由于在配置文件中为age属性设置了一个错误类型的值（字符串abc而不是整数），当Spring尝试创建user Bean时，就可能会抛出org.springframework.beans.factory.BeanCreationException异常。1.2 报错分析在上述示例中，导致org.springframework.beans.factory.BeanCreationException异常的原因主要是由于Bean属性配置错误。1.2.1 类型不匹配问题在配置user Bean时，对于age属性，Spring期望一个整数类型的值，但配置文件中提供了一个字符串。当Spring尝试将字符串abc转换为整数来设置age属性时，转换失败，从而导致Bean创建过程中的异常。这种类型不匹配问题在Spring的属性注入机制中是一个常见的错误来源。1.2.2 Bean依赖问题（假设存在依赖）如果User类依赖于其他的Bean，而这些依赖Bean在创建过程中出现问题（例如，依赖Bean的配置错误、无法找到依赖Bean的类等），也会导致user Bean创建失败。比如，如果User类有一个Address类型的属性，而Address Bean的配置存在问题，那么在创建user Bean时，当Spring尝试注入Address Bean时就会出现异常。1.2.3 类加载问题有时候，即使Bean本身的配置看起来正确，但如果类加载出现问题，也会导致Bean无法创建。例如，如果User类所在的jar包损坏或者类路径配置错误，Spring在尝试加载User类时会失败，进而引发BeanCreationException。这可能是由于项目构建问题、IDE设置问题或者运行环境问题导致的。1.3 解决思路解决这个问题的思路主要是从Bean的配置、依赖关系以及类加载等方面进行全面排查。1.3.1 检查Bean属性配置仔细检查配置文件中对Bean属性的设置，包括属性值的类型、格式等是否正确。确保每个属性的值都能正确地转换为Bean类中相应属性的类型。1.3.2 审查Bean依赖关系对于有依赖的Bean，检查依赖Bean的配置是否正确，是否存在依赖缺失或者配置错误的情况。可以通过查看Spring的启动日志或者使用调试工具来追踪依赖Bean的创建过程。1.3.3 排查类加载问题确认Bean相关类的类路径是否正确，检查项目的构建路径、IDE设置以及运行环境的配置。确保类能够被正确加载，没有受到损坏的jar包或者错误的类路径影响。二、解决方法2.1 方法一：修正Bean属性配置错误2.1.1 类型检查与修正在上述示例中，对于user Bean的age属性，将配置文件中的错误值修改为正确的整数类型。修改后的配置如下：12345678910<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean id="user" class="com.example.model.User">        <property name="username" value="John Doe"/>        <property name="age" value="30"/>    </bean></beans>这样，Spring在创建user Bean时就能正确地设置age属性，避免因类型不匹配导致的异常。2.1.2 语法和格式检查除了类型问题，还要检查属性配置的语法和格式。例如，如果属性值是一个复杂的表达式或者引用其他Bean，确保语法正确。如果使用SpEL（Spring Expression Language）表达式，检查表达式的语法和引用是否正确。2.2 方法二：解决Bean依赖问题2.2.1 检查依赖Bean的配置如果User类依赖于其他Bean，如Address Bean，检查Address Bean的配置文件。确保Address Bean的类名、属性配置等都正确。例如，如果Address Bean的配置如下：1234<bean id="address" class="com.example.model.Address">    <property name="street" value="123 Main St"/>    <property name="city" value="Anytown"/></bean>检查Address类是否存在，属性street和city是否与Address类中的属性匹配，以及类路径是否正确。2.2.2 处理依赖缺失或错误如果发现依赖Bean缺失（例如，忘记配置某个依赖Bean），添加正确的配置。如果依赖Bean的配置存在错误，如类名错误或者属性设置问题，修改相应的配置。另外，如果存在循环依赖问题（即两个或多个Bean相互依赖），可以采用合适的设计模式或者使用Spring的@Lazy注解来解决。例如，如果A Bean依赖于B Bean，B Bean又依赖于A Bean，可以在其中一个Bean的依赖注入处使用@Lazy注解，延迟该Bean的初始化，以避免循环依赖导致的创建失败。2.3 方法三：解决类加载问题2.3.1 检查项目构建路径在使用IDE（如Eclipse、IntelliJ IDEA等）开发时，检查项目的构建路径设置。确保所有包含Bean相关类的源文件目录、依赖的jar包等都正确添加到构建路径中。在Eclipse中，可以通过项目属性中的“Java Build Path”选项来检查和修改构建路径。在IntelliJ IDEA中，可以在项目结构设置中查看和调整相关内容。2.3.2 检查运行环境和类路径当应用程序在服务器或者其他运行环境中部署时，检查运行环境的类路径设置。确保所有必要的jar包都在类路径中，并且没有冲突或损坏的jar包。如果使用了Maven或Gradle等构建工具，检查生成的可执行jar包或war包的结构，确保类和依赖的jar包都正确打包。如果发现类加载问题是由于损坏的jar包导致的，可以尝试重新下载或更新相关的jar包。2.3.3 查看类加载日志大多数Java应用服务器和运行环境都提供了类加载的日志功能。可以查看这些日志来确定是否存在类加载失败的情况。例如，在Tomcat服务器中，可以查看catalina.out或localhost.log等日志文件，查找有关类加载问题的信息。根据日志中的错误信息，如“ClassNotFoundException”或“java.lang.NoClassDefFoundError”，进一步排查问题所在。2.4 方法四：使用Spring的调试和日志功能2.4.1 启用详细的Spring日志在项目的日志配置文件（如log4j.properties或logback.xml等）中，将Spring相关的日志级别设置为DEBUG或TRACE。例如，在log4j.properties中，可以添加以下内容：1log4j.logger.org.springframework=DEBUG这样，在应用程序启动和运行过程中，Spring会输出更详细的日志信息，包括Bean的创建过程、属性注入情况、依赖关系处理等。通过查看这些详细日志，可以更清晰地发现问题所在。例如，如果Bean创建失败，日志中可能会显示出具体是哪个属性配置错误、哪个依赖Bean无法创建或者是类加载过程中的哪个步骤出现问题。2.4.2 使用Spring的调试工具（在IDE中）许多现代的IDE（如IntelliJ IDEA）提供了对Spring的调试支持。在调试模式下启动应用程序，可以在IDE中设置断点，观察Spring在创建Bean过程中的内部操作。可以查看变量的值、方法的调用顺序等，帮助确定问题的具体位置。例如，可以在Spring创建user Bean的过程中，在属性注入的代码处设置断点，查看注入的值是否正确，以及是否有异常抛出。三、其他解决方法检查与其他框架或组件的集成：如果应用程序使用了多个框架或组件，并且它们与Spring有交互，检查这些交互是否导致了BeanCreationException。例如，如果使用Spring与Hibernate集成，检查Hibernate的配置是否与Spring的配置相互影响，是否存在版本冲突或者配置不兼容的问题。确保所有相关框架和组件的配置都正确协调，不会干扰Spring的Bean创建过程。清理和重新构建项目：有时候，由于编译过程中的临时文件、缓存或者其他原因，可能会导致Bean创建出现问题。可以尝试在IDE中清理项目（通常有专门的清理选项），然后重新构建项目。这可以清除可能存在的错误编译产物，重新生成干净的类文件和配置文件。在使用Maven或Gradle等构建工具时，也可以使用相应的清理和重新构建命令（如mvn clean install或gradle clean build）。检查Bean的生命周期方法（如果存在）：如果Bean实现了InitializingBean接口或者定义了init - method等生命周期方法，检查这些方法中的代码是否存在问题。例如，如果在InitializingBean的afterPropertiesSet方法中抛出异常，也会导致Bean创建失败。同样，对于destroy - method（如果有）也要进行检查，确保在Bean的整个生命周期中不会出现影响其创建的问题。可以在这些生命周期方法中添加日志输出，或者使用调试工具来检查方法的执行情况。四、总结本文围绕org.springframework.beans.factory.BeanCreationException这个在Spring应用程序开发中常见的异常展开了深入的讨论。通过详细的代码示例展示了可能导致该异常的场景，包括Bean属性配置错误、Bean依赖问题以及类加载问题等。分析了这些问题引发异常的原因，强调了在Bean创建过程中各个环节出现问题的可能性。提出了多种解决方法，如修正Bean属性配置错误、解决Bean依赖问题、解决类加载问题以及使用Spring的调试和日志功能等。此外，还介绍了检查与其他框架或组件的集成、清理和重新构建项目以及检查Bean的生命周期方法等其他相关的解决途径。下次遇到这类报错时，首先应该查看Spring的日志信息（如果已启用详细日志），以确定问题的大致方向。然后从Bean的属性配置、依赖关系、类加载以及与其他框架的集成等方面入手，逐一排查可能出现的问题。结合本文提到的各种方法，全面检查和修复问题，确保Spring能够顺利创建Bean，保障应用程序的正常启动和运行。在开发和维护过程中，保持对配置文件和代码的仔细审查，以及对运行环境和框架集成的关注，有助于预防和及时解决这类异常情况，提高应用程序的稳定性和可靠性。

一、方法1：使用重定向1、在命令行中，你可以使用重定向操作符 > 或 >> 来将输出重定向到文件中。例如：12$  java -jar example.jar > output.log$  java -jar example.jar >> output.log2、这会将标准输出（stdout）重定向到 output.log 文件。如果你想同时捕获标准错误（stderr），可以使用 2>&1 来合并标准错误到标准输出：12java -jar example.jar > output.log 2>&1Java -jar example.jar >> output.log 2>&1二、方法2：在代码中配置日志框架1、如果你使用的是如 Log4j、SLF4J、Logback 等日志框架，你可以在代码中配置日志的输出目的地。例如，使用 Logback 的 logback.xml 配置文件：1234567891011<configuration>    <appender name="FILE" class="ch.qos.logback.core.FileAppender">        <file>path/to/your/logfile.log</file>        <encoder>            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>        </encoder>    </appender>    <root level="debug">        <appender-ref ref="FILE" />    </root></configuration>2、确保将 标签中的路径改为你的目标文件路径。三、方法3：使用 JVM 参数指定日志文件1、某些日志框架允许通过 JVM 参数来指定日志文件。例如，使用 Log4j 2，你可以在启动时通过系统属性来设置日志文件：1java -D log4j.configurationFile=path/to/log4j2.xml -jar example.jar2、其中 log4j2.xml 应该包含一个类似于上面 Logback 配置的配置，指定输出到特定文件。四、方法4：使用第三方库或工具对于一些复杂的场景，你可能会想要使用更高级的日志管理工具，如 Logrotate（在 Linux 上）或者使用第三方 Java 库如 log4j-layout-tpl 来实现更复杂的日志轮转和归档策略。例如，使用 Logrotate 可以自动管理日志文件的大小和轮转。1、示例：使用 Log4j2 的 XML 配置文件确保你的 example.jar 包含了 Log4j2 的依赖，并创建一个 log4j2.xml 文件在你的项目资源目录中（例如 src/main/resources），内容如下：12345678910111213<?xml version="1.0" encoding="UTF-8"?><Configuration>    <Appenders>        <File name="LogFile" fileName="path/to/your/logfile.log">            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>        </File>    </Appenders>    <Loggers>        <Root level="info">            <AppenderRef ref="LogFile"/>        </Root>    </Loggers></Configuration>2、然后，在运行你的 jar 时指定 Log4j2 的配置文件：1java -Dlog4j.configurationFile=path/to/log4j2.xml -jar example.jar3、这样，你的应用日志就会输出到指定的文件了。

Redis 提供了 Pub/Sub (发布/订阅) 模式，允许客户端订阅频道并接收发布到这些频道的消息。以下是 Java 中使用 Redis 实现消息订阅的几种方式。1. 使用 Jedis 客户端添加依赖12345<dependency>    <groupId>redis.clients</groupId>    <artifactId>jedis</artifactId>    <version>4.3.1</version></dependency>基本订阅示例12345678910111213141516171819202122232425import redis.clients.jedis.Jedis;import redis.clients.jedis.JedisPubSub;  public class RedisSubscriber {    public static void main(String[] args) {        // 创建 Jedis 连接        Jedis jedis = new Jedis("localhost", 6379);                 // 创建订阅者        JedisPubSub subscriber = new JedisPubSub() {            @Override            public void onMessage(String channel, String message) {                System.out.println("收到消息 - 频道: " + channel + ", 内容: " + message);            }                         @Override            public void onSubscribe(String channel, int subscribedChannels) {                System.out.println("订阅成功 - 频道: " + channel);            }        };                 // 订阅频道        jedis.subscribe(subscriber, "myChannel");    }}发布消息123456789import redis.clients.jedis.Jedis;  public class RedisPublisher {    public static void main(String[] args) {        Jedis jedis = new Jedis("localhost", 6379);        jedis.publish("myChannel", "Hello, Redis Pub/Sub!");        jedis.close();    }}2. 使用 Lettuce 客户端 (推荐)Lettuce 是另一个流行的 Redis Java 客户端，支持响应式编程。添加依赖12345<dependency>    <groupId>io.lettuce</groupId>    <artifactId>lettuce-core</artifactId>    <version>6.2.3.RELEASE</version></dependency>订阅示例12345678910111213141516171819202122232425262728293031323334353637383940414243import io.lettuce.core.RedisClient;import io.lettuce.core.pubsub.RedisPubSubListener;import io.lettuce.core.pubsub.StatefulRedisPubSubConnection;import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;  public class LettuceSubscriber {    public static void main(String[] args) {        RedisClient client = RedisClient.create("redis://localhost");        StatefulRedisPubSubConnection<String, String> connection = client.connectPubSub();                 connection.addListener(new RedisPubSubListener<String, String>() {            @Override            public void message(String channel, String message) {                System.out.println("收到消息 - 频道: " + channel + ", 内容: " + message);            }                         @Override            public void message(String pattern, String channel, String message) {                // 模式匹配的消息            }                         @Override            public void subscribed(String channel, long count) {                System.out.println("订阅成功 - 频道: " + channel);            }                         // 其他需要实现的方法...        });                 RedisPubSubCommands<String, String> sync = connection.sync();        sync.subscribe("myChannel");                 // 保持程序运行以持续接收消息        try {            Thread.sleep(Long.MAX_VALUE);        } catch (InterruptedException e) {            e.printStackTrace();        }                 connection.close();        client.shutdown();    }}3. Spring Data Redis 集成如果你使用 Spring Boot，可以更方便地集成 Redis Pub/Sub，这也是比较常用的方式添加依赖1234<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-data-redis</artifactId></dependency>配置 Redis 容器123456789101112131415161718import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.listener.ChannelTopic;import org.springframework.data.redis.listener.RedisMessageListenerContainer;  @Configurationpublic class RedisConfig {         @Bean    public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,                                                 RedisMessageSubscriber subscriber) {        RedisMessageListenerContainer container = new RedisMessageListenerContainer();        container.setConnectionFactory(connectionFactory);        container.addMessageListener(subscriber, new ChannelTopic("myChannel"));        return container;    }}配置订阅123456789101112import org.springframework.data.redis.connection.Message;import org.springframework.data.redis.connection.MessageListener;import org.springframework.stereotype.Component;  @Componentpublic class RedisMessageSubscriber implements MessageListener {      @Override    public void onMessage(Message message, byte[] pattern) {        System.out.println("收到消息: " + new String(message.getBody()));    }}发布消息12345678910111213141516import org.springframework.data.redis.core.RedisTemplate;import org.springframework.stereotype.Service;  @Servicepublic class RedisMessagePublisher {         private final RedisTemplate<String, Object> redisTemplate;         public RedisMessagePublisher(RedisTemplate<String, Object> redisTemplate) {        this.redisTemplate = redisTemplate;    }         public void publish(String message) {        redisTemplate.convertAndSend("myChannel", message);    }}高级功能模式匹配订阅：可以使用 psubscribe 订阅匹配模式的频道取消订阅处理连接断开：实现 onPMessage, onPUnsubscribe 等方法处理各种事件1234567891011//模式匹配订阅// Jedisjedis.psubscribe(subscriber, "news.*");  // Lettucesync.psubscribe("news.*");    //取消订阅subscriber.unsubscribe("myChannel");subscriber.punsubscribe("news.*");

log.info("requestBody: " + finalBody); 这段代码在 finalBody 为 null 时会抛出 NullPointerException，因为 Java 中不能对 null 调用 String 的方法（如 + 拼接操作实际上会调用 String.valueOf()，但直接拼接 null 字符串是允许的，但这里可能涉及日志框架的特殊处理）。具体分析如果 log.info() 内部直接拼接字符串："requestBody: " + finalBody 在 finalBody == null 时会返回字符串 "requestBody: null"（不会报错，因为 Java 的 + 操作符允许拼接 null）。但某些日志框架（如 SLF4J、Log4j）可能对 null 有特殊处理，如果 log.info() 内部尝试调用 finalBody.toString()，则会抛出 NullPointerException。如果 log.info() 使用 {} 占位符（推荐方式）：log.info("requestBody: {}", finalBody); // 更安全，日志框架会自动处理 null 这种方式不会报错，日志框架（如 SLF4J）会将 null 转换为 "null" 字符串输出。如何避免 NullPointerException？方案 1：使用 {} 占位符（推荐）log.info("requestBody: {}", finalBody); // 自动处理 null 方案 2：手动判空log.info("requestBody: " + (finalBody != null ? finalBody : "null")); 方案 3：使用 String.valueOf()（避免 NPE）log.info("requestBody: " + String.valueOf(finalBody)); // null 会变成 "null" 结论如果 log.info() 直接拼接字符串（+ 操作符），通常不会报错，但取决于日志框架的实现。最安全的方式是使用 {} 占位符（如 SLF4J），它能正确处理 null 值。如果日志框架不支持 {} 占位符，建议手动判空或使用 String.valueOf()。示例（SLF4J/Logback）import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Example { private static final Logger log = LoggerFactory.getLogger(Example.class); public static void main(String[] args) { String finalBody = null; log.info("requestBody: {}", finalBody); // 输出: requestBody: null log.info("requestBody: " + finalBody); // 通常不会报错，但取决于日志框架 } } 推荐使用 {} 占位符，避免潜在的 NullPointerException。

Java服务使用了读写分离地址，代码中使用事务注解，会强制走主库吗？

1.modelengine提供哪些模型？最新版本ds 和 千问32.上下文限制8096问题3.知识库是在mate里面，还是在engine里面,如果都有怎么使用4.意图识别准确率。是否必选项

问题1.园区数字平台24.1现在有两套环境x86和ARM,并且ARM环境才有AI相关内容，如果让我们对接两套环境，业务无法闭环（AI算法调用ARM但是业务数据在X86）?问题2.cv模型算法是否可以在24.1版本进行对接，是否对接万州算法（人员摔倒、人员聚集、车辆违停、消防通道占用、烟火监测等），请给出具体对接方式和demo？问题3.安全红线现在有很多底层框架扫描问题，比如扫描spring boot2.x有安全漏洞，是否能提供java侧底层框架推荐版本建议，比如spring boot2.x可以升级到哪个版本，spring boot3.x升级到哪个版本？

1.算法来源（比如ivs、ai集成框架第三方cv算法）和第三方CV算法使用方式？2.算法是否支持参数配置，如果支持都有哪些参数？