3.实现一个数据单元，包括学号和姓名两部分。编写两个线程，一个线程往数据单元中写，另一个线程往外读。要求没写一次就往外读一次。

### 回答1：
这道题需要使用线程间的同步机制来保证数据的正确读写。可以使用互斥锁来实现。

下面是一个简单的实现，使用了一个全局的数据单元 `data`，一个互斥锁 `mutex`，以及两个线程函数 `read_thread` 和 `write_thread`。

#include <iostream>
#include <thread>
#include <mutex>

using namespace std;

// 数据单元
struct Student {
    int id;
    string name;
};

// 全局数据单元和互斥锁
Student data;
mutex mutex;

// 写线程函数
void write_thread() {
    // 循环写入数据
    for (int i = 0; i < 10; i++) {
        // 加锁
        mutex.lock();
        // 写入数据
        data.id = i;
        data.name = "Name" + to_string(i);
        // 输出写入的数据
        cout << "Write: " << data.id << " " << data.name << endl;
        // 解锁
        mutex.unlock();

        // 等待一段时间
        this_thread::sleep_for(chrono::milliseconds(100));
    }
}

// 读线程函数
void read_thread() {
    // 循环读取数据
    for (int i = 0; i < 10; i++) {
        // 加锁
        mutex.lock();
        // 输出读取的数据
        cout << "Read: " << data.id << " " << data.name << endl;
        // 解锁
        mutex.unlock();

        // 等待一段时间
        this_thread::sleep_for(chrono::milliseconds(100));
    }
}

int main() {
    // 创建写线程和读线程
    thread write(write_thread);
    thread read(read_thread);

    // 等待线程结束
    write.join();
    read.join();

    return 0;
}

在 `write_thread` 中，我们先加锁，然后写入数据，最后解锁。在 `read_thread` 中，我们也先加锁，然后读取数据，最后解锁。这样就保证了每次写入数据后立即读取，保证了数据的正确性。

注意，在实际应用中，可能需要使用更加复杂的同步机制来保证数据的正确性，比如条件变量等。

### 回答2：
实现该功能可以使用线程安全的队列数据结构来存储数据单元。首先创建一个名为"数据单元"的类，包括学号和姓名两个属性：

class DataUnit:
    def __init__(self, student_id, name):
        self.student_id = student_id
        self.name = name

接下来，创建两个线程，一个用于往数据单元中写入数据，另一个用于读取数据。

import threading
import queue

# 创建线程安全的队列
data_queue = queue.Queue()

# 写入数据的线程函数
def write_data():
    for i in range(10):
        student_id = i + 1
        name = "学生{}".format(student_id)
        data_unit = DataUnit(student_id, name)
        data_queue.put(data_unit)
        print("写入: {}".format(data_unit.__dict__))

# 读取数据的线程函数
def read_data():
    for i in range(10):
        data_unit = data_queue.get()
        print("读取: {}".format(data_unit.__dict__))

# 创建线程
write_thread = threading.Thread(target=write_data)
read_thread = threading.Thread(target=read_data)

# 启动线程
write_thread.start()
read_thread.start()

# 等待线程执行完毕
write_thread.join()
read_thread.join()

上述代码实现了使用队列数据结构使得每次写入数据后立即读取一次数据。循环10次，写入10个数据单元，并读取10个数据单元。通过使用队列数据结构，保证了多线程读写时的线程安全性，避免了数据冲突问题。

### 回答3：
实现上述要求，可以使用线程间的通信方式，如条件变量或信号量。

首先，我们可以创建一个数据单元类，包括学号和姓名两个成员变量，并提供相应的读写方法。假设我们将该类命名为"DataUnit"，其中成员变量的类型分别为int型的"studentId"和String型的"name"，读写方法分别为"writeData()"和"readData()"。

接下来，我们创建两个线程，一个用于写入数据的线程，另一个用于读取数据的线程。

对于写入数据的线程，我们可以使用一个循环，每次写入数据后，通过条件变量或信号量通知读取线程，然后等待读取线程读取完数据后再进行下一次写入。伪代码如下：

DataUnit dataUnit = new DataUnit();
Semaphore semaphore = new Semaphore(0); // 信号量

Thread writeThread = new Thread(() -> {
    while (true) {
        dataUnit.writeData(); // 写数据

        // 通知读取线程
        semaphore.release();

        // 等待读取线程读取完数据
        semaphore.acquireUninterruptibly();
    }
});

writeThread.start();

对于读取数据的线程，我们同样使用一个循环，每次读取数据后，通过条件变量或信号量通知写入线程，然后等待写入线程写入新的数据。伪代码如下：

Thread readThread = new Thread(() -> {
    while (true) {
        // 等待写入线程写入数据
        semaphore.acquireUninterruptibly();

        dataUnit.readData(); // 读数据

        // 通知写入线程
        semaphore.release();
    }
});

readThread.start();

通过上述方式，我们实现了一个数据单元，同时编写了两个线程，一个用于写入数据，另一个用于读取数据。每次写入数据后，就会立即读取数据，并且两个线程间通过条件变量或信号量进行同步，确保写入线程和读取线程的顺序交替进行。