Java实现学生线程随机分配给教师线程的技术求助

核心调整思路 #

• 移除教师与固定学生的绑定，让教师可处理任意学生的作业
• 维护教师集合，学生完成作业时随机选取一名教师发起通知
• 修正wait()/notify()的使用逻辑，避免假唤醒，支持教师批量处理多份作业
• 简化线程结构，通过主线程控制多轮作业流程，无需单独的Assignment线程

修改后的完整代码 #

学生线程类（Student）

import java.util.List;
import java.util.Random;

public class Student extends Thread {
    private final int studentId;
    private final int assignmentId;
    private final List<Teacher> teachers;
    private static final Random random = new Random();

    public Student(int studentId, int assignmentId, List<Teacher> teachers) {
        this.studentId = studentId;
        this.assignmentId = assignmentId;
        this.teachers = teachers;
    }

    @Override
    public void run() {
        // 模拟做作业过程
        System.out.printf("Student %d is working on assignment %d%n", studentId, assignmentId);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return;
        }
        System.out.printf("Student %d is done with assignment %d%n", studentId, assignmentId);

        // 随机选择一名教师
        Teacher selectedTeacher = teachers.get(random.nextInt(teachers.size()));
        synchronized (selectedTeacher) {
            selectedTeacher.setCurrentStudent(studentId);
            selectedTeacher.notify();
            System.out.printf("Student %d notified teacher %d that assignment %d is complete.%n",
                    studentId, selectedTeacher.getTeacherId(), assignmentId);
        }
    }
}

教师线程类（Teacher）

import java.util.Random;

public class Teacher extends Thread {
    private final int teacherId;
    private final int totalAssignments;
    private int currentStudentId;
    private int gradedCount = 0;
    private static final Random random = new Random();

    public Teacher(int teacherId, int totalAssignments) {
        this.teacherId = teacherId;
        this.totalAssignments = totalAssignments;
    }

    @Override
    public void run() {
        System.out.printf("Teacher %d is waiting for students to finish assignments%n", teacherId);
        while (gradedCount < totalAssignments) {
            synchronized (this) {
                try {
                    // 等待学生通知
                    this.wait();
                    // 批改作业并生成成绩
                    int grade = random.nextInt(101);
                    System.out.printf("Teacher %d is grading assignment from student %d%n", teacherId, currentStudentId);
                    System.out.printf("Teacher %d graded student %d's assignment, grade: %d%n",
                            teacherId, currentStudentId, grade);
                    gradedCount++;
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
            }
        }
        System.out.printf("Teacher %d has finished grading all assigned assignments%n", teacherId);
    }

    public void setCurrentStudent(int currentStudentId) {
        this.currentStudentId = currentStudentId;
    }

    public int getTeacherId() {
        return teacherId;
    }
}

主程序（测试逻辑）

import java.util.ArrayList;
import java.util.List;

public class AssignmentGradingSystem {
    public static void main(String[] args) {
        final int numberOfStudents = 5;
        final int numberOfTeachers = 2;
        final int numberOfAssignments = 2;

        // 创建并启动教师线程
        List<Teacher> teachers = new ArrayList<>();
        for (int i = 0; i < numberOfTeachers; i++) {
            Teacher teacher = new Teacher(i, numberOfStudents);
            teachers.add(teacher);
            teacher.start();
        }

        // 执行多轮作业流程
        for (int assignmentRound = 0; assignmentRound < numberOfAssignments; assignmentRound++) {
            System.out.printf("%n=== Starting Assignment Round %d ===%n", assignmentRound);
            // 创建并启动学生线程
            List<Student> students = new ArrayList<>();
            for (int i = 0; i < numberOfStudents; i++) {
                Student student = new Student(i, assignmentRound, teachers);
                students.add(student);
                student.start();
            }

            // 等待本轮所有学生完成作业
            for (Student student : students) {
                try {
                    student.join();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
            }
            System.out.printf("=== Assignment Round %d Completed ===%n%n", assignmentRound);
        }

        // 等待所有教师完成批改
        for (Teacher teacher : teachers) {
            try {
                teacher.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }

        System.out.println("All assignment rounds completed!");
    }
}

关键说明 #

• 随机分配实现：学生通过random.nextInt(teachers.size())从教师列表中随机选取目标教师，完全满足随机分配需求
• 线程协作优化：教师用while循环持续等待通知，避免wait()被假唤醒后直接退出；每次通知仅处理当前学生的作业，计数达标后自动结束
• 多轮作业控制：主线程通过循环控制作业轮数，每轮创建新的学生线程，等待所有学生完成后进入下一轮，符合需求中的多轮流程要求
• 线程安全保障：所有涉及共享状态的操作均在synchronized块中执行，避免线程安全问题

内容的提问来源于stack exchange，提问作者Ion J.