而Java中的循环则是在线程完成之前进行循环

我有一个关于while循环的问题，它将运行一个菜单系统

这是我正在使用的代码。每个线程或借用者在每个线程中使用sleep（）命令同时执行任务。我现在遇到的问题是，一旦每个借贷者线程运行，例如

for(int i = 0 ;i < borrowCount; i++) {
    model.getBorrowers().add(new Borrower(i+1,model.getLibrary(),model.runs));

model.librarian().start();

for(Borrower b : model.getBorrowers()) {
    b.start();
}

for（int i=0；i

然而，由于涉及sleep（）命令，借贷者开始执行While循环，并在线程的输出中重新打印菜单

有没有办法确保While循环只在所有线程完成后循环

以下是我正在使用的代码：

****编辑和更新的代码*****

package model;

import java.util.ArrayList;
import java.util.Scanner;

public class LibraryModel implements Runnable{
  Library library = new Library();
  Librarian librarian;
  ArrayList<Borrower> BorrowArray = new ArrayList<Borrower>();
  int runs = 0;
  Boolean isActive = true;

public LibraryModel() {
    library.AddBooks();
}

public static void main(String[]args) 
{
    int borrowCount = 0;
    System.out.println("Welcome to the Library Simulator\n");


    LibraryModel model = new LibraryModel();
    Scanner sc = new Scanner(System.in);
    String a = sc.next();
    char quit = 'y';

    while(quit != 'q')  {

    String a = sc.next();
    System.out.println("\n[S = start, A = About, Q = quit]");

    switch (a) {

        case "S":
           System.out.println("Please enter the number of Borrowers\n");
           borrowCount = sc.nextInt();
           System.out.println("Please enter how many runs the Program will run");
           model.runs = sc.nextInt();

           model.librarian = new Librarian(model.library,model.runs);

           for(int i = 0 ;i < borrowCount; i++) {
                model.getBorrowers().add(new Borrower(i+1,model.getLibrary(),model.runs));
                }
                model.librarian().start();

                for(Borrower b : model.getBorrowers()) {
                    b.start();
                }
        break;


        case "A":
        break;

        case "Q" :
            quit = 'q';
        break;


        default :
            System.out.println("Incorrect Entry, please enter a correct");
        break;
    }
}

包模型；
导入java.util.ArrayList；
导入java.util.Scanner；
公共类LibraryModel实现可运行{
库=新库（）；
图书馆员；
ArrayList BorrowArray=新的ArrayList（）；
整数=0；
布尔isActive=真；
公共图书馆模型（）{
library.AddBooks（）；
}
公共静态void main（字符串[]args）
{
整数计数=0；
System.out.println（“欢迎使用库模拟器”\n）；
LibraryModel=新的LibraryModel（）；
扫描仪sc=新的扫描仪（System.in）；
字符串a=sc.next（）；
char quit='y'；
while（退出！=“q”）{
字符串a=sc.next（）；
System.out.println（“\n[S=start，A=About，Q=quit]”）；
开关（a）{
案例“S”：
System.out.println（“请输入借贷者的数量\n”）；
借用计数=sc.nextInt（）；
System.out.println（“请输入程序将运行多少次”）；
model.runs=sc.nextInt（）；
model.library=新的图书管理员（model.library，model.runs）；
对于（int i=0；i

涉及借款人的要求代码：

package model;

public class Borrower extends Thread {

private int noOfBooks;
private Set<Book> BooksBorrowed;
private Set<Integer> booksRequested;
private int id;
private int runs;
private Library library;
private Random randSleep = new Random();

public Borrower(int id, Library library, int runs) {

    this.library = library;
    this.id = id;
    this.runs = runs;
    noOfBooks = 1;

    }

public Borrower(){}

public String getLoans() {
    String output = "";
    for(Book b : BooksBorrowed) {
        output +=" "+b.getBookId()+" ";
    }
    return output;
}

public void run()
{   
    try {
        Initialize();

        for(int i = 0; i < runs; i++) {
            RequestBooks();
            ReturnBooks();
        }

    } finally {}
}

public synchronized void Initialize() {

    int min = 1;
    int max = 10;
    Random r = new Random();
    noOfBooks = r.nextInt(max - min + 1) + min;

    System.out.println("--------------------------");
    System.out.println("Borrower "+id+" Starting");

    notifyAll();
}

public synchronized void RequestBooks () {

    Random r2 = new Random();
    Book temp = null;

    ArrayList<Book>books = new ArrayList<Book>(library.getBooks());
    ArrayList<Integer>Chosen = new ArrayList<Integer>();

    for(int i = 0; i < noOfBooks; i++){
        int index = r2.nextInt(books.size());
        temp = books.get(index);
        int tempId = temp.getBookId();
        Chosen.add(tempId);
    }
    System.out.println("--------------------------");
    System.out.println("\nBorrower "+id+" requests " +noOfBooks+" Books from Library ");

    booksRequested = new HashSet<Integer>(Chosen);

    String requestedBooks = "";

    for(Integer bookid : Chosen) {
        requestedBooks = requestedBooks+bookid+" ";
        booksRequested.add(bookid);

    }
    System.out.println("Borrower "+id+" request Books: "+requestedBooks);

    BooksBorrowed = library.RQST(id,booksRequested);
    ArrayList<Book> chosenBooks = new ArrayList<Book>();
    chosenBooks.addAll(BooksBorrowed);

    System.out.println("Books requested by Borrower "+id+" : "+requestedBooks+"\n");

    String receivedBooks = "";
    Book[]BookArray = BooksBorrowed.toArray(new Book[BooksBorrowed.size()]);
    for(Book b : BookArray) {
        receivedBooks = receivedBooks+b.getBookId()+" ";
    }

    System.out.println("Borrower "+id+" Books recieved :"+receivedBooks);
    System.out.println("--------------------------");
    notifyAll();

}

public synchronized void ReturnBooks() {
    Set<Integer> BooksReturned;
    ArrayList<Integer> returningBooks = new ArrayList<Integer>();
    String returnedBooks = "";
    ArrayList<Book> borrowed = new ArrayList<Book>(BooksBorrowed);

    for (Book b : borrowed) {
        returningBooks.add(b.getBookId());
        returnedBooks = returnedBooks+b.getBookId()+" ";
    }

    BooksReturned = new HashSet<Integer>(returningBooks);

    library.RTRN(BooksReturned);
    System.out.println("\nBorrower "+id+" returned books to library: "+returnedBooks+"\n");
}

包模型；
公共类扩展线程{
私家书屋；
私人套书；
私人订书；
私有int-id；
私人互联网运营；
私人图书馆；
private Random randSleep=新建Random（）；
公共借阅者（int id、图书馆、int运行）{
this.library=图书馆；
this.id=id；
this.runs=运行；
noOfBooks=1；
}
公共借款人（）{}
公共字符串getLoans（）{
字符串输出=”；
（b书：借来的书）{
输出+=“”+b.getBookId（）+“”；
}
返回输出；
}
公开募捐
{   
试一试{
初始化（）；
for（int i=0；i

---

}

启动所有线程后，可以添加另一个对所有线程调用join的循环。有关详细信息，请参阅

与直接使用线程不同，您应该真正使用Runnable，它允许您使用一些更高级别的抽象。例如：

ExecutorService threadPool = Executors.newCachedThreadPool();
threadPool.submit(librarian);
for (Borrower b : borrowers) {
    threadPool.submit(b);
}
threadPool.shutdown();
threadPool.awaitTermination(1, TimeUnit.DAYS); // do this in a loop or error if it hasnt finished?

您可以使用join（）等待线程完成。启动所有线程，然后再次循环调用join（）

---

我想你可以使用线程，但是更高的抽象（执行器）可能是更好的选择。听起来我真的应该实现一些东西。但是，不要使用ea