编写一个多线程的程序一个线程输出20次你的学号，另一个输出20次你的姓名Java代码

public class MultiThreadDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new StudentIdThread());
        Thread t2 = new Thread(new StudentNameThread());
        t1.start();
        t2.start();
    }
}

class StudentIdThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("My student id is 2021000000000X.");
        }
    }
}

class StudentNameThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("My name is John Smith.");
        }
    }
}

相关问题

用Java实现一个数据单元,包括学号,姓名两部分。编写两个线程，一个线程往数据单元中写，另一个线程往出读。要求每写一次就往出读一次

下面是一个简单的示例程序，该程序实现了一个数据单元类，包括学号和姓名两部分，并包含一个写入方法和一个读取方法。在主方法中创建了一个共享的数据单元对象和两个线程对象，一个用于写入数据，一个用于读取数据。每次写入数据时，都会通知读取线程进行读取，每次读取数据后，都会通知写入线程进行写入。

public class DataUnit {
    private String studentId;
    private String name;
    private boolean available = false;

    public synchronized void write(String studentId, String name) {
        while (available) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.studentId = studentId;
        this.name = name;
        available = true;
        notifyAll();
    }

    public synchronized String[] read() {
        while (!available) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String[] data = new String[]{studentId, name};
        available = false;
        notifyAll();
        return data;
    }
}

class Writer implements Runnable {
    private DataUnit dataUnit;

    public Writer(DataUnit dataUnit) {
        this.dataUnit = dataUnit;
    }

    @Override
    public void run() {
        String[] students = new String[]{"1001", "1002", "1003", "1004", "1005"};
        String[] names = new String[]{"Tom", "Jerry", "Mike", "Lucy", "Lily"};
        for (int i = 0; i < students.length; i++) {
            dataUnit.write(students[i], names[i]);
            System.out.println("写入数据：" + students[i] + " " + names[i]);
            String[] data = dataUnit.read();
            System.out.println("读取数据：" + data[0] + " " + data[1]);
        }
    }
}

class Reader implements Runnable {
    private DataUnit dataUnit;

    public Reader(DataUnit dataUnit) {
        this.dataUnit = dataUnit;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            String[] data = dataUnit.read();
            System.out.println("读取数据：" + data[0] + " " + data[1]);
            dataUnit.write(data[0], data[1]);
            System.out.println("写入数据：" + data[0] + " " + data[1]);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        DataUnit dataUnit = new DataUnit();
        Thread writerThread = new Thread(new Writer(dataUnit));
        Thread readerThread = new Thread(new Reader(dataUnit));
        writerThread.start();
        readerThread.start();
    }
}

在上面的代码中，使用了synchronized关键字来实现线程的同步，使得每次写入数据后都会通知读取线程进行读取，每次读取数据后都会通知写入线程进行写入。注意在写入方法和读取方法中都使用了while循环进行判断，而不是if语句。这是因为在多线程环境下，可能会出现虚假唤醒的情况，如果使用if语句进行判断，可能会导致程序出现问题。

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();

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