【昕宝爸爸小模块】线程的几种状态，状态之间怎样流转

news2025/1/21 11:30:41

在这里插入图片描述

➡️博客首页       https://blog.csdn.net/Java_Yangxiaoyuan


       欢迎优秀的你👍点赞、🗂️收藏、加❤️关注哦。


       本文章CSDN首发，欢迎转载，要注明出处哦！


       先感谢优秀的你能认真的看完本文，有问题欢迎评论区交流，都会认真回复！


线程的几种状态，状态之间怎样流转

  • 一、✅典型解析
    • 1.1 ✅线程的优先级对程序的性能有什么影响
    • 1.2 ✅ 线程优先级影响内存使用的原因是什么
    • 1.3 ✅优先级越高,线程越容易被调度到吗
    • 1.4 ✅线程的优先级是根据什么决定的呢
    • 1.5 ✅如何避免线程优先级和内存使用之间的关联
  • 二、✅拓展知识仓
    • 2.1 ✅WAITING和TIMED_WAIT的区别?
    • 2.2 ✅为什么线程没有RUNNING状态


一、✅典型解析


Java中线程的状态分为六种：


  • 初始(NEW): 新创建了一个线程对象，但还没有调用start()方法。
  • 运行(RUNNABLE): Java线程中将就绪 (READY) 和运行中(RUNNING) 两种状态笼统的称为 “ 运行 " 。

就绪(READY): 线程对象创建后，其他线程(比如main线程) 调用了该对象的start0方法。该状态的线程位于可运行线程池中，等待被线程调度选中并分配cpu使用权。

运行中 (RUNNING): 就绪(READY)的线程获得了cpu 时间片，开始执行程序代码。

  • 阻塞(BLOCKED): 表示线程阻塞于锁 (关于锁，在后面章节会介绍) 。
  • 等待(WAITING): 进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
  • 超时等待(TIMED WAITING): 该状态不同于WAITING，它可以在指定的时间后自行返回。
  • 终止(TERMINATED): 表示该线程已经执行完毕。

状态流转如图:


在这里插入图片描述


1.1 ✅线程的优先级对程序的性能有什么影响


线程的优先级对程序的性能有很大影响。影响的一些关键点：

  1. 响应速度和吞吐量：优先级较高的线程在多线程环境中通常能够更快地执行任务，从而提高程序的响应速度和吞吐量。这是因为操作系统会为优先级较高的线程分配更多的CPU时间片，使其能够更快地完成任务。
  2. 执行顺序：在多线程编程中，有些任务需要按照一定的顺序执行。通过设置线程的优先级，可以控制线程的执行顺序，从而满足任务的需求。
  3. 避免线程饥饿：如果某个线程的优先级过低，它可能会长时间得不到足够的CPU资源，从而导致线程饥饿现象。使用线程优先级可以避免这种情况，保证程序的稳定性和正确性。

然而，需要注意的是，过度调整线程优先级可能会带来一些问题。例如，如果将某个线程的优先级设置得过高，可能会导致其他线程得不到足够的CPU资源，从而影响它们的性能。此外，不同的操作系统和线程调度器对线程优先级的处理方式可能不同，因此在实际应用中需要考虑到这些因素。


总的来说，合理地设置线程优先级可以帮助提高程序的性能和响应速度，但需要根据实际应用场景和需求进行适当的调整。在某些情况下，使用默认的线程优先级就已经足够好。


Demo：


/**
* @author xinbaobaba
* 使用Java代码来解释线程优先级对程序性能影响的示例
*/

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread A: " + i);
            }
        }, "Thread A");

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread B: " + i);
            }
        }, "Thread B");

        Thread threadC = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread C: " + i);
            }
        }, "Thread C");

        // 设置线程优先级
        threadA.setPriority(Thread.MAX_PRIORITY); // 高优先级
        threadB.setPriority(Thread.NORM_PRIORITY); // 正常优先级
        threadC.setPriority(Thread.MIN_PRIORITY); // 低优先级

        // 启动线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

代码解析：创建了三个线程，分别命名为"Thread A"、“Thread B"和"Thread C”。然后，我们为这三个线程设置了不同的优先级：Thread A 是高优先级，Thread B 是正常优先级，Thread C 是低优先级。最后，我们启动这三个线程。


由于线程的优先级不同，它们的执行顺序和执行时间也会有所不同。高优先级的线程会比低优先级的线程更快地执行完毕。因此，程序的性能和响应速度会受到线程优先级的影响。


