【JAVA-Day76】Java线程解析：三态和五态

Java线程解析：三态和五态

  • 《Java线程状态深度解析：三态和五态探秘 😎》
    • 摘要
    • 引言
    • 一、什么是三态 😊
    • 二、什么是五态 😃
    • 三、五态之间如何转变
      • 3.1 新建状态转换到运行状态
      • 3.2 运行状态转换到阻塞状态
      • 3.3 运行状态转换到等待状态
      • 3.4 运行状态转换到计时等待状态
      • 3.5 运行状态转换到终止状态
    • 四、五态的应用场景 🌐
      • 1. 新建状态（New）：
      • 2. 运行状态（Runnable）：
      • 3. 阻塞状态（Blocked）：
      • 4. 等待状态（Waiting）：
      • 5. 计时等待状态（Timed Waiting）：
    • 五、JAVA五态面试题 ❓
    • 六、总结 🎉
    • 参考资料

在这里插入图片描述

博主 默语带您 Go to New World.
✍ 个人主页—— 默语 的博客👦🏻
《java 面试题大全》
🍩惟余辈才疏学浅，临摹之作或有不妥之处，还请读者海涵指正。☕🍭
《MYSQL从入门到精通》数据库是开发者必会基础之一~
🪁 吾期望此文有资助于尔，即使粗浅难及深广，亦备添少许微薄之助。苟未尽善尽美，敬请批评指正，以资改进。！💻⌨

《Java线程状态深度解析：三态和五态探秘 😎》

摘要

嘿，各位Java小伙伴们，博主又来啦！今天我们要揭开Java线程状态的神秘面纱，深入研究线程的三态和五态，了解线程在不同状态之间的转变过程。通过详细的代码演示和深入的探讨，让我们一起探秘线程状态的奥秘，助你在多线程编程中游刃有余！ 🚀

引言

在Java编程中，理解线程状态是高效编写多线程程序的关键。本文将深入研究线程的三态（新建、运行、阻塞）和五态（新建、运行、阻塞、等待、计时等待）之间的关系，通过大量代码案例演示，为你呈现线程状态的全貌。

一、什么是三态 😊

