小阳同学嵌入式学习日记-条件变量

已于 2024-04-07 17:08:32 修改
阅读量1.2k 收藏 20
点赞数 33
分类专栏： 嵌入式学习日记 文章标签： 学习 c++ linux 服务器
于 2024-04-07 12:20:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51769299/article/details/137449464
版权

 

目录

一、什么是条件变量？ 

二、条件变量的应用函数

a、pthread_cond_init()

b、pthread_cond_wait()

c、 pthread_cond_timedwait()

 d、pthread_cond_signal()

e、pthread_cond_broadcast()

f、 pthread_cond_destroy()

 三、生产者消费者条件变量模型

四、条件变量的优点 

一、什么是条件变量？ 

        条件变量（Condition Variables）是一种线程同步的机制，用于在多线程编程中实现线程之间的协作。它通常与互斥锁（Mutex）一起使用，用于在线程等待某个条件成立时暂停执行，并在条件满足时恢复执行。条件变量允许线程在等待某个条件成立时进入阻塞状态，以避免忙等待（busy-waiting）的情况，从而有效地利用系统资源。

        条件变量通常提供了两种操作：

  1. 等待（wait）：一个线程可以调用等待操作来阻塞自己的执行，直到某个条件被满足。当某个线程在条件不满足时调用等待操作时，它会释放持有的互斥锁，并进入阻塞状态等待条件成立。一旦条件成立，其他线程调用通知操作时，等待线程会被唤醒，并重新尝试获取互斥锁以继续执行。
  2. 通知（notify）：一个线程可以调用通知操作来通知等待在条件上的其他线程，条件已经被满足，因此它们可以尝试重新竞争获取互斥锁。通知操作通常有两种形式：通知单个线程（notify_one）和通知所有线程（notify_all）。

二、条件变量的应用函数

a、pthread_cond_init()

        pthread_cond_init() 函数用于初始化一个条件变量，其函数原型如下：

#include <pthread.h>

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
  • cond：指向要初始化的条件变量的指针。
  • attr：条件变量的属性，通常传入 NULL 表示使用默认属性。

        这个函数用于在使用条件变量之前对其进行初始化。初始化后的条件变量可以在多个线程之间共享使用。如果条件变量在栈上分配内存，那么在使用之前必须对其进行初始化。注意，这个函数不会分配内存，只是对已分配的条件变量进行初始化。 

返回值：

  • 成功：返回 0。
  • 失败：返回一个正整数的错误码，表示发生了错误。

示例用法：

pthread_cond_t my_cond;

int main() {
    // 初始化条件变量
    if (pthread_cond_init(&my_cond, NULL) != 0) {
        perror("pthread_cond_init");
        exit(EXIT_FAILURE);
    }

    // 使用 my_cond 进行其他操作...

    // 销毁条件变量
    pthread_cond_destroy(&my_cond);

    return 0;
}

         这个函数是 POSIX 线程库中对条件变量的初始化操作。

b、pthread_cond_wait()

         pthread_cond_wait() 函数用于阻塞等待一个条件变量，其函数原型如下：

  • cond：指向要等待的条件变量的指针。
  • mutex：指向与条件变量关联的互斥锁的指针。在调用该函数之前，线程必须先锁定该互斥锁，否则会导致未定义的行为。在调用完 pthread_cond_wait() 后，互斥锁会被释放，以允许其他线程访问共享资源。

         该函数被调用时，线程会被阻塞，直到其他线程调用 pthread_cond_signal() 或 pthread_cond_broadcast() 函数来通知条件变量，并且该线程获得了与条件变量关联的互斥锁。在被唤醒之后，该线程会重新获得互斥锁并继续执行。

 返回值：

  • 成功：返回 0。
  • 失败：返回一个正整数的错误码，表示发生了错误。

示例用法：

pthread_cond_t my_cond;
pthread_mutex_t my_mutex;
int shared_data = 0;