输出结果可能类似于以下内容：


Thread A: 0
Thread A: 1
Thread A: 2
... (其他 Thread A 的输出)
Thread B: 0
Thread B: 1
Thread B: 2
... (其他 Thread B 的输出)
Thread C: 0
Thread C: 1
Thread C: 2
... (其他 Thread C 的输出)

可以看到，高优先级的 Thread A 先于其他线程执行，然后是正常优先级的 Thread B，最后是低优先级的 Thread C。这是因为操作系统会根据线程的优先级分配CPU时间片，优先级高的线程会获得更多的CPU时间，从而更快地执行任务。这影响了程序的性能和响应速度。


1.2 ✅ 线程优先级影响内存使用的原因是什么


线程优先级影响内存使用的原因在于，线程在执行过程中需要占用内存资源。具体来说，每个线程在执行时都需要分配一定的内存空间，包括栈空间和堆空间等。线程优先级高的线程会获得更多的CPU时间，从而更快地执行任务，这可能导致优先级高的线程在较短的时间内占用了更多的内存资源。


在多线程程序中，如果大量高优先级的线程同时运行，它们可能会迅速地消耗掉可用的内存资源，导致系统频繁地进行内存分配和垃圾回收操作，这不仅会影响程序的性能，还可能引发内存溢出等问题。因此，合理地设置线程优先级，并配合其他并发控制手段，可以有效地管理内存使用，提高程序的稳定性和性能。


Demo：


首先，要理解Java中的线程优先级，你需要了解Java线程调度器的行为。在Java中，线程调度器是一个在操作系统之上的抽象，它决定了哪些线程可以在特定时间运行。每个线程都有一个优先级，优先级决定了线程调度器在选择要运行的线程时的考虑因素。

Java定义了10个不同的优先级，从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。默认情况下，所有线程的优先级都是Thread.NORM_PRIORITY（5）。

以下是一个简单的Java代码示例，演示如何设置线程优先级：



/**
* @author xinbaobaba
* 如何在Java中使用线程优先级以及如何通过调整线程优先级来影响内存使用
*/
public class ThreadPriorityExample {
    public static void main(String[] args) {
        // 创建线程并设置优先级
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread A: " + i);
            }
        });
        threadA.setPriority(Thread.MAX_PRIORITY); // 设置线程A的优先级为最高

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread B: " + i);
            }
        });
        threadB.setPriority(Thread.NORM_PRIORITY); // 设置线程B的优先级为正常

        Thread threadC = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread C: " + i);
            }
        });
        threadC.setPriority(Thread.MIN_PRIORITY); // 设置线程C的优先级为最低

        // 启动线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

现在，关于如何通过调整线程优先级来影响内存使用，这里有一些考虑因素：


  1. 堆栈大小：线程的优先级会影响到JVM为其分配的堆栈大小。高优先级的线程通常会获得更大的堆栈空间。如果大量高优先级的线程同时运行，它们可能会消耗掉大量的内存资源。因此，在设置线程优先级时，需要考虑到程序的内存需求和可用内存。
  2. 上下文切换：高优先级的线程更容易获得CPU时间，这意味着它们更频繁地运行和休眠，这可能导致更多的上下文切换。上下文切换需要保存和恢复线程的执行环境，这会增加CPU的负载和内存消耗。因此，不当地设置线程优先级可能会对程序的性能产生负面影响。
  3. 垃圾回收：当一个线程分配了大量的内存空间时，垃圾回收器需要更频繁地运行以回收不再使用的内存。这可能会导致垃圾回收器在高优先级线程活跃时运行得更加频繁，从而影响程序的性能。因此，在设计多线程程序时，应该注意控制内存分配，以减少垃圾回收的频率和影响。

1.3 ✅优先级越高,线程越容易被调度到吗


优先级越高的线程在大多数操作系统中更容易被调度。优先级决定了线程在调度时的优先顺序，优先级高的线程会比优先级低的线程获得更多的CPU时间。


注意：优先级高的线程并不一定总是先于低优先级的线程执行。线程调度器会根据调度算法和系统负载等多种因素来决定线程的执行顺序。此外，不同的操作系统和硬件平台可能会有不同的调度行为。


因此，虽然优先级高的线程更容易被调度，但并不能保证它们一定先于低优先级的线程执行。在设计程序时，应该避免过度依赖线程优先级来优化性能，而是应该综合考虑代码设计、数据结构和算法优化、同步机制等方面的因素。


