银行 ATM 模拟 排队抽号,(只取款,存取款,只存款,服务机)类型机器,账号,用户信息, Vista,跨行存取钱 Java多线程

好的，这个需求可以使用 Java 多线程实现。

首先，我们需要设计一个 ATM 机类，用于模拟 ATM 机器的行为。这个类应该包含以下属性：

- 类型：只取款、存取款、只存款、服务机
- 状态：空闲、服务中、等待中
- 账号：如果正在服务中，则表示正在服务的用户账号
- 用户信息：如果正在服务中，则表示正在服务的用户信息

然后，我们需要设计一个用户类，用于表示 ATM 的用户。这个类应该包含以下属性：

- 账号
- 密码
- 余额

接下来，我们需要实现一个排队系统，用于管理 ATM 的排队。这个排队系统应该包含以下功能：

- 用户加入排队
- 用户离开排队
- 获取当前排队列表
- 获取排队长度

最后，我们需要实现多线程机制，让 ATM 机器和用户能够并发运行。当用户加入排队时，启动一个新的线程，用于模拟用户的操作行为。当 ATM 机器空闲时，从排队列表中选择一个用户进行服务，并启动一个新的线程，用于模拟 ATM 机器的操作行为。

具体实现可以参考以下代码：

// ATM 机类
public class ATM {
    private String type; // 类型
    private String status; // 状态
    private String account; // 账号
    private String userInfo; // 用户信息

    // 构造函数
    public ATM(String type) {
        this.type = type;
        this.status = "空闲";
        this.account = "";
        this.userInfo = "";
    }

    // 获取类型
    public String getType() {
        return type;
    }

    // 获取状态
    public String getStatus() {
        return status;
    }

    // 获取账号
    public String getAccount() {
        return account;
    }

    // 获取用户信息
    public String getUserInfo() {
        return userInfo;
    }

    // 开始服务
    public void startService(String account, String userInfo) {
        this.status = "服务中";
        this.account = account;
        this.userInfo = userInfo;
    }

    // 结束服务
    public void endService() {
        this.status = "空闲";
        this.account = "";
        this.userInfo = "";
    }

    // 操作
    public void operate() {
        // 模拟操作行为
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 用户类
public class User {
    private String account; // 账号
    private String password; // 密码
    private double balance; // 余额

    // 构造函数
    public User(String account, String password, double balance) {
        this.account = account;
        this.password = password;
        this.balance = balance;
    }

    // 获取账号
    public String getAccount() {
        return account;
    }

    // 获取密码
    public String getPassword() {
        return password;
    }

    // 获取余额
    public double getBalance() {
        return balance;
    }

    // 设置余额
    public void setBalance(double balance) {
        this.balance = balance;
    }

    // 操作
    public void operate() {
        // 模拟操作行为
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 排队系统类
public class QueueSystem {
    private List<User> queue; // 排队列表

    // 构造函数
    public QueueSystem() {
        this.queue = new ArrayList<>();
    }

    // 用户加入排队
    public synchronized void addUser(User user) {
        queue.add(user);
        System.out.println(user.getAccount() + " 加入排队，当前排队长度为 " + queue.size());
    }

    // 用户离开排队
    public synchronized void removeUser(User user) {
        queue.remove(user);
        System.out.println(user.getAccount() + " 离开排队，当前排队长度为 " + queue.size());
    }

    // 获取当前排队列表
    public synchronized List<User> getQueue() {
        return queue;
    }

    // 获取排队长度
    public synchronized int getQueueLength() {
        return queue.size();
    }
}

// 主程序
public class Main {
    public static void main(String[] args) {
        // 初始化 ATM 机器和用户
        ATM atm1 = new ATM("只取款");
        ATM atm2 = new ATM("存取款");
        ATM atm3 = new ATM("只存款");
        ATM atm4 = new ATM("服务机");
        User user1 = new User("10001", "123456", 1000);
        User user2 = new User("10002", "123456", 2000);
        User user3 = new User("10003", "123456", 3000);
        User user4 = new User("10004", "123456", 4000);

        // 初始化排队系统
        QueueSystem queueSystem = new QueueSystem();

        // 用户加入排队
        queueSystem.addUser(user1);
        queueSystem.addUser(user2);
        queueSystem.addUser(user3);
        queueSystem.addUser(user4);

        // 启动 ATM 线程
        new Thread(new ATMThread(atm1, queueSystem)).start();
        new Thread(new ATMThread(atm2, queueSystem)).start();
        new Thread(new ATMThread(atm3, queueSystem)).start();
        new Thread(new ATMThread(atm4, queueSystem)).start();
    }
}

// ATM 线程类
public class ATMThread implements Runnable {
    private ATM atm; // ATM 机器
    private QueueSystem queueSystem; // 排队系统

    // 构造函数
    public ATMThread(ATM atm, QueueSystem queueSystem) {
        this.atm = atm;
        this.queueSystem = queueSystem;
    }

    // 运行
    @Override
    public void run() {
        while (true) {
            // 如果 ATM 机器空闲，选择一个用户进行服务
            if (atm.getStatus().equals("空闲")) {
                List<User> queue = queueSystem.getQueue();
                if (queue.size() > 0) {
                    User user = queue.get(0);
                    queueSystem.removeUser(user);
                    atm.startService(user.getAccount(), "用户信息");
                    System.out.println("ATM " + atm.getType() + " 开始为 " + user.getAccount() + " 服务");
                    user.operate();
                    atm.operate();
                    user.setBalance(user.getBalance() - 100); // 模拟取款或存款操作
                    atm.endService();
                    System.out.println("ATM " + atm.getType() + " 结束为 " + user.getAccount() + " 服务");
                }
            }

            // 等待一段时间后再次运行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

上述代码中，我们使用了 synchronized 关键字来实现线程安全。在 addUser、removeUser、getQueue 和 getQueueLength 方法中，我们使用了 synchronized 关键字来确保多个线程对排队列表的访问是互斥的。在 ATMThread 的 run 方法中，我们使用了 while (true) 循环来不断运行，并使用了 Thread.sleep 方法来让线程等待一段时间后再次运行。当 ATM 机器空闲时，从排队列表中选择一个用户进行服务，并模拟 ATM 机器和用户的操作行为，完成服务后再次变为空闲状态。

当然，这只是一个简单的模拟程序，实际开发中还需要考虑很多其他因素，比如并发访问时的死锁问题、排队系统的优化、多线程的性能问题等等。