编写java应用程序实现如下功能:创建工作线程,模拟银行现金账户取款操作。多个线程的简单介绍

本文目录一览：

• 1、用java编写多线程银行ATM 模拟程序
• 2、使用JAVA编写一个简单的银行存取款程序
• 3、银行运行模拟 设计一个Java应用程序，模拟顾客到银行存取款的现象。 谢谢
• 4、求两道编程题程序！ 1.模拟银行取款,制造卡和折同时取款时出现的线程安全问题,分别用同步代码块和同步方法
• 5、用JAVA语言编写程序，模拟银行账户功能。要有： 属性：账号、储户姓名、地址、存款余额、最小余额。

用java编写多线程银行ATM 模拟程序

先构建一个客户端，再构建一个服务器端，其实做一个简单的界面，建立一个数据库，调用SQl 语句，，实现单机，模拟多线程的就可以了，服务器部分不做也可以模拟出来。。

PS:这不会是程序专题训练一吧。。。

使用JAVA编写一个简单的银行存取款程序

package com.lw.thread;

/*

银行账户类Account（不能透支），

包含账号id（10~16位数字），密码password（6位数字），户主姓名name，余额balence

*/

public class Account {

private String id;

private int password;

private String name;

private double balence;

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public int getPassword() {

return password;

}

public void setPassword(int password) {

this.password = password;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getBalence() {

return balence;

}

public void setBalence(double balence) {

this.balence = balence;

}

/*

* 默认构造账户信息为：1111111111111111,666666，钱三多，888888.88。

*/

public Account() {

super();

this.id = “1111111111111111”;

this.password = 666666;

this.name = “钱三多”;

this.balence = 888888.88;

}

/*

* 另一个构造方法带4个参数分别初始化4个属性（带数据有效性验证）。

*/

public Account(String id, int password, String name, double balence) {

this.id = id;

this.password = password;

this.name = name;

this.balence = balence;

}

/*

* 查询余额

*/

public static double selectMoney(Account account) {

return account.getBalence();

}

/*

* 存钱

*/

public static String setMoney(Account account, double balence) {

if (balence 0) {

return “存钱失败，请正确放入！”;

}

double d = balence + account.getBalence();

account.setBalence(d);

return “您存入了” + balence + “元，现账户余额为+” + d;

}

/*

* 取钱

*/

public static String getMoney(Account account, double balence) {

double d = account.getBalence();

if (balence d) {

return “您的余额不足！”;

}

account.setBalence(d – balence);

return “您取出了” + balence + “元，现账户余额为+” + account.getBalence();

}

}

银行运行模拟 设计一个Java应用程序，模拟顾客到银行存取款的现象。 谢谢

使用的生产者和消费者模型具有如下特点：

(1)本实验的多个缓冲区不是环形循环的，也不要求按顺序访问。生产者可以把产品放到目前某一个空缓冲区中。

(2)消费者只消费指定生产者的产品。

(3)在测试用例文件中指定了所有的生产和消费的需求，只有当共享缓冲区的数据满足了所有关于它的消费需求后，此共享缓冲区才可以作为空闲空间允许新的生产者使用。

(4)本实验在为生产者分配缓冲区时各生产者间必须互斥，此后各个生产者的具体生产活动可以并发。而消费者之间只有在对同一产品进行消费时才需要互斥，同时它们在消费过程结束时需要判断该消费对象是否已经消费完毕并清除该产品。

Windows 用来实现同步和互斥的实体。在Windows 中，常见的同步对象有：信号量(Semaphore)、

互斥量(Mutex)、临界段(CriticalSection)和事件(Event)等。本程序中用到了前三个。使用这些对象都分

为三个步骤，一是创建或者初始化：接着请求该同步对象，随即进入临界区，这一步对应于互斥量的

上锁；最后释放该同步对象，这对应于互斥量的解锁。这些同步对象在一个线程中创建，在其他线程

中都可以使用，从而实现同步互斥。当然，在进程间使用这些同步对象实现同步的方法是类似的。

1．用锁操作原语实现互斥

为解决进程互斥进人临界区的问题，可为每类临界区设置一把锁，该锁有打开和关闭两种状态，进程执行临界区程序的操作按下列步骤进行：

①关锁。先检查锁的状态，如为关闭状态，则等待其打开；如已打开了，则将其关闭，继续执行步骤②的操作。

②执行临界区程序。

③开锁。将锁打开，退出临界区。

2．信号量及WAIT，SIGNAL操作原语

信号量的初值可以由系统根据资源情况和使用需要来确定。在初始条件下信号量的指针项可以置为0，表示队列为空。信号量在使用过程中它的值是可变的，但只能由WAIT，SIGNAL操作来改变。设信号量为S，对S的WAIT操作记为WAIT（S），对它的SIGNAL操作记为SIGNAL（S）。

WAIT（S）：顺序执行以下两个动作：

①信号量的值减1，即S=S－1；

②如果S≥0，则该进程继续执行；

如果 S（0，则把该进程的状态置为阻塞态，把相应的WAITCB连人该信号量队列的末尾，并放弃处理机，进行等待（直至其它进程在S上执行SIGNAL操作，把它释放出来为止）。

SIGNAL（S）：顺序执行以下两个动作

①S值加 1，即 S=S＋1；

②如果S）0，则该进程继续运行；

如果S（0则释放信号量队列上的第一个PCB（既信号量指针项所指向的PCB）所对应的进程（把阻塞态改为就绪态），执行SIGNAL操作的进程继续运行。

在具体实现时注意，WAIT，SIGNAL操作都应作为一个整体实施，不允许分割或相互穿插执行。也就是说，WAIT，SIGNAL操作各自都好像对应一条指令，需要不间断地做下去，否则会造成混乱。

从物理概念上讲，信号量S）时，S值表示可用资源的数量。执行一次WAIT操作意味着请求分配一个单位资源，因此S值减1；当S0时，表示已无可用资源，请求者必须等待别的进程释放了该类资源，它才能运行下去。所以它要排队。而执行一次SIGNAL操作意味着释放一个单位资源，因此S值加1；若S（0时，表示有某些进程正在等待该资源，因而要把队列头上的进程唤醒，释放资源的进程总是可以运行下去的。

—————

/**

* 生产者

*

*/

public class Producer implements Runnable{

private Semaphore mutex,full,empty;

private Buffer buf;

String name;

public Producer(String name,Semaphore mutex,Semaphore full,Semaphore empty,Buffer buf){

this.mutex = mutex;

this.full = full;

this.empty = empty;

this.buf = buf;

this.name = name;

}

public void run(){

while(true){

empty.p();

mutex.p();

System.out.println(name+” inserts a new product into “+buf.nextEmptyIndex);

buf.nextEmptyIndex = (buf.nextEmptyIndex+1)%buf.size;

mutex.v();

full.v();

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

—————

/**

* 消费者

*

*/

public class Customer implements Runnable{

private Semaphore mutex,full,empty;

private Buffer buf;

String name;

public Customer(String name,Semaphore mutex,Semaphore full,Semaphore empty,Buffer buf){

this.mutex = mutex;

this.full = full;

this.empty = empty;

this.buf = buf;

this.name = name;

}

public void run(){

while(true){

full.p();

mutex.p();

System.out.println(name+” gets a product from “+buf.nextFullIndex);

buf.nextFullIndex = (buf.nextFullIndex+1)%buf.size;

mutex.v();

empty.v();

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

————————-

/**

* 缓冲区

*

*/

public class Buffer{

public Buffer(int size,int nextEmpty,int nextFull){

this.nextEmptyIndex = nextEmpty;

this.nextFullIndex = nextFull;

this.size = size;

}

public int size;

public int nextEmptyIndex;

public int nextFullIndex;

}

—————–

/**

* 此类用来模拟信号量

*

*/

public class Semaphore{

private int semValue;

public Semaphore(int semValue){

this.semValue = semValue;

}

public synchronized void p(){

semValue–;

if(semValue0){

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public synchronized void v(){

semValue++;

if(semValue=0){

this.notify();

}

}

}

————————

public class Test extends Thread

{

public static void main(String[] args)

{

Buffer bf=new Buffer(10,0,0);

Semaphore mutex=new Semaphore(1);

Semaphore full=new Semaphore(0);

Semaphore empty=new Semaphore(10);

//new Thread(new Producer(“p001”,mutex,full,empty,bf)).start();

Producer p=new Producer(“p001”,mutex,full,empty,bf);

new Thread(new Producer(“p002”,mutex,full,empty,bf)).start();

new Thread(new Producer(“p003”,mutex,full,empty,bf)).start();

new Thread(new Producer(“p004”,mutex,full,empty,bf)).start();

new Thread(new Producer(“p005”,mutex,full,empty,bf)).start();

try{

sleep(3000);

}

catch(Exception ex)

{

ex.printStackTrace();

}

new Thread(new Customer(“c001”,mutex,full,empty,bf)).start();

new Thread(new Customer(“c002”,mutex,full,empty,bf)).start();

new Thread(new Customer(“c003”,mutex,full,empty,bf)).start();

new Thread(new Customer(“c004”,mutex,full,empty,bf)).start();

new Thread(new Customer(“c005”,mutex,full,empty,bf)).start();

}

}

——————————————–

求两道编程题程序！ 1.模拟银行取款,制造卡和折同时取款时出现的线程安全问题,分别用同步代码块和同步方法

你好楼主，看看我的代码行不

第一题 同步代码块实现：

class TB implements Runnable {

int i = 100;

int money = 11000;

boolean flag = true;

public void run() {

while(flag) {

synchronized (this){

if(i=money) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

money -= i;

System.out.println(Thread.currentThread().getName()+”取款”+i+”元。余额为：”+money);

}else flag = false;

}

}

}

}

public class Bank {

public static void main(String[] args) {

TB2 tt = new TB2();

Thread t1 = new Thread(tt);

Thread t2 = new Thread(tt);

t1.setName(“银行卡”);

t2.setName(“存折用户”);

t1.start();

t2.start();

}

}

第一题同步方法实现，主方法的那个类还是一样，看看TB：

class TB implements Runnable {

int i = 100;

int money = 1100;

boolean flag = true;

public void run() {

while(flag) {

QuKuan();

}

}

public synchronized void QuKuan(){

if(i=1100) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

money -= i;

System.out.println(Thread.currentThread().getName()+”取款”+i+”元。余额为：”+money);

}

}

}

=========================================================================

第二题

==========================================================================

public class Bank {

public static void main(String[] args) {

TB2 tt = new TB2();

Thread saveThed = new Thread(tt);

Thread payThed = new Thread(tt);

saveThed.setName(“saveMoney”);

payThed.setName(“payMoney”);

saveThed.start();

payThed.start();

}

}

class TB2 implements Runnable {

int i = 50;

int money = 100;

boolean flag = true;

int count=0;

public void run() {

while(count100) {//存取操作100次就可以了

if(Thread.currentThread().getName().equals(“saveMoney”)){

CunKuan();

}else if(Thread.currentThread().getName().equals(“payMoney”)){

QuKuan();

}

//为了方便观看，程序跑得慢一点，这里我们休眠一段时间

//去掉后效率更高，并且结果正确

try {

Thread.sleep(500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

count++;

}

}

public void QuKuan(){

if(money=50) {

money -= i;

System.out.println(Thread.currentThread().getName()+”取款”+i+”元。余额为：”+money);

}else{

Thread.yield();//停止当前线程，执行其线程

}

}

public void CunKuan(){

if(money50) {

money += i;

System.out.println(Thread.currentThread().getName()+”存款”+i+”元。余额为：”+money);

}else{

Thread.yield();

}

}

}

怎么样？？？

用JAVA语言编写程序，模拟银行账户功能。要有： 属性：账号、储户姓名、地址、存款余额、最小余额。

package com.cshr.test;

public class bank {

private String card;//账号

private String uname;//储户姓名

private String address;//地址

private double money;//存款余额

public static final double minMoney=0;//最小余额

public bank(){}

public String getCard() {

return card;

}

public void setCard(String card) {

this.card = card;

}

public String getUname() {

return uname;

}

public void setUname(String uname) {

this.uname = uname;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

public double getMoney() {

return money;

}

public void setMoney(double money) {

this.money = money;

}

public static double getMinmoney() {

return minMoney;

}

}

package com.cshr.test;

import java.util.List;

import org.hibernate.Session;

import com.utils.HibernateSessionFactory;

public class bankDao {

//存款

public void addMoney(double money,double Sqlmoney,String card){

Session session=HibernateSessionFactory.getSession();

try{

session.beginTransaction();

String hql=”update bank b set b.money+=”+money+Sqlmoney+” where b.card='”+card+”‘”;

session.createQuery(hql).executeUpdate();

session.beginTransaction().commit();

}catch(Exception e){

e.printStackTrace();

session.beginTransaction().rollback();

}finally{

HibernateSessionFactory.closeSession();

}

}

//取款

public void delMoney(double money,double Sqlmoney,String card){

Session session=HibernateSessionFactory.getSession();

try{

session.beginTransaction();

String hql=”update bank b set b.money+=”+(Sqlmoney-money)+” where b.card='”+card+”‘”;

session.createQuery(hql).executeUpdate();

session.beginTransaction().commit();

}catch(Exception e){

e.printStackTrace();

System.out.println(“取款失败”);

session.beginTransaction().rollback();

}finally{

HibernateSessionFactory.closeSession();

}

}

//查询所有

public Listbank selectfind(){

Session session=HibernateSessionFactory.getSession();

session.beginTransaction();

String hql=”select b from bank b “;

Listbank list=session.createQuery(hql).list();

return list;

}

}