void* thread_function(void* arg) {
    pthread_mutex_lock(&my_mutex);
    while (shared_data == 0) {
        pthread_cond_wait(&my_cond, &my_mutex);
    }
    // 在这里处理共享资源
    pthread_mutex_unlock(&my_mutex);
    return NULL;
}

int main() {
    // 初始化条件变量和互斥锁
    pthread_cond_init(&my_cond, NULL);
    pthread_mutex_init(&my_mutex, NULL);

    // 创建线程并执行
    pthread_t tid;
    pthread_create(&tid, NULL, thread_function, NULL);

    // 修改共享资源
    pthread_mutex_lock(&my_mutex);
    shared_data = 1;
    // 通知等待的线程
    pthread_cond_signal(&my_cond);
    pthread_mutex_unlock(&my_mutex);

    // 等待线程执行完成
    pthread_join(tid, NULL);

    // 销毁条件变量和互斥锁
    pthread_cond_destroy(&my_cond);
    pthread_mutex_destroy(&my_mutex);

    return 0;
}

         这个函数允许线程等待条件变量的发生，通常与互斥锁结合使用来实现线程间的同步。

c、 pthread_cond_timedwait()

         pthread_cond_timedwait() 函数与 pthread_cond_wait() 函数类似，但是它允许设置一个超时时间，如果超过了指定的时间仍然没有收到条件变量的信号，则函数返回。其函数原型如下：

#include <pthread.h>
#include <time.h>

int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
  • cond：指向要等待的条件变量的指针。
  • mutex：指向与条件变量关联的互斥锁的指针。在调用该函数之前，线程必须先锁定该互斥锁，否则会导致未定义的行为。在调用完 pthread_cond_timedwait() 后，互斥锁会被释放，以允许其他线程访问共享资源。
  • abstime：指向一个 timespec 结构体的指针，表示等待的超时时间。

        该函数会阻塞当前线程，直到条件变量被信号唤醒或者超时。如果超时时间到达但条件变量仍未被信号唤醒，该函数会返回 ETIMEDOUT 错误码。

返回值：

  • 成功：返回 0。
  • 失败：返回一个正整数的错误码，表示发生了错误。

示例用法：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

pthread_cond_t my_cond;
pthread_mutex_t my_mutex;
int shared_data = 0;

void* thread_function(void* arg) {
    pthread_mutex_lock(&my_mutex);
    struct timespec timeout;
    clock_gettime(CLOCK_REALTIME, &timeout);
    timeout.tv_sec += 5; // 设置超时时间为5秒后
    int result = pthread_cond_timedwait(&my_cond, &my_mutex, &timeout);
    if (result == ETIMEDOUT) {
        printf("Timed out waiting for condition\n");
    } else if (result == 0) {
        printf("Condition signaled\n");
    } else {
        perror("pthread_cond_timedwait");
    }
    pthread_mutex_unlock(&my_mutex);
    return NULL;
}

int main() {
    // 初始化条件变量和互斥锁
    pthread_cond_init(&my_cond, NULL);
    pthread_mutex_init(&my_mutex, NULL);

    // 创建线程并执行
    pthread_t tid;
    pthread_create(&tid, NULL, thread_function, NULL);

    // 等待一段时间后发送信号
    sleep(7);
    pthread_mutex_lock(&my_mutex);
    shared_data = 1;
    // 通知等待的线程
    pthread_cond_signal(&my_cond);
    pthread_mutex_unlock(&my_mutex);

    // 等待线程执行完成
    pthread_join(tid, NULL);

    // 销毁条件变量和互斥锁
    pthread_cond_destroy(&my_cond);
    pthread_mutex_destroy(&my_mutex);

    return 0;
}

        这个函数允许设置一个超时时间，在超时之后会返回，可以用于实现一些需要等待一段时间的操作。

 d、pthread_cond_signal()

         pthread_cond_signal() 函数用于唤醒至少一个等待在条件变量上的线程。其函数原型如下：

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cond);
  • cond：指向要发送信号的条件变量的指针。

         该函数调用后会唤醒至少一个等待在条件变量上的线程。如果没有线程在等待条件变量上，那么调用 pthread_cond_signal() 函数也不会有任何作用。