Demo：


import java.util.concurrent.*;

/**
* @author xinbaobaba
* 如何使用Java的并发工具和内存管理机制来优化内存使用和程序性能
*/
public class ComplexThreadPriorityExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建任务并提交到线程池执行
        Future<?> futureA = executor.submit(() -> {
            // 模拟内存密集型任务
            for (int i = 0; i < 1000; i++) {
                System.out.println("Task A: " + i);
            }
        });

        Future<?> futureB = executor.submit(() -> {
            // 模拟CPU密集型任务
            int sum = 0;
            for (int i = 0; i < 100000; i++) {
                sum += i; // 模拟CPU密集型计算任务
            }
            System.out.println("Task B: " + sum);
        });

        Future<?> futureC = executor.submit(() -> {
            // 模拟I/O密集型任务
            try {
                Thread.sleep(5000); // 休眠5秒，模拟I/O密集型任务等待时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task C: Completed");
        });

        // 获取任务的执行结果（如果需要）
        try {
            System.out.println("Task A result: " + futureA.get()); // 等待任务A执行完成并获取结果（如果有返回值）
            System.out.println("Task B result: " + futureB.get()); // 等待任务B执行完成并获取结果（如果有返回值）
            System.out.println("Task C result: " + futureC.get()); // 等待任务C执行完成并获取结果（如果有返回值）
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池，释放资源
            executor.shutdown();
        }
    }
}

代码解析：使用了Java的ExecutorService来创建固定大小的线程池，并提交任务到线程池执行。这样可以更好地管理线程的执行，避免线程过多导致资源竞争和内存问题。每个任务模拟了不同类型的任务：内存密集型、CPU密集型和I/O密集型。通过合理地组织任务的执行顺序和利用线程池，我们可以优化内存使用和程序性能。


1.4 ✅线程的优先级是根据什么决定的呢


线程的优先级是根据多种因素决定的，其中一些因素包括线程的属性、任务紧急程度、线程的执行历史记录等。在Java中，线程优先级是一个从1到10的整数，其中1是最低优先级，10是最高优先级。默认情况下，线程的优先级为5。线程优先级是调度程序选择运行哪个线程的一个关键因素。调度程序会根据优先级、任务的紧急程度和其他因素来决定线程的执行顺序。高优先级的线程通常会更有可能获得CPU时间，而低优先级的线程可能会被调度程序推迟执行。需要注意的是，线程优先级并不能保证线程的执行顺序，因为线程的执行还受到其他因素的影响，如系统负载、其他线程的执行情况等。


1.5 ✅如何避免线程优先级和内存使用之间的关联


为了避免线程优先级和内存使用之间的关联，可以采取以下措施：


  1. 合理设置线程优先级：不要过度依赖线程优先级来优化性能。优先级高的线程可能会获得更多的CPU时间，但并不意味着它可以更有效地使用内存。相反，过度调整线程优先级可能会导致线程调度的不稳定和其他问题。
  2. 使用适当的同步机制：当多个线程访问和修改共享资源时，需要使用适当的同步机制（如互斥锁、条件变量等）来避免死锁和资源竞争。这样可以确保线程安全地访问内存，并减少不必要的内存占用。
  3. 优化数据结构和算法：通过优化数据结构和算法，可以减少线程对内存的需求。例如，使用更高效的数据结构、减少不必要的内存分配等。
  4. 使用内存管理工具：使用操作系统提供的内存管理工具来监控和分析内存使用情况。这可以帮助你识别和解决内存泄漏、过度分配等问题。
  5. 编写良好的并发代码：编写高质量的并发代码可以减少线程间的竞争和同步问题，从而降低内存使用的风险。遵循最佳实践，如避免数据竞态条件、正确使用锁等。
  6. 测试和性能分析：通过测试和性能分析来评估线程优先级和内存使用之间的关系。通过收集性能数据并进行分析，可以找到潜在的性能瓶颈和内存问题，并采取相应的优化措施。

总之，避免线程优先级和内存使用之间的关联需要综合考虑多个方面，包括代码设计、同步机制、数据结构和算法优化等。通过合理的编程实践和性能分析，可以有效地管理内存并提高程序的性能。


Demo：


当涉及到线程优先级和内存使用之间的关联时，Java 提供了丰富的并发编程工具和内存管理机制。



