在C99中，基于RT-Thread的信号量实现读写锁的控制结构体和相关API函数，要求条理清晰

在 C99 标准中，可以使用 `_Thread_local` 来定义线程局部变量，使用 `pthread_mutex_t` 和 `pthread_cond_t` 来实现读写锁的控制结构，而信号量可以使用 `sem_t` 来实现。下面是一个基于 RT-Thread 的读写锁的实现：

首先，定义一个结构体来表示读写锁的控制结构：

#include <pthread.h>
#include <semaphore.h>

typedef struct {
    _Thread_local int read_count;   // 读者数量
    _Thread_local int write_count;  // 写者数量
    pthread_mutex_t mutex;          // 互斥锁
    pthread_cond_t read_cond;       // 读条件变量
    pthread_cond_t write_cond;      // 写条件变量
    sem_t sem;                      // 信号量
} rwlock_t;

其中，`read_count` 表示当前有多少个读者正在读取数据，`write_count` 表示当前有多少个写者正在修改数据，`mutex` 是用来保证读写锁的互斥访问，`read_cond` 和 `write_cond` 是用来控制读者和写者的条件变量，`sem` 是用来控制读者和写者的信号量。

接下来，定义相关的 API 函数：

void rwlock_init(rwlock_t *lock);
void rwlock_read_lock(rwlock_t *lock);
void rwlock_read_unlock(rwlock_t *lock);
void rwlock_write_lock(rwlock_t *lock);
void rwlock_write_unlock(rwlock_t *lock);

其中，`rwlock_init` 用于初始化读写锁，`rwlock_read_lock` 和 `rwlock_write_lock` 分别用于获取读锁和写锁，`rwlock_read_unlock` 和 `rwlock_write_unlock` 分别用于释放读锁和写锁。

下面是具体实现：

void rwlock_init(rwlock_t *lock) {
    lock->read_count = 0;
    lock->write_count = 0;
    pthread_mutex_init(&(lock->mutex), NULL);
    pthread_cond_init(&(lock->read_cond), NULL);
    pthread_cond_init(&(lock->write_cond), NULL);
    sem_init(&(lock->sem), 0, 1);
}

void rwlock_read_lock(rwlock_t *lock) {
    sem_wait(&(lock->sem));
    pthread_mutex_lock(&(lock->mutex));
    while (lock->write_count > 0) {
        pthread_cond_wait(&(lock->read_cond), &(lock->mutex));
    }
    lock->read_count++;
    pthread_mutex_unlock(&(lock->mutex));
    sem_post(&(lock->sem));
}

void rwlock_read_unlock(rwlock_t *lock) {
    pthread_mutex_lock(&(lock->mutex));
    lock->read_count--;
    if (lock->read_count == 0) {
        pthread_cond_signal(&(lock->write_cond));
    }
    pthread_mutex_unlock(&(lock->mutex));
}

void rwlock_write_lock(rwlock_t *lock) {
    sem_wait(&(lock->sem));
    pthread_mutex_lock(&(lock->mutex));
    lock->write_count++;
    while (lock->read_count > 0 || lock->write_count > 1) {
        pthread_cond_wait(&(lock->write_cond), &(lock->mutex));
    }
    pthread_mutex_unlock(&(lock->mutex));
}

void rwlock_write_unlock(rwlock_t *lock) {
    pthread_mutex_lock(&(lock->mutex));
    lock->write_count--;
    if (lock->write_count == 0) {
        pthread_cond_signal(&(lock->read_cond));
    } else {
        pthread_cond_signal(&(lock->write_cond));
    }
    pthread_mutex_unlock(&(lock->mutex));
    sem_post(&(lock->sem));
}

在实现读锁和写锁的时候，需要注意以下几点：

1. 获取读锁时，需要先获取信号量，然后再获取互斥锁，如果有写者正在修改数据，需要等待写条件变量，如果没有写者正在修改数据，需要增加读者数量，并释放互斥锁。
2. 释放读锁时，需要获取互斥锁，减少读者数量，如果没有读者，需要发送写条件变量，然后释放互斥锁。
3. 获取写锁时，需要先获取信号量，然后再获取互斥锁，如果有其他读者或写者正在修改数据，需要等待写条件变量，如果没有其他读者或写者正在修改数据，需要增加写者数量，并释放互斥锁。
4. 释放写锁时，需要获取互斥锁，减少写者数量，如果没有其他写者，需要发送读条件变量，否则需要发送写条件变量，然后释放互斥锁，并释放信号量。

这样就实现了一个基于 RT-Thread 的读写锁。