返回值：

  • 成功：返回 0。
  • 失败：返回一个正整数的错误码，表示发生了错误。

示例用法：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_cond_t my_cond;
pthread_mutex_t my_mutex;
int shared_data = 0;

void* thread_function(void* arg) {
    pthread_mutex_lock(&my_mutex);
    printf("Waiting for condition...\n");
    pthread_cond_wait(&my_cond, &my_mutex);
    printf("Condition signaled, shared_data: %d\n", shared_data);
    pthread_mutex_unlock(&my_mutex);
    return NULL;
}

int main() {
    // 初始化条件变量和互斥锁
    pthread_cond_init(&my_cond, NULL);
    pthread_mutex_init(&my_mutex, NULL);

    // 创建线程并执行
    pthread_t tid;
    pthread_create(&tid, NULL, thread_function, NULL);

    // 修改共享资源
    pthread_mutex_lock(&my_mutex);
    shared_data = 1;
    // 通知等待的线程
    pthread_cond_signal(&my_cond);
    pthread_mutex_unlock(&my_mutex);

    // 等待线程执行完成
    pthread_join(tid, NULL);

    // 销毁条件变量和互斥锁
    pthread_cond_destroy(&my_cond);
    pthread_mutex_destroy(&my_mutex);

    return 0;
}

         这个函数用于在满足条件时唤醒一个或多个等待线程，以便它们可以继续执行。

e、pthread_cond_broadcast()

        pthread_cond_broadcast() 函数用于唤醒所有等待在条件变量上的线程。其函数原型如下：

#include <pthread.h>

int pthread_cond_broadcast(pthread_cond_t *cond);
  • cond：指向要广播信号的条件变量的指针。

        该函数会唤醒所有等待在条件变量上的线程。如果没有线程在等待条件变量上，调用 pthread_cond_broadcast() 函数也不会有任何作用。

返回值：

  • 成功：返回 0。
  • 失败：返回一个正整数的错误码，表示发生了错误。

示例用法：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_cond_t my_cond;
pthread_mutex_t my_mutex;
int shared_data = 0;

void* thread_function(void* arg) {
    pthread_mutex_lock(&my_mutex);
    printf("Waiting for condition...\n");
    pthread_cond_wait(&my_cond, &my_mutex);
    printf("Condition signaled, shared_data: %d\n", shared_data);
    pthread_mutex_unlock(&my_mutex);
    return NULL;
}

int main() {
    // 初始化条件变量和互斥锁
    pthread_cond_init(&my_cond, NULL);
    pthread_mutex_init(&my_mutex, NULL);

    // 创建线程并执行
    pthread_t tid;
    pthread_create(&tid, NULL, thread_function, NULL);

    // 修改共享资源
    pthread_mutex_lock(&my_mutex);
    shared_data = 1;
    // 广播通知所有等待的线程
    pthread_cond_broadcast(&my_cond);
    pthread_mutex_unlock(&my_mutex);

    // 等待线程执行完成
    pthread_join(tid, NULL);

    // 销毁条件变量和互斥锁
    pthread_cond_destroy(&my_cond);
    pthread_mutex_destroy(&my_mutex);

    return 0;
}

        这个函数用于在满足条件时唤醒所有等待线程，以便它们可以继续执行。

f、 pthread_cond_destroy()

         pthread_cond_destroy() 函数用于销毁一个条件变量，释放相关资源。其函数原型如下：

#include <pthread.h>

int pthread_cond_destroy(pthread_cond_t *cond);
  • cond：指向要销毁的条件变量的指针。

        该函数会销毁指定的条件变量，释放与其相关的资源。在调用该函数之后，不能再对该条件变量进行任何操作，否则将导致未定义的行为。

返回值：

  • 成功：返回 0。
  • 失败：返回一个正整数的错误码，表示发生了错误。

示例用法：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_cond_t my_cond;