/**
* @author xinbaobaba
* 使用Java代码来解释如何避免线程优先级和内存使用之间关联
*/
public class ThreadPriorityExample {
    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 模拟内存密集型任务
                System.out.println("Thread A: " + i);
                try {
                    Thread.sleep(100); // 休眠100毫秒，模拟内存密集型任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread A");

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 模拟CPU密集型任务
                System.out.println("Thread B: " + i);
                int sum = 0;
                for (int j = 0; j < 10000; j++) {
                    sum += j; // 模拟CPU密集型计算任务
                }
            }
        }, "Thread B");

        Thread threadC = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 模拟I/O密集型任务
                System.out.println("Thread C: " + i);
                try {
                    Thread.sleep(500); // 休眠500毫秒，模拟I/O密集型任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread C");

        // 设置线程优先级（但Java不推荐设置线程优先级）
        // threadA.setPriority(Thread.MAX_PRIORITY); // 高优先级
        // threadB.setPriority(Thread.NORM_PRIORITY); // 正常优先级
        // threadC.setPriority(Thread.MIN_PRIORITY); // 低优先级

        // 启动线程（使用Executor框架）
        ExecutorService executor = Executors.newFixedThreadPool(3); // 创建固定大小的线程池
        executor.execute(threadA); // 提交线程任务到线程池执行
        executor.execute(threadB);
        executor.execute(threadC);
        executor.shutdown(); // 关闭线程池，等待所有任务执行完毕
    }
}

代码解析：创建了三个线程：Thread A、Thread B 和 Thread C，分别模拟内存密集型、CPU密集型和I/O密集型任务。我们没有设置线程优先级，而是使用了Java的Executor框架来管理线程的执行。通过这种方式，我们避免了直接设置线程优先级，而是通过合理地组织任务的执行顺序和利用线程池来优化内存使用。


注意：Java并不推荐直接设置线程优先级，因为不同的JVM实现和操作系统可能会有不同的行为。相反，推荐使用Java提供的并发工具和内存管理机制来优化内存使用和程序性能。


二、✅拓展知识仓


2.1 ✅WAITING和TIMED_WAIT的区别?


WAITING是等待状态，在Java中，调用wait方法时，线程会进入到WAITING状态，而TIMED_WAITING是超时等待状态，当线程执行sleep方法时，线程会进入TIMED_WAIT状态


处于WAITING和TIMED_WAIT的线程，都是会让出CPU的，这时候其他线程就可以获得CPU时间片开始执行。但是他们在对象的锁释放上面并不一样，如果加了锁，sleep方法不会释放对象上的锁，而wait方法是会释放锁的。


因为Java锁的目标是对象，所以wait、notifv和notifyAll针对的目标都是对象，所以把他们定义在Object类中。而sleep不需要释放锁，所以他是Thread类中的一人方法。


2.2 ✅为什么线程没有RUNNING状态


对于现在的分时操作系统来说，在单CPU情况下，所有的线程其实都是串行执行的。但是为了让我们看起来像是在并发执行，人们把CPU的执行分成很多个小的时间片。


哪个线程得到时间片，那个线程就执行，时间片到了之后，就要释放出CPU，再重新进行争抢时间片。


只要把时间片划分的足够细，那么多个程序虽然在不断的串行执行，但是看起来也像是在同时执行样。


在这里插入图片描述

那么，CPU的时间片其实是很短的，一般也就是10-20毫秒左右。


那么，也就是说，在一秒钟之内，同一个线程可能一部分时间处于READY状态、一部分时间处于RUNNING状态。


那么如果，明确的给线程定义出RUNNING状态的话，有一个很大的问题，就是这个状态其实是不准的。


因为当我们看到线程是RUNNING状态的时候，很有可能他已经丢失了CPU时间片了。


对于线程的状态，我们只需要知道，他当前有没有在"正在参与执行"就行了，何为"参与执行"?


就是他的状态是可执行的，只要获得时间片，就能立即执行。


那这不就是RUNNABLE吗?


所以，Java就没有给线程定义RUNNING状态，而是定义了一个RUNNABLE状态


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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

react项目运行卡在编译：您当前运行的TypeScript版本不受@TypeScript eslint/TypeScript estree的官方支持

react项目运行卡在编译：您当前运行的TypeScript版本不受@TypeScript eslint/TypeScript estree的官方支持

