题目：设计一个Java程序，在线图书馆管理系统。（进阶）

题目：设计一个Java程序，实现一个简单的在线图书馆管理系统。

要求：

使用面向对象编程，定义至少两个类：Book（书籍）和Library（图书馆）。
书籍类包含属性：书名、作者、出版年份、ISBN号、价格。
图书馆类包含属性：图书馆名称、地址、藏书列表（List）。
为书籍类提供构造方法、getter和setter方法。
为图书馆类提供构造方法、getter和setter方法。
在图书馆类中，实现以下功能： a. 添加书籍到藏书列表。 b. 根据书名或作者查找书籍。 c. 显示所有藏书信息。
使用Java集合框架存储和管理书籍信息。
使用Java I/O操作，将图书馆的藏书信息保存到文件中，以及从文件中读取藏书信息。
使用Java多线程，实现一个简单的图书借阅功能，允许多个用户同时借阅书籍。
使用Java网络编程，实现一个简单的图书馆查询系统，允许用户通过网络查询图书馆的书籍信息。

示例代码：
好的，以下是中文注释的代码：

// Book.java
public class Book {
    private String title; // 书名
    private String author; // 作者
    private int year; // 出版年份
    private String isbn; // ISBN号
    private double price; // 价格

    public Book(String title, String author, int year, String isbn, double price) {
        this.title = title;
        this.author = author;
        this.year = year;
        this.isbn = isbn;
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", year=" + year +
                ", isbn='" + isbn + '\'' +
                ", price=" + price +
                '}';
    }
}

// Library.java
import java.util.*;
import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class Library {
    private String name; // 图书馆名称
    private String address; // 地址
    private List<Book> books; // 图书列表
    private ExecutorService executor; // 线程池
    private final Object lock = new Object(); // 同步锁对象

    public Library(String name, String address) {
        this.name = name;
        this.address = address;
        this.books = new ArrayList<>();
        this.executor = Executors.newFixedThreadPool(10); // 创建10个线程的线程池
    }

    public void addBook(Book book) {
        synchronized (lock) { // 同步添加图书操作
            books.add(book);
        }
    }

    public Book findBook(String title, String author) {
        synchronized (lock) { // 同步查找图书操作
            for (Book book : books) {
                if (book.getTitle().equals(title) || book.getAuthor().equals(author)) {
                    return book;
                }
            }
        }
        return null;
    }

    public void displayBooks() {
        synchronized (lock) { // 同步显示所有图书操作
            for (Book book : books) {
                System.out.println(book);
            }
        }
    }

    public void saveBooksToFile(String filename) throws IOException {
        synchronized (lock) { // 同步保存图书到文件操作
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(filename));
            out.writeObject(books);
            out.close();
        }
    }

    public void loadBooksFromFile(String filename) throws IOException, ClassNotFoundException {
        synchronized (lock) { // 同步从文件加载图书操作
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(filename));
            books = (List<Book>) in.readObject();
            in.close();
        }
    }

    public void borrowBook(String title, String author) {
        executor.execute(new Runnable() { // 使用线程池异步执行借书操作
            @Override
            public void run() {
                synchronized (lock) { // 同步借书操作
                    Book book = findBook(title, author);
                    if (book != null) {
                        try {
                            System.out.println("Borrowing book: " + book.getTitle());
                            Thread.sleep(2000); // 模拟借书耗时
                            System.out.println("Book borrowed: " + book.getTitle());
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("Book not found");
                    }
                }
            }
        });
    }

    public void startLibraryQueryServer() throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080); // 启动一个查询服务器，监听8080端口
        while (true) {
            try {
                Socket clientSocket = serverSocket.accept(); // 接受客户端连接请求
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                String request = in.readLine(); // 读取客户端请求内容
                String response = processRequest(request); // 处理客户端请求并生成响应结果
                out.println(response); // 将响应结果发送回客户端
                clientSocket.close(); // 关闭客户端连接
            } catch (IOException e) {
                e.printStackTrace(); // 处理可能出现的异常情况
            }
        }
    }

    private String processRequest(String request) {
        String[] tokens = request.split("\\s+"); // 将请求内容按空格分割成多个标记（token）
        if (tokens[0].equalsIgnoreCase("find")) { // 如果请求是查找图书操作
            synchronized (lock) { // 同步查找图书操作
                Book book = findBook(tokens[1], tokens[2]); // 根据标题和作者查找图书信息
                if (book != null) {
                    return book.toString(); // 返回图书信息字符串表示形式
                } else {
                    return "Book not found"; // 返回图书未找到的提示信息
                }
            }
        } else if (tokens[0].equalsIgnoreCase("display")) { // 如果请求是显示所有图书操作
            synchronized (lock) { // 同步显示所有图书操作
                return displayBooks(); // 调用显示所有图书方法并返回其结果字符串表示形式
            }
        } else {
            return "Invalid request"; // 返回无效请求的提示信息
        }
    }
}