int main() {
    // 初始化条件变量
    pthread_cond_init(&my_cond, NULL);

    // 使用条件变量...

    // 销毁条件变量
    if (pthread_cond_destroy(&my_cond) != 0) {
        perror("pthread_cond_destroy");
        exit(EXIT_FAILURE);
    }

    return 0;
}

         这个函数用于释放条件变量相关的资源，通常在不再需要条件变量时调用。

 三、生产者消费者条件变量模型

        生产者-消费者问题是一个经典的多线程同步问题，其中生产者线程负责生产数据并将其放入共享缓冲区，而消费者线程则负责从缓冲区中取出数据进行处理。条件变量是实现生产者-消费者模型的一种常见方法之一。

以下是使用条件变量实现生产者-消费者模型的基本步骤：

  1. 定义共享资源：通常是一个缓冲区，生产者向其中放入数据，消费者从中取出数据。
  2. 定义互斥锁：用于保护对共享资源的访问，防止多个线程同时对其进行操作。
  3. 定义条件变量：用于在缓冲区为空时阻塞消费者线程，在缓冲区满时阻塞生产者线程，直到条件满足时唤醒相应的线程。
  4. 编写生产者线程函数和消费者线程函数，分别进行生产和消费操作。
  5. 在生产者线程和消费者线程中使用互斥锁保护对共享资源的访问，并在必要时等待条件变量的信号。
  6. 在生产者线程向缓冲区放入数据后，通知等待在条件变量上的消费者线程。
  7. 在消费者线程从缓冲区取出数据后，通知等待在条件变量上的生产者线程。

以下是一个简单的生产者-消费者条件变量模型的示例（使用 C 语言和 POSIX 线程库）：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE]; // 共享缓冲区
int count = 0; // 缓冲区中当前项目的数量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 互斥锁
pthread_cond_t cond_full = PTHREAD_COND_INITIALIZER; // 缓冲区满条件变量
pthread_cond_t cond_empty = PTHREAD_COND_INITIALIZER; // 缓冲区空条件变量

// 生产者线程函数
void* producer(void* arg) {
    int item = 0;
    while (1) {
        pthread_mutex_lock(&mutex); // 加锁
        if (count == BUFFER_SIZE) { // 如果缓冲区满
            pthread_cond_wait(&cond_full, &mutex); // 等待缓冲区不满
        }
        buffer[count++] = item++; // 生产一个项目并放入缓冲区
        printf("Produced item %d\n", item);
        pthread_cond_signal(&cond_empty); // 唤醒等待缓冲区为空的消费者线程
        pthread_mutex_unlock(&mutex); // 解锁
    }
    return NULL;
}

// 消费者线程函数
void* consumer(void* arg) {
    while (1) {
        pthread_mutex_lock(&mutex); // 加锁
        if (count == 0) { // 如果缓冲区为空
            pthread_cond_wait(&cond_empty, &mutex); // 等待缓冲区不空
        }
        int item = buffer[--count]; // 从缓冲区取出一个项目
        printf("Consumed item %d\n", item);
        pthread_cond_signal(&cond_full); // 唤醒等待缓冲区不满的生产者线程
        pthread_mutex_unlock(&mutex); // 解锁
    }
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;

    // 创建生产者线程和消费者线程
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    // 等待线程结束
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    return 0;
}

         这段代码实现了一个简单的生产者-消费者模型，其中生产者线程不断向缓冲区放入数据，而消费者线程不断从缓冲区取出数据。通过互斥锁和条件变量来确保线程之间的同步和互斥访问共享资源。

运行结果如下：

四、条件变量的优点 