三态指的是线程的三种基本状态：新建、运行和阻塞。在多线程编程中，了解线程的三态非常重要，因为它们描述了线程在不同阶段的行为和状态转换。

  1. 新建状态（New）：

    • 当使用 new 关键字创建一个线程对象时，该线程处于新建状态。
    • 新建状态的线程还没有开始执行，处于等待状态，直到调用 start() 方法启动线程。

    在新建状态下，线程已经被创建，但尚未启动执行任何代码。线程对象的相关资源已被分配，但是操作系统还没有为其分配 CPU 时间片。要使线程开始执行，必须调用 start() 方法，这会将线程转移到可运行状态（Runnable）。

 public class NewThreadDemo extends Thread {
       public void run() {
           System.out.println("新线程执行");
       }
   public static void main(String[] args) {
       // 创建新线程对象
       NewThreadDemo thread = new NewThreadDemo();
       // 此时线程处于新建状态，尚未启动
   
       // 调用 start() 方法启动线程，将线程转移到可运行状态（Runnable）
       thread.start();
   }
   }

  1. 运行状态（Runnable）：

    • 线程调用 start() 方法后，进入运行状态。
    • 在运行状态中，线程正在执行任务或等待执行。
    • 处于运行状态的线程可能会因为时间片用完、主动调用 sleep()、yield() 或 wait() 方法，或者被其他线程抢占 CPU 而进入阻塞状态。

    在运行状态下，线程已经开始执行任务或者等待执行。它可能在执行过程中主动放弃 CPU 时间片，让其他线程执行（yield() 方法），也可能主动暂停一段时间（sleep() 方法），或者等待某个条件的满足（wait() 方法）。当线程执行完毕、被阻塞、或者时间片用完时，线程将会离开运行状态。

    public class RunnableThreadDemo {
    public static void main(String[] args) {
        // 创建一个线程对象，并传入一个任务
        Thread thread = new Thread(() -> {
            // 线程执行任务
            for (int i = 1; i <= 5; i++) {
                System.out.println("线程正在执行：" + i);
                try {
                    // 模拟线程执行过程中的一些操作
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 调用 start() 方法启动线程，线程进入运行状态
        thread.start();
    }
}

  2. 阻塞状态（Blocked）：

    • 线程处于阻塞状态时，不能继续执行，暂时停止运行，直到某种条件得到满足。
    • 线程进入阻塞状态的原因可能包括等待输入/输出、获取锁失败、调用 sleep()、yield()、wait() 方法等。
    • 当阻塞状态的线程满足条件后，它会重新进入就绪状态，等待 CPU 调度执行。

    在阻塞状态下，线程暂时停止运行，等待某种条件的满足。这种条件可能是等待输入/输出完成、获取锁失败、或者主动调用了一些暂停线程执行的方法（如 sleep()、yield()、wait()）。当线程满足条件后，它会重新进入就绪状态，等待操作系统重新分配 CPU 资源，并且再次开始执行。

   public class BlockedThreadDemo {
       public static void main(String[] args) {
           final Object lock = new Object();
   
           Thread taskThread = new Thread(() -> {
               synchronized (lock) {
                   System.out.println("任务线程获取了锁并开始执行任务...");
                   // 模拟执行耗时任务
                   try {
                       Thread.sleep(5000); // 任务线程休眠5秒钟
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("任务线程执行完毕，释放了锁。");
               }
           });
   
           Thread waitingThread = new Thread(() -> {
               synchronized (lock) {
                   System.out.println("获取锁成功！但不会执行到这里，因为任务线程持有锁...");
               }
           });
   
           taskThread.start(); // 启动任务线程
   
           // 等待一段时间后再尝试获取锁
           try {
               Thread.sleep(1000); // 等待1秒钟
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
   
           waitingThread.start(); // 尝试获取锁的线程开始执行
   
           // 等待尝试获取锁的线程执行完毕
           try {
               waitingThread.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

线程的状态转换如下：

  • 从新建状态到运行状态：调用 start() 方法启动线程。
  • 从运行状态到阻塞状态：线程等待某些条件的满足。
  • 从阻塞状态到运行状态：条件满足后，线程重新进入就绪状态，等待 CPU 调度执行。

通过了解线程的三态及其状态转换，我们可以更好地理解线程在不同情况下的行为，从而更有效地进行多线程编程。

二、什么是五态 😃

五态则包括了三态的基础上，增加了等待和计时等待状态。通过深入研究，我们将揭示线程在这五个状态之间如何灵活切换，为你呈现线程状态的更加细致的画面。

五态是指线程的五种基本状态，包括新建、运行、阻塞、等待和计时等待状态。在多线程编程中，了解线程的五态是非常重要的，因为它们描述了线程在不同阶段的行为和状态转换。

    • 新建状态（New）：

      • 当使用 new 关键字创建一个线程对象时，该线程处于新建状态。
      • 新建状态的线程还没有开始执行，处于等待状态，直到调用 start() 方法启动线程。

      在新建状态下，线程已经被创建，但尚未启动执行任何代码。线程对象的相关资源已被分配，但是操作系统还没有为其分配 CPU 时间片。要使线程开始执行，必须调用 start() 方法，这会将线程转移到可运行状态（Runnable）。

  2. 运行状态（Runnable）：

    • 线程调用 start() 方法后，进入运行状态。
    • 在运行状态中，线程正在执行任务或等待执行。

  3. 阻塞状态（Blocked）：

    • 线程处于阻塞状态时，不能继续执行，暂时停止运行，直到某种条件得到满足。

  4. 等待状态（Waiting）：

    • 线程在等待某个条件的满足时进入等待状态，与阻塞状态不同的是，等待状态下的线程不会被调度执行。
    • 线程可以通过 Object.wait()、Thread.join()、LockSupport.park() 等方法进入等待状态。

  5. 计时等待状态（Timed Waiting）：

    • 计时等待状态是等待状态的一个特例，线程在等待某个条件的满足时可以设置一个超时时间，在超时时间内未满足条件则线程自动唤醒。
    • 线程可以通过 Thread.sleep()、Object.wait(long timeout)、Thread.join(long millis)、LockSupport.parkNanos()、LockSupport.parkUntil() 等方法进入计时等待状态。

这五种状态描述了线程在不同阶段的行为和状态转换，了解和掌握线程的五态对于进行多线程编程非常重要。

三、五态之间如何转变

3.1 新建状态转换到运行状态

在新建状态下的线程如何转变为运行状态？我们将通过代码案例演示这一过程，助你更好地理解线程状态的变化。

public class NewToRunnableDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            // 线程任务代码
            System.out.println("线程开始执行任务...");
        });

        // 此时线程对象已经创建，处于新建状态
        System.out.println("线程处于新建状态");

        // 调用 start() 方法，将线程对象转变为运行状态
        thread.start();

        // 线程启动后，处于运行状态
        System.out.println("线程处于运行状态");
    }
}

在这个示例中，我们创建了一个线程对象 thread，但此时线程对象处于新建状态。然后，我们调用 start() 方法启动线程，这会将线程对象转变为运行状态。一旦线程处于运行状态，它就有机会被操作系统调度并开始执行任务。

3.2 运行状态转换到阻塞状态

当线程运行时，如果遇到阻塞条件，会如何转变为阻塞状态？我们将详细探讨阻塞状态的产生及其解决方案。

public class RunnableToBlockedDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行任务...");

            // 模拟阻塞条件：线程休眠一段时间
            try {
                Thread.sleep(2000); // 线程休眠2秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 执行完阻塞操作后，线程继续执行任务
            System.out.println("线程继续执行任务...");
        });

        // 启动线程
        thread.start();

        // 主线程等待一段时间，然后检查线程状态
        try {
            Thread.sleep(1000); // 主线程休眠1秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，并在任务中模拟了一个阻塞条件：线程休眠2秒钟。在线程休眠期间，线程处于阻塞状态。主线程等待1秒钟后，通过检查线程状态来观察线程是否处于阻塞状态。

3.3 运行状态转换到等待状态

线程在运行时，如何转变为等待状态？通过实例演示，我们将揭晓等待状态的应用场景和解决方法。

public class RunnableToWaitingDemo {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程开始执行任务...");

                // 模拟等待条件：线程调用 wait() 方法进入等待状态
                try {
                    lock.wait(); // 线程等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                // 等待状态结束后，线程继续执行任务
                System.out.println("线程继续执行任务...");
            }
        });

        // 启动线程
        thread.start();

        // 主线程等待一段时间，然后检查线程状态
        try {
            Thread.sleep(1000); // 主线程休眠1秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，并在任务中模拟了一个等待条件：线程调用 wait() 方法进入等待状态。在等待状态期间，线程会等待其他线程通过 notify() 或 notifyAll() 方法来唤醒它。主线程等待1秒钟后，通过检查线程状态来观察线程是否处于等待状态。

3.4 运行状态转换到计时等待状态

计时等待状态是如何产生的？我们将通过具体案例，深入剖析计时等待状态的特点和使用方法。

public class RunnableToTimedWaitingDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行任务...");

            // 模拟计时等待条件：线程调用 sleep() 方法进入计时等待状态
            try {
                Thread.sleep(3000); // 线程休眠3秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 计时等待状态结束后，线程继续执行任务
            System.out.println("线程继续执行任务...");
        });

        // 启动线程
        thread.start();

        // 主线程等待一段时间，然后检查线程状态
        try {
            Thread.sleep(1000); // 主线程休眠1秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，并在任务中模拟了一个计时等待条件：线程调用 sleep() 方法进入计时等待状态，即线程会休眠3秒钟。在计时等待状态期间，线程不会执行任何操作，只是等待指定的时间。主线程等待1秒钟后，通过检查线程状态来观察线程是否处于计时等待状态。

3.5 运行状态转换到终止状态

线程运行结束后，如何转变为终止状态？我们将通过实际代码示例，为你展示线程如何优雅地结束生命周期。

public class RunnableToTerminatedDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行任务...");
            // 模拟线程执行任务
            for (int i = 0; i < 5; i++) {
                System.out.println("线程执行中：" + i);
                try {
                    Thread.sleep(1000); // 线程休眠1秒钟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程任务执行完毕。");
        });

        // 启动线程
        thread.start();

        // 等待线程执行完毕
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，执行完任务后线程即将进入终止状态。主线程调用 join() 方法等待线程执行完毕，然后通过检查线程状态来观察线程是否处于终止

四、五态的应用场景 🌐

除了了解状态转换的过程，我们还将深入研究线程状态在实际项目中的应用场景。通过大量实例，助你更好地理解线程状态在不同场景下的灵活应用。

1. 新建状态（New）：

  • 在多线程编程中，新建状态通常出现在创建线程对象后，但尚未调用 start() 方法启动线程的阶段。这种状态常见于线程池中的空闲线程对象。

2. 运行状态（Runnable）：

  • 运行状态是线程正在执行任务或等待执行的状态。这种状态在任何需要执行的线程中都会出现，例如，处理客户请求的服务器线程、执行计算任务的后台线程等。

3. 阻塞状态（Blocked）：

  • 阻塞状态是指线程因为某些条件无法继续执行而暂时停止运行的状态。在并发编程中，常见的阻塞情况包括等待锁资源、等待输入/输出完成等。

4. 等待状态（Waiting）：

  • 等待状态是指线程在等待其他线程的通知或条件满足时暂时停止执行的状态。例如，线程调用 wait() 方法进入等待状态，直到其他线程调用 notify() 或 notifyAll() 方法来唤醒它。

5. 计时等待状态（Timed Waiting）：

  • 计时等待状态是等待状态的一个特例，线程在等待某个条件的满足时可以设置一个超时时间，在超时时间内未满足条件则线程自动唤醒。这种状态常见于等待超时的场景，例如网络连接超时、任务执行超时等。

通过深入理解线程的五态及其在实际项目中的应用场景，我们可以更好地利用多线程编程来解决各种复杂的并发问题，提高程序的性能和可靠性。

五、JAVA五态面试题 ❓

在面试中，对线程状态的深入理解将为你赢得宝贵分数。本节将提供一些常见的线程状态面试题，帮助你在面试时从容应对，展现你在多线程编程领域的专业知识。

线程的五态指的是线程在操作系统中的五种状态，通常是新建、就绪、运行、阻塞和终止。在Java中，这些状态可以稍微不同，但是概念基本相同。

  1. 新建状态（New）：当线程对象被创建时，它处于新建状态。在这个状态下，操作系统为线程分配了资源，但尚未执行线程的run()方法。

  2. 就绪状态（Runnable）：线程处于就绪状态时，表示线程已经准备好运行，但尚未获得 CPU 时间片。当线程处于就绪状态时，它等待操作系统分配 CPU 资源。

  3. 运行状态（Running）：线程处于运行状态时，表示它正在执行其run()方法中的代码，并且正在使用 CPU 执行指令。

  4. 阻塞状态（Blocked）：线程处于阻塞状态时，表示线程暂时无法执行。这可能是由于等待输入/输出、等待获取锁、等待其他线程的通知等原因造成的。线程在此状态下会暂时释放CPU资源。

  5. 终止状态（Terminated）：线程处于终止状态时，表示线程执行完了run()方法中的所有代码，或者因为异常等原因提前结束了。在这个状态下，线程将被销毁，释放所有的资源。

线程如何从新建状态转变为运行状态？

  • 线程从新建状态转变为运行状态通常是通过调用start()方法来启动线程。这会导致线程进入就绪状态，然后根据CPU调度器的调度，进入运行状态。

线程如何从运行状态转变为阻塞状态？

  • 线程从运行状态转变为阻塞状态通常是由于某些阻塞操作，例如等待输入/输出或等待获取锁。一旦线程执行了这些操作，它将进入阻塞状态，等待条件满足或锁释放。

线程如何从运行状态转变为等待状态？

  • 线程从运行状态转变为等待状态通常是通过调用wait()方法来等待某些条件的发生。在这种情况下，线程会释放它所持有的锁，并进入等待状态，直到其他线程唤醒它。

线程如何从运行状态转变为计时等待状态？

  • 线程从运行状态转变为计时等待状态通常是通过调用sleep()方法或者指定等待时间的wait()方法。线程在这种状态下会暂停执行一段时间，然后根据指定的时间重新进入就绪状态。

线程如何从运行状态转变为终止状态？

  • 线程从运行状态转变为终止状态通常是因为线程执行完了其run()方法中的所有代码，或者因为发生了未捕获的异常导致线程提前结束。在这种情况下，线程将进入终止状态并释放所有资源。

在Java中，线程如何被唤醒？

  • 在Java中，线程可以通过调用notify()、notifyAll()或者interrupt()方法来唤醒。这些方法可以在等待状态下的线程被其他线程唤醒，使其重新进入就绪状态。

在Java中，如何检查线程的状态？

  • 在Java中，可以通过Thread类的getState()方法来检查线程的状态。该方法返回一个枚举值，表示线程的当前状态。

线程的状态转换是同步的还是异步的？为什么？

  • 线程的状态转换通常是异步的，因为线程的状态转换受到操作系统和CPU调度器的管理。线程的状态转换不受程序控制，而是由操作系统和CPU调度器决定。因此，线程的状态转换是异步的。

在Java中，如何避免线程死锁？

  • 要避免线程死锁，可以采取以下措施：
    1. 避免嵌套锁，即在持有一个锁的情况下再去申请另一个锁。
    2. 使用线程安全的并发工具，如ConcurrentHashMap、CopyOnWriteArrayList等，它们内部实现了避免死锁的机制。
    3. 使用try-with-resources或手动释放锁，确保在使用锁的过程中，锁能够被正确释放，不会因为异常而造成死锁。
    4. 使用同步代码块时，确保锁的获取顺序是一致的，避免不同线程获取锁的顺序不一致导致死锁的发生。

六、总结 🎉

通过本文的学习，相信你已经对Java线程的三态和五态有了更深入的认识。从基础概念到实际应用，我们一起揭示了线程状态的方方面面。让我们在总结中回顾一下重要的知识点，为未来的多线程编程之旅画上精彩的句号。

参考资料

在编写本文时，我参考了许多优秀的教材和在线文档。如果你对Java线程状态还有更多的疑问或想深入学习，可以查阅以下参考资料：

  • Java多线程编程实战
  • 《Java并发编程的艺术》 - 作者：方腾飞

希望这篇博客能够为你在Java线程状态的学习之路上提供充足的帮助。如果有任何问题或建议，欢迎留言讨论，我们一起进步！ 🌟

在这里插入图片描述

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🍁🐥

如对本文内容有任何疑问、建议或意见，请联系作者，作者将尽力回复并改进📓；(联系微信:Solitudemind )

点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/384100.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

鸿蒙开发理论之页面和自定义组件生命周期

鸿蒙开发理论之页面和自定义组件生命周期

1、自定义组件和页面的关系 页面&#xff1a;即应用的UI页面。可以由一个或者多个自定义组件组成&#xff0c;Entry装饰的自定义组件为页面的入口组件&#xff0c;即页面的根节点&#xff0c;一个页面有且仅能有一个Entry。只有被Entry装饰的组件才可以调用页面的生命周期。自…
阅读更多...
University Program VWF仿真步骤__全加器

University Program VWF仿真步骤__全加器

本教程将以全加器为例&#xff0c;选择DE2-115开发板的Cyclone IV EP4CE115F29C7 FPGA&#xff0c;使用Quartus Lite v18.1&#xff0c;循序渐进的介绍如何创建Quartus工程&#xff0c;并使用Quartus Prime软件的University Program VWF工具创建波形文件&#xff0c;对全加器的…
阅读更多...
Qt【一】：Qt3个窗口类的区别、VS与QT项目转换

Qt【一】：Qt3个窗口类的区别、VS与QT项目转换

一、Qt3个窗口类的区别 QMainWindow&#xff1a;包含菜单栏、工具栏、状态栏 QWidget&#xff1a;普通的一个窗口&#xff0c;什么也不包括 QDialog&#xff1a;对话框&#xff0c;常用来做登录窗口、弹出窗口&#xff08;例如设置页面&#xff09; QDialog实现简易登录界面…
阅读更多...
DP读书：《openEuler操作系统》（九）从IPC到网卡到卡驱动程序

DP读书：《openEuler操作系统》（九）从IPC到网卡到卡驱动程序

DP读书&#xff1a;《openEuler操作系统》从IPC到网卡到卡驱动程序&#xff09; 上章回顾_SPI上节回顾_TCP 网卡驱动程序简介1.设备驱动2.总线与设备3.网卡及其抽象 驱动程序的注册与注销1. 注册2. 注销 设备初始化1. 硬件初始化2. 软件初始化 设备的打开与关闭1. 设备的打开2.…
阅读更多...
「小明赠书活动」2024第三期《一书读懂物联网：基础知识+运行机制+工程实现》

「小明赠书活动」2024第三期《一书读懂物联网：基础知识+运行机制+工程实现》

⭐️ 赠书 - 《一书读懂物联网&#xff1a;基础知识运行机制工程实现》 《一书读懂物联网》以物联网工程技术为核心内容&#xff0c;结合数据处理的流程和技术&#xff0c;介绍了物联网的基础知识、运行机制及工程实现。 ⭐️ 内容简介 - 《一书读懂物联网&#xff1a;基础知识…
阅读更多...
【后端高频面试题--设计模式上篇】

【后端高频面试题--设计模式上篇】

&#x1f680; 作者 &#xff1a;“码上有前” &#x1f680; 文章简介 &#xff1a;后端高频面试题 &#x1f680; 欢迎小伙伴们 点赞&#x1f44d;、收藏⭐、留言&#x1f4ac; 什么是设计模式&#xff1f;怎么理解设计模式&#xff1f; 设计模式是在软件设计中&#xff0c…
阅读更多...
OpenSSL 创建自签名证书

OpenSSL 创建自签名证书

前言 Openssl 是一个方便的实用程序，用于创建自签名证书。您可以在所有操作系统（如 Windows、MAC 和 Linux 版本）上使用 OpenSSL。 自签名证书 创建我们自己的根 CA 证书和 CA 私钥（我们自己充当 CA）创建服务器私钥以生成 CSR使用我们的根 CA 和 CA 私钥创建具有 CSR 的…
阅读更多...
甘肃旅游服务平台：技术驱动的创新实践

甘肃旅游服务平台：技术驱动的创新实践

✍✍计算机编程指导师 ⭐⭐个人介绍&#xff1a;自己非常喜欢研究技术问题&#xff01;专业做Java、Python、微信小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。 ⛽⛽实战项目&#xff1a;有源码或者技术上的问题欢迎在评论区一起讨论交流&#xff01; ⚡⚡ Java实战 |…
阅读更多...
写的太通透了！大模型自省式 RAG 与 LangGraph 的实践！

写的太通透了！大模型自省式 RAG 与 LangGraph 的实践！

本文讲解了自省式 RAG 的基础原理以及基于 LangGraph 的实践演示 自省式 RAG 与 LangGraph 重要链接 关于 Self-RAG 和 CRAG 的教程手册 演示视频 研究背景 由于大多数大型语言模型&#xff08;LLMs&#xff09;通常只针对大量公共数据进行周期性训练&#xff0c;它们往往…
阅读更多...
电路设计（16）——纪念馆游客进出自动计数显示器proteus仿真

电路设计（16）——纪念馆游客进出自动计数显示器proteus仿真

1.设计要求 设计、制作一个纪念馆游客进出自动计数显示器。 某县&#xff0c;有一个免费参观的“陶渊明故里纪念馆”&#xff0c;游客进出分道而行&#xff0c;如同地铁有确保单向通行的措施。在入口与出口处分别设有红外检测、声响、累加计数器装置&#xff0c;当游人进&#…
阅读更多...
ChatGLM2-6B模型的win10测试笔记

ChatGLM2-6B模型的win10测试笔记

ChatGLM2-6B介绍&#xff1a; 介绍 ChatGLM2-6B 是开源中英双语对话模型 ChatGLM-6B 的第二代版本&#xff0c;在保留了初代模型对话流畅、部署门槛较低等众多优秀特性的基础之上&#xff0c;ChatGLM2-6B 引入了如下新特性&#xff1a; 更强大的性能&#xff1a;基于 ChatGLM 初…
阅读更多...
服务异步通信

服务异步通信

服务异步通信 消息队列在使用过程中&#xff0c;面临着很多实际问题需要思考&#xff1a; 1.消息可靠性 消息从发送&#xff0c;到消费者接收&#xff0c;会经理多个过程&#xff1a; 其中的每一步都可能导致消息丢失&#xff0c;常见的丢失原因包括&#xff1a; 发送时丢失…
阅读更多...
app逆向-⽹络请求库okhttp3

app逆向-⽹络请求库okhttp3

文章目录 一、前言二、应用GET请求1、添加权限AndroidManifest.xml2、添加依赖okhttp33、编写界面文件activity_main.xml4、编写Activity代码5、效果 三、应用POST请求四、okhttp3请求拦截器 一、前言 OkHttp是由Square公司开发的用于Java和Android的开源HTTP客户端库。它被广…
阅读更多...
leetcode链表相关题目

leetcode链表相关题目

文章目录 1.移除链表元素方法1&#xff1a;方法2 2.合并两个有序链表3.链表的中间节点方法1方法2 4.反转单链表方法1方法2 5.分割链表6.链表中的倒数第k个节点方法1&#xff1a;方法2: 7.环形链表的约瑟夫问题8.链表的回文结构9.相交链表方法1方法2&#xff1a; 10.环形链表11.…
阅读更多...
python接口自动化（三）--如何设计接口测试用例（详解）

python接口自动化（三）--如何设计接口测试用例（详解）

在开始接口测试之前&#xff0c;我们来想一下&#xff0c;如何进行接口测试的准备工作。或者说&#xff0c;接口测试的流程是什么&#xff1f;有些人就很好奇&#xff0c;接口测试要流程干嘛&#xff1f;不就是拿着接口文档直接利用接口 测试工具测试嘛。其实&#xff0c;如果…
阅读更多...
关于物理机ping不通虚拟机问题

关于物理机ping不通虚拟机问题

方法一 设置虚拟机处于桥接状态即可&#xff1a;&#xff08;虚拟机->设置->网络适配器&#xff09;&#xff0c;选择完确定&#xff0c;重启虚拟机即可。 方法二 如果以上配置还是无法ping通&#xff1a;&#xff08;编辑->虚拟网络编辑器&#xff09; 首先查看主机网…
阅读更多...
MySQL（基础）

MySQL（基础）

第01章_数据库概述 1. 为什么要使用数据库 持久化(persistence)&#xff1a;把数据保存到可掉电式存储设备中以供之后使用。大多数情况下&#xff0c;特别是企业级应用&#xff0c;数据持久化意味着将内存中的数据保存到硬盘上加以”固化”&#xff0c;而持久化的实现过程大多…
阅读更多...
C++11中的简化声明

C++11中的简化声明

auto 用于自动类型推断&#xff0c;显示定义变量&#xff1a; typeid typeid推导出来的是字符串&#xff0c;只能看不能用&#xff0c;通过打印来查看变量的类型&#xff0c;用法如上。 decltype 同样是用来自动推导类型&#xff0c;与auto的区别是&#xff0c;auto在定义时必…
阅读更多...
DAY9.

DAY9.

1.选择芯片型号 2. 3. 4. 5. 6. 7.
阅读更多...
MOCO动量编码

MOCO动量编码

参考&#xff0c;推荐阅读 李沐论文精读系列三&#xff1a;MoCo、对比学习综述&#xff08;MoCov1/v2/v3、SimCLR v1/v2、DINO等&#xff09;_moco 对比学习-CSDN博客 背景 1. MOCO CVPR 2020 2. 对比学习&#xff1a;无监督学习的一种&#xff0c;重点学习同类实例中的共同…
阅读更多...
最新文章

Copyright @ 2022~2023