1.问题 错误信息具体如下&#xff1a; 搜索了一下&#xff0c;是typescript版本的问题&#xff0c;提示我版本需要在3.3.0和4.5.0中间&#xff0c;我查看了package.json&#xff0c;显示版本为4.1.3&#xff0c;然后一直给我提示我的版本是4.9.5&#xff0c;全局搜索一下&…
阅读更多...
读写分离的手段——主从复制，解决读流量大大高于写流量的问题

读写分离的手段——主从复制，解决读流量大大高于写流量的问题

应用场景 假设说有这么一种业务场景&#xff0c;读流量显著高于写流量&#xff0c;你要怎么优化呢。因为写是要加锁的&#xff0c;可能就会阻塞你读请求。而且其实读多写少的场景还很多见&#xff0c;比如电商平台&#xff0c;用户浏览n多个商品才会买一个。 大部分人的思路可…
阅读更多...
智慧园区数字孪生智能可视运营平台解决方案：PPT全文82页，附下载

智慧园区数字孪生智能可视运营平台解决方案：PPT全文82页，附下载

关键词&#xff1a;智慧园区解决方案&#xff0c;数字孪生解决方案&#xff0c;数字孪生应用场景及典型案例&#xff0c;数字孪生可视化平台&#xff0c;数字孪生技术&#xff0c;数字孪生概念&#xff0c;智慧园区一体化管理平台 一、基于数字孪生的智慧园区建设目标 1、实现…
阅读更多...
Linux-命名管道

Linux-命名管道

文章目录 前言一、命名管道接口函数介绍二、使用步骤 前言 上章内容&#xff0c;我们介绍与使用了管道。上章内容所讲的&#xff0c;是通过pipe接口函数让操作系统给我们申请匿名管道进行进程间通信。 并且这种进程间通信一般只适用于父子进程之间&#xff0c;那么对于两个没有…
阅读更多...
什么是二分查找

什么是二分查找

一、是什么 在计算机科学中&#xff0c;二分查找算法&#xff0c;也称折半搜索算法&#xff0c;是一种在有序数组中查找某一特定元素的搜索算法 想要应用二分查找法&#xff0c;则这一堆数应有如下特性&#xff1a; 存储在数组中有序排序 搜索过程从数组的中间元素开始&…
阅读更多...
Python-AST语法树

Python-AST语法树

一、抽象语法树 1、什么是抽象语法树 在计算机科学中&#xff0c;抽象语法树&#xff08;abstract syntax tree &#xff0c;AST&#xff09;&#xff0c;是源代码的抽象语法结构的树状表现形式&#xff0c;这里特指编程语言的源代码。AST是编译器或解释器在处理源代码时所使…
阅读更多...
＜软考高项备考＞《论文专题 - 65 质量管理（4） 》

＜软考高项备考＞《论文专题 - 65 质量管理（4） 》

4 过程3-管理质量 4.1 问题 4W1H过程做什么为了评估绩效&#xff0c;确保项目输出完整、正确且满足客户期望&#xff0c;而监督和记录质量管理活动执行结果的过程作用&#xff1a;①核实项目可交付成果和工作已经达到主要干系人的质量要求&#xff0c;可供最终验收;②确定项目…
阅读更多...
class_4:car类

class_4:car类

#include <iostream> using namespace std; class Car{ public://成员数据string color; //颜色string brand; //品牌string type; //车型int year; //年限//其实也是成员数据&#xff0c;指针变量&#xff0c;指向函数的变量&#xff0c;并非真正的成员函数void (*…
阅读更多...
剪映国际版，免费无限制使用

剪映国际版，免费无限制使用

随着抖音的爆火短视频的崛起&#xff0c;相信每一个人都感受到了短视频快节奏下的生活洪流。 现如今每个人都能成为自己生活的记录者&#xff0c;每一个人都有掌握着剪辑的基本技能。而剪映就是很多人都会使用的剪辑软件。 相对于PR、AE等剪辑软件来说&#xff0c;作为一款国…
阅读更多...
读《Open-Vocabulary Video Anomaly Detection》

读《Open-Vocabulary Video Anomaly Detection》

2023 西北工业大学和新大 引言 视频异常检测(VAD)旨在检测不符合预期模式的异常事件&#xff0c;由于其在智能视频监控和视频内容审查等应用前景广阔&#xff0c;已成为学术界和工业界日益关注的问题。通过几年蓬勃发展&#xff0c;VAD 在许多不断涌现的工作中取得了重大进展。…
阅读更多...
spring-mvc(1):Hello World