条件变量作为多线程编程中的一种同步机制，具有以下优点：

  1. 减少资源竞争： 条件变量可以使线程在等待某个条件时进入阻塞状态，而不是采用忙等待的方式，从而减少了对共享资源的竞争，提高了系统的性能和效率。

  2. 提高系统吞吐量： 使用条件变量可以允许线程在等待某个条件时挂起，当条件满足时再唤醒，这样可以更有效地利用系统资源，提高了系统的吞吐量。

  3. 避免忙等待： 忙等待会消耗大量的 CPU 时间，降低系统的效率，并且容易导致死锁等问题。条件变量的出现可以避免这种情况的发生，使得线程能够在条件满足时自动进入阻塞状态，直到条件被满足时被唤醒。

  4. 提高代码可读性和可维护性： 使用条件变量可以更清晰地表达线程之间的逻辑关系，使得代码更易于理解和维护。

  5. 支持复杂的线程间通信： 条件变量通常与互斥锁一起使用，可以支持更复杂的线程间通信和同步需求，例如生产者-消费者模型、读者-写者问题等。

        总的来说，条件变量是多线程编程中非常重要的一种同步机制，它能够有效地提高系统的性能和可维护性，减少资源竞争和忙等待，支持复杂的线程间通信，是实现多线程程序的重要工具之一。

做大做强，再创辉煌！ 

努力的小阳同学
关注
  • 33
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式 多线程条件变量相关操作
skdkjxy的专栏
12-02 868
条件变量函数 操作 相关函数说明 初始化条件变量 pthread_cond_init 语法 基于条件变量阻塞 pthread_cond_wait 语法 解除阻塞特定线程 pthread_cond_signal 语法 在指定的时间之前阻塞 pthread_cond_timedwait 语法 在指定的时间间隔内阻塞 pthre
房地产行业1~3月房地产数据点评：销售面积增速超预期，行业小阳春回暖-0418-东北证券-13页.pdf
07-27
2019年1月至3月期间，中国的房地产市场显示出积极迹象，呈现小阳春回暖态势。全国房地产开发投资额达到2.38万亿元，同比增长11.8%，增速略有上升。新开工面积3.87亿平方米，增长11.9%，这一反弹主要是由于3月市场...
嵌入式 互斥锁和条件变量基础常识
skdkjxy的专栏
12-02 1122
前言 在学习posix ipc编程的时候，遇到两个很重要的概念：互斥锁和条件变量，而且，在各种进程/线程之间的同步中的使用很多。所以今天就系统的整理了一下，主要的参考资料来自《UNIX网络编程 卷2：进程间通信》 一、概述 在多线程或者多进程共享数据时，为了保证数据的完整性和正确性，,使用同步机制来实现。互斥锁和条件变量均是出自posix.1线程标准，可以被用来同步一个进程中的多个线程，还可以用
小阳同学嵌入式学习日记-守护进程
qq_51769299的博客
04-01 868
守护进程（Daemon Process）是在操作系统后台运行的一种特殊类型的进程。它们在后台运行，通常独立于任何用户会话，并且没有控制终端。守护进程通常被设计用来执行一些系统级的任务或服务，例如作为服务器后端运行、定期执行某些任务、监控硬件或网络设备等。守护进程在后台持续运行，通常不受用户会话的影响，不需要用户交互。守护进程通常不与任何控制终端相关联，因此不接收用户输入，也不向终端输出。守护进程通常在系统启动时启动，并在系统关闭时终止，与用户登录和注销无关。
小阳同学嵌入式学习日记-文件描述符
qq_51769299的博客
03-25 561
在Linux系统中，文件描述符（File Descriptor）是一个用于标识打开文件、套接字、管道和其他 I/O 设备的非负整数。Linux系统遵循了Unix哲学中“一切皆文件”的概念，因此文件描述符不仅仅用于表示普通的文件，还可以表示其他的I/O资源，比如管道、套接字等。
小阳同学嵌入式学习日记-extern “C“
qq_51769299的博客
04-12 883
用于声明C语言风格的函数接口，这意味着函数名称不会被C++的名称修饰机制修改，也就是不会进行函数名称的重命名（名称修饰）。这样声明的常量是一个声明而非定义，编译器在编译时不会为它分配存储空间，而是将其作为一个标识符，用于在其他文件中访问已定义的常量。时，这个函数的名称在链接时会按照 C 语言规则进行修饰，因此在 C 代码中可以直接引用这个函数而不需要使用 extern。声明告诉编译器这些函数是用C语言编写的，而不是C++。声明，只是告诉编译器该变量是在其他文件中定义的，而不是在当前文件中定义的。
小阳同学嵌入式学习日记-什么是系统调用？
qq_51769299的博客
03-25 499
在系统调用的过程中，用户程序通过将参数传递给特定的系统调用函数或者指令，然后通过软中断或者其他机制将控制权转交给操作系统内核。系统调用是用户空间程序与内核之间的接口，它允许用户程序通过一组预定义的函数或者指令，向操作系统发出请求以执行特定的操作。系统调用是操作系统提供的重要功能之一，它为用户程序提供了访问操作系统功能的标准化接口，同时也是操作系统内核实现功能的核心部分。当用户程序需要执行特权操作（例如创建进程、读写文件等），或者访问受保护的资源时，就需要通过系统调用来委托操作系统来完成这些任务。
小阳同学嵌入式学习日记-进程状态
qq_51769299的博客
03-31 1047
如上图所示，便是一个进程从出生到死亡的全过程。
小阳同学嵌入式学习日记-互斥锁
qq_51769299的博客
04-03 740
互斥锁（Mutex，全名为 Mutual Exclusion）是一种线程同步的机制，用于保护共享资源，确保同一时间只有一个线程可以访问共享资源，从而避免多个线程同时修改共享资源导致的数据不一致性和竞态条件。互斥锁的基本操作包括两个主要函数：锁定（Lock）和解锁（Unlock）。当一个线程要访问共享资源时，首先会尝试获取互斥锁，如果互斥锁已经被其他线程获取，则当前线程会被阻塞，直到获取到互斥锁为止。获取到互斥锁后，线程可以安全地访问共享资源，执行完操作后，需要释放互斥锁，以允许其他线程继续访问共享资源。
嵌入式初级工程师面试问题
05-13
IIC 数据帧格式包括起始条件、数据位、应答位和停止条件。 RS485 是一种常用的串行通信协议，用于连接不同的设备。RS485 协议是一种半双工协议，主机控制总线的传输方向。 BS8116 触摸芯片是一种常用的触摸控制器...
《深度学习在互联网上的应用》——寒小阳.mp4
01-23
《深度学习在互联网上的应用》——寒小阳.mp4
房地产行业：一线城市成交量回升，三四月小阳春行情继续-0401-东北证券-14页.pdf
07-27
这种回暖可能与所谓的“小阳春行情”有关，这是一种在每年春季发生的市场成交量上升的现象。不过，这种回暖是否代表了市场的长期趋势，还需要进一步观察。 在房地产行业中，土地交易是核心业务活动之一。在报告中...
2021工商管理-2021219073038-廖小阳-程序 Jupyter Notebook.mhtml
04-06
2021工商管理-2021219073038-廖小阳-程序 Jupyter Notebook.mhtml
小阳同学嵌入式学习日记-线程同步
qq_51769299的博客
04-03 863
线程同步是指在多线程编程中，通过各种机制来协调和控制多个线程的执行顺序和访问共享资源的行为，以确保程序的正确性和一致性。线程同步的主要目的是避免竞态条件（Race Condition）和其他并发问题，确保多个线程能够按照既定的顺序和方式进行协作和合作。使用互斥锁（Mutex）来保护临界区，确保同一时间只有一个线程可以进入临界区执行操作，避免多个线程同时访问共享资源导致数据不一致的情况。使用条件变量来实现线程的等待和通知机制，允许线程等待某个条件的发生并在条件满足时被唤醒，以便有效地进行线程间的协调和通信。
Freertos学习笔记
qq_45031559的博客
08-21 623
Freertos学习笔记
零基础学习人工智能—Python—Pytorch学习（六）
最新发布
kiba518的博客
08-21 846
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
学习分享： Java 中调用 API 的一般方式
weixin_71842181的博客
08-19 380
学习分享： Java 中调用 API 的一般方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值