spring-mvc(1):Hello World

虽然目前大多数都是使用springboot来开发java程序&#xff0c;或者使用其来为其他端提供接口&#xff0c;而为其他端提供接口&#xff0c;这些功能都是依靠springmvc实现的&#xff0c;所以有必要学习一下spring-mvc&#xff0c;这样才能更好的学习springboot。 一&#xff0c…
阅读更多...
好物周刊#36：程序员简历

好物周刊#36：程序员简历

村雨遥的好物周刊&#xff0c;记录每周看到的有价值的信息&#xff0c;主要针对计算机领域&#xff0c;每周五发布。 一、项目 1. SmartDNS 一个运行在本地的 DNS 服务器&#xff0c;它接受来自本地客户端的 DNS 查询请求&#xff0c;然后从多个上游 DNS 服务器获取 DNS 查询…
阅读更多...
陶瓷碗口缺口检测-图像分割

陶瓷碗口缺口检测-图像分割

图像分割 由于对碗口进行缺口检测&#xff0c;因此只需要碗口的边界信息。得到陶瓷碗区域填充后的图像&#xff0c;对图像进行边缘检测。这是属于图像分割中的内容&#xff0c;在图像的边缘中&#xff0c;可以利用导数算子对数字图像求差分&#xff0c;将边缘提取出来。 本案…
阅读更多...
案例：新闻数据加载

案例：新闻数据加载

文章目录 介绍相关概念相关权限约束与限制完整示例 代码结构解读构建主界面数据请求下拉刷新总结 介绍 本篇Codelab是基于ArkTS的声明式开发范式实现的样例&#xff0c;主要介绍了数据请求和touch事件的使用。包含以下功能&#xff1a; 数据请求。列表下拉刷新。列表上拉加载…
阅读更多...
基于面向对象，C++实现双链表

基于面向对象，C++实现双链表

双链表同单链表类似&#xff0c;由一个值和两个指针组成 Node.h节点头文件 #pragma once class Node { public:int value;Node* prev;Node* next;Node(int value);~Node(); };Node.cpp节点源文件 #include "Node.h"Node::Node(int value) {this->value value…
阅读更多...
Python-高阶函数

Python-高阶函数

在Python中&#xff0c;高阶函数是指能够接收函数作为参数&#xff0c;或者能够返回函数的函数。这种特性使得函数在Python中可以被灵活地传递和使用。以下是一些关于Python高阶函数的详细解释&#xff1a; 函数作为参数&#xff1a; 高阶函数可以接收其他函数作为参数。这样的…
阅读更多...
C语言 - 最简单，最易懂的指针、引用讲解

C语言 - 最简单，最易懂的指针、引用讲解

一、变量、地址、变量值 二、直接上代码&#xff0c;一边看上图&#xff0c;一边讲解 #include <stdio.h>struct Hello {int a;int b; };int main() {struct Hello h;h.a 10;h.b 20;struct Hello *hp;hp &h;printf("1: h的地址是%d&#xff0c;hp地址是%d \…
阅读更多...
89.乐理基础-记号篇-省略记号-震音、音型与小节反复

89.乐理基础-记号篇-省略记号-震音、音型与小节反复

内容参考于&#xff1a;三分钟音乐社 上一个内容&#xff1a;88.乐理基础-记号篇-反复记号&#xff08;二&#xff09;D.C.、D.S.、Fine、Coda-CSDN博客 省略记号总结图&#xff1a;有些素材会把它们归纳到反复记号里&#xff0c;因为它们也涉及到 重复、反复的概念&#xff…
阅读更多...
Open3D 两片点云的最小/最大距离（23）

Open3D 两片点云的最小/最大距离（23）

Open3D 两片点云的最小/最大距离（23） 一、效果展示二、使用步骤1.代码三、cloudcompare量距小工具一、效果展示 算法与实际量测的结果保持一致，输出最近距离和对应点 二、使用步骤 1.代码 import open3d as o3d import numpy as np# 读取点云数据 cloud_2 = o3d.io.re…
阅读更多...
查询和结果处理的Java代码

查询和结果处理的Java代码

match_all查询&#xff1a; //查询所有文档 match_all查询Testvoid testMatchAll() throws IOException {// 1.准备RequestSearchRequest request new SearchRequest("hotel");// 2.准备DSLrequest.source().query(QueryBuilders.matchAllQuery());// 3.发送请求Sea…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023