银行取钱---验证继承Thread与实现接口Runnable的区别

最新推荐文章于 2022-03-27 19:43:58 发布
最新推荐文章于 2022-03-27 19:43:58 发布
阅读量406 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25986811/article/details/79817543
版权

继承Thread：

package Bank_extends;

public class Bank {

	// 定义静态变量
	static int money = 1000;

	// 柜台Counter取钱的方法
	public void Counter(int money) {// 参数是每次取走的钱
		Bank.money -= money;//取钱后总数减少
		System.out.println("A取走了" + money + "还剩下" + (Bank.money));
	}

	// ATM取钱的方法
	public void ATM(int money) {// 参数是每次取走的钱
		Bank.money -= money;//取钱后总数减少
		System.out.println("B取走了" + money + "还剩下" + (Bank.money));
	}
}
package Bank_extends;

public class MainClass {

	public static void main(String[] args) {

		/**  
		 * 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱  
		 * */  
		// 实力化一个银行对象  
		Bank bank = new Bank();  
		// 实例化两个人，传入同一个银行的对象  
		PersonA pA = new PersonA(bank);  
		PersonB pB = new PersonB(bank);  
		// 两个人开始取钱  
		pA.start();  
		pB.start();  
	}  
}

package Bank_extends;

public class PersonA extends Thread{

	Bank bank;  

	// 通过构造器传入银行对象，确保两个人进入的是一个银行  
	public PersonA(Bank bank) {  
		this.bank = bank;  
	}  

	//重写run方法，在里面实现使用柜台取钱  
	@Override  
	public void run() {  
		while (Bank.money >= 100) {
			bank.Counter(100);// 每次取100块  
			try {  
				sleep(100);// 取完休息0.1秒  
			} catch (InterruptedException e) {  
				e.printStackTrace();  
			}  
		}  
	}  
}

package Bank_extends;

public class PersonB extends Thread{

	Bank bank;  

	// 通过构造器传入银行对象，确保两个人进入的是一个银行  
	public PersonB(Bank bank) {  
		this.bank = bank;  
	}  

	// 重写run方法，在里面实现使用柜台取钱  
	@Override  
	public void run() {  
		while (Bank.money >= 200) {  
			bank.ATM(200);// 每次取200块  
			try {  
				sleep(100);// 取完休息0.1秒  
			} catch (InterruptedException e) {  
				e.printStackTrace();  
			}  
		}  

	}  
}
打印结果：



实现Runnable接口：

package Bank_imp;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Bank {
	/**
	 * 1、提供方法给每条线程返回当前总金额。
	 * @return
	 */
	private int moneyAll = 1000; // 总金额
	public int getMoneyAll() {
		return moneyAll;
	}
	/**
	 * 2、提供方法给每条线程返回同一把锁。
	 * 		通过柜台orATM取钱，都必须同步所有取钱的动作。
	 * @return
	 */
	private Lock lock = new ReentrantLock();// 取钱时上锁
	public Lock getLock(){
		return lock;
	}

	// 柜台Counter取钱的方法
	public void Counter(int money) { 
		moneyAll -= money;//取钱后总数减少
		System.out.println("线程 "+Thread.currentThread().getName()+"从柜台取走了" + money + "还剩下" + (moneyAll));
	}

	// ATM取钱的方法
	public void ATM(int money)  {// 参数是每次取走的钱
		moneyAll -= money;//取钱后总数减少
		System.out.println("线程 "+Thread.currentThread().getName()+"从ATM取走了" + money + "还剩下" + (moneyAll));
	}
}

package Bank_imp;

public class MainClass {

	public static void main(String[] args) {

		// 实力化一个银行对象  
		Bank bank = new Bank();  
		/**
		 *  这里区别与 继承Thread：
		 *  定义为柜台、ATM两种取钱方式
		 *  传入同一个银行的对象  
		 */
		PersonA pA = new PersonA(bank);
		PersonB pB = new PersonB(bank);
		/**
		 *  自定义线程数量，每个线程是一次取钱动作。
		 *  传入取钱方式。
		 */
		Thread t1 = new Thread(pA);
		Thread t2 = new Thread(pA);
		Thread t3 = new Thread(pB);
		Thread t4 = new Thread(pB);

		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}  

}

package Bank_imp;

public class PersonA implements Runnable{ // 实现Runnable
	
	private Bank bank;  
	public PersonA(Bank bank) {  
		this.bank = bank;  
	}
	private int quMoney = 20;// 取钱金额
	@Override  
	public void run() {
		A:while(true){
			System.out.println("线程 "+Thread.currentThread().getName()+" 进入 A用户");
			bank.getLock().lock();// 拿锁
			int moneyAll = bank.getMoneyAll();
			while(moneyAll<quMoney){
				System.out.println("线程 "+Thread.currentThread().getName()+" 关闭");
				bank.getLock().unlock();// 关闭线程前，解锁
				break A;
			}
			System.out.println("线程 "+Thread.currentThread().getName()+"------可以取的钱："+moneyAll);
			bank.Counter(quMoney);
			bank.getLock().unlock();// 取完钱，还锁
		}
	}  
}


package Bank_imp;

public class PersonB extends Thread{

	private Bank bank;  
	public PersonB(Bank bank) {
		this.bank = bank;  
	}  
	private int quMoney = 70;// 取钱金额
	@Override  
	public void run() {  
		A:while(true){
			System.out.println("线程 "+Thread.currentThread().getName()+" 进入 B用户");
			bank.getLock().lock();// 拿锁
			int moneyAll = bank.getMoneyAll();
			while(moneyAll<quMoney){
				System.out.println("线程 "+Thread.currentThread().getName()+" 关闭");
				bank.getLock().unlock();// 关闭线程前，解锁
				break A;
			}
			System.out.println("线程 "+Thread.currentThread().getName()+"------可以取的钱："+moneyAll);
			bank.ATM(quMoney);
			bank.getLock().unlock();// 取完钱，还锁
		}
	}  
}
打印结果一：
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：1000
线程 Thread-1从柜台取走了20还剩下980
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：980
线程 Thread-1从柜台取走了20还剩下960
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：960
线程 Thread-1从柜台取走了20还剩下940
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：940
线程 Thread-1从柜台取走了20还剩下920
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：920
线程 Thread-1从柜台取走了20还剩下900
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：900
线程 Thread-1从柜台取走了20还剩下880
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：880
线程 Thread-1从柜台取走了20还剩下860
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：860
线程 Thread-1从柜台取走了20还剩下840
线程 Thread-3 进入 B用户
线程 Thread-4 进入 B用户
线程 Thread-3------可以取的钱：840
线程 Thread-3从ATM取走了70还剩下770
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：770
线程 Thread-2从柜台取走了20还剩下750
线程 Thread-2 进入 A用户
线程 Thread-1 进入 A用户
线程 Thread-3 进入 B用户
线程 Thread-4------可以取的钱：750
线程 Thread-4从ATM取走了70还剩下680
线程 Thread-4 进入 B用户
线程 Thread-2------可以取的钱：680
线程 Thread-2从柜台取走了20还剩下660
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：660
线程 Thread-2从柜台取走了20还剩下640
线程 Thread-2 进入 A用户
线程 Thread-1------可以取的钱：640
线程 Thread-1从柜台取走了20还剩下620
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：620
线程 Thread-1从柜台取走了20还剩下600
线程 Thread-1 进入 A用户
线程 Thread-3------可以取的钱：600
线程 Thread-3从ATM取走了70还剩下530
线程 Thread-3 进入 B用户
线程 Thread-4------可以取的钱：530
线程 Thread-4从ATM取走了70还剩下460
线程 Thread-4 进入 B用户
线程 Thread-2------可以取的钱：460
线程 Thread-2从柜台取走了20还剩下440
线程 Thread-2 进入 A用户
线程 Thread-1------可以取的钱：440
线程 Thread-1从柜台取走了20还剩下420
线程 Thread-1 进入 A用户
线程 Thread-3------可以取的钱：420
线程 Thread-3从ATM取走了70还剩下350
线程 Thread-3 进入 B用户
线程 Thread-4------可以取的钱：350
线程 Thread-4从ATM取走了70还剩下280
线程 Thread-4 进入 B用户
线程 Thread-2------可以取的钱：280
线程 Thread-2从柜台取走了20还剩下260
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：260
线程 Thread-2从柜台取走了20还剩下240
线程 Thread-2 进入 A用户
线程 Thread-1------可以取的钱：240
线程 Thread-1从柜台取走了20还剩下220
线程 Thread-1 进入 A用户
线程 Thread-3------可以取的钱：220
线程 Thread-3从ATM取走了70还剩下150
线程 Thread-3 进入 B用户
线程 Thread-4------可以取的钱：150
线程 Thread-4从ATM取走了70还剩下80
线程 Thread-4 进入 B用户
线程 Thread-2------可以取的钱：80
线程 Thread-2从柜台取走了20还剩下60
线程 Thread-2 进入 A用户
线程 Thread-1------可以取的钱：60
线程 Thread-1从柜台取走了20还剩下40
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：40
线程 Thread-1从柜台取走了20还剩下20
线程 Thread-1 进入 A用户
线程 Thread-3 关闭
线程 Thread-4 关闭
线程 Thread-2------可以取的钱：20
线程 Thread-2从柜台取走了20还剩下0
线程 Thread-1 关闭
线程 Thread-2 进入 A用户
线程 Thread-2 关闭

打印结果二：

线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：1000
线程 Thread-1从柜台取走了20还剩下980
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：980
线程 Thread-1从柜台取走了20还剩下960
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：960
线程 Thread-1从柜台取走了20还剩下940
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：940
线程 Thread-2从柜台取走了20还剩下920
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：920
线程 Thread-2从柜台取走了20还剩下900
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：900
线程 Thread-2从柜台取走了20还剩下880
线程 Thread-1 进入 A用户
线程 Thread-2 进入 A用户
线程 Thread-4 进入 B用户
线程 Thread-1------可以取的钱：880
线程 Thread-1从柜台取走了20还剩下860
线程 Thread-3 进入 B用户
线程 Thread-3------可以取的钱：860
线程 Thread-1 进入 A用户
线程 Thread-3从ATM取走了70还剩下790
线程 Thread-2------可以取的钱：790
线程 Thread-3 进入 B用户
线程 Thread-2从柜台取走了20还剩下770
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：770
线程 Thread-2从柜台取走了20还剩下750
线程 Thread-4------可以取的钱：750
线程 Thread-4从ATM取走了70还剩下680
线程 Thread-4 进入 B用户
线程 Thread-2 进入 A用户
线程 Thread-4------可以取的钱：680
线程 Thread-4从ATM取走了70还剩下610
线程 Thread-4 进入 B用户
线程 Thread-1------可以取的钱：610
线程 Thread-1从柜台取走了20还剩下590
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：590
线程 Thread-1从柜台取走了20还剩下570
线程 Thread-1 进入 A用户
线程 Thread-3------可以取的钱：570
线程 Thread-3从ATM取走了70还剩下500
线程 Thread-3 进入 B用户
线程 Thread-3------可以取的钱：500
线程 Thread-3从ATM取走了70还剩下430
线程 Thread-3 进入 B用户
线程 Thread-2------可以取的钱：430
线程 Thread-2从柜台取走了20还剩下410
线程 Thread-2 进入 A用户
线程 Thread-2------可以取的钱：410
线程 Thread-2从柜台取走了20还剩下390
线程 Thread-2 进入 A用户
线程 Thread-4------可以取的钱：390
线程 Thread-4从ATM取走了70还剩下320
线程 Thread-4 进入 B用户
线程 Thread-4------可以取的钱：320
线程 Thread-4从ATM取走了70还剩下250
线程 Thread-4 进入 B用户
线程 Thread-4------可以取的钱：250
线程 Thread-4从ATM取走了70还剩下180
线程 Thread-4 进入 B用户
线程 Thread-4------可以取的钱：180
线程 Thread-4从ATM取走了70还剩下110
线程 Thread-4 进入 B用户
线程 Thread-1------可以取的钱：110
线程 Thread-1从柜台取走了20还剩下90
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：90
线程 Thread-1从柜台取走了20还剩下70
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：70
线程 Thread-1从柜台取走了20还剩下50
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：50
线程 Thread-1从柜台取走了20还剩下30
线程 Thread-1 进入 A用户
线程 Thread-1------可以取的钱：30
线程 Thread-1从柜台取走了20还剩下10
线程 Thread-1 进入 A用户
线程 Thread-1 关闭
线程 Thread-3 关闭
线程 Thread-2 关闭
线程 Thread-4 关闭


总结：

继承Thread的逻辑：

1.每个run方法单独运行，且只能运行一个线程。

2.为了满足不同线程之间的通信，只能声明静态变量。

实现Runnable接口：

1.每个run方法可以同时让N个线程使用。

2.可以不用声明静态变量。只要保证资源和锁的同步即可。

3.可以满足更复杂的业务需求。

4.当数据量变大，业务更复杂时，配合Lock使用，更灵活。


qq_25986811
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
07-02 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
07-26
07-02 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱07-02 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
Java中继承thread类与实现Runnable接口的比较
08-30
Java 中继承 Thread 类与实现 Runnable 接口的比较 在 Java 中，创建线程有两种方式：继承 Thread 类和实现 Runnable 接口。这些方式都可以用来创建线程，但它们之间有着一些关键的区别。 继承 Thread 类 继承 ...
Java 多线程 socket 取款例子 runnable callable
weixin_30532987的博客
03-30 95
socket部分参考http://blog.csdn.net/kongxx/article/details/7259465 取款部分参考http://blog.csdn.net/dayday1987/article/details/9971647 先说说取款吧 如何保证数据同步？ 操作时加锁即可 怎么加？使用synchronized关键字 然后自己设置两个线程 一个add 一个w...
Runnable案例 我赚钱她取钱案例 java1615475726
pyhui的技术博客
03-11 184
Runnable案例 我赚钱她取钱案例 java1615475726 需求 演示 定义一个银行卡类 定义一个存钱的功能 定义一个取钱的功能 测试类 结果 存在的问题后续解决
Java基础及提高 之 线程创建的两种方式Thread VS Runnable（附卖票和取钱问题）
紫陌520的博客
09-13 237
1.首先来说说创建线程的两种方式 一种方式是继承Thread类,并重写run()方法 public class MyThread extends Thread{ @Override public void run() { // TODO Auto-generated method stub } } //线程使用 MyT...
Java题-多线程实例--多人同时取钱
琅枫的博客
03-25 2835
两个人AB通过一个账户A在柜台取钱和B在ATM机取钱！ 程序分析：钱的数量要设置成一个静态的变量。两个人要取的同一个对象值 第一种： public class MoneyTest { public static void main(String[] args) { Bank bank = new Bank(); new PersonB(bank,800).start(); new PersonA(bank,600).start();
Java多线程-创建多线程的基本方式二：实现Runnable接口
01-25
本文将详细讲解如何通过实现`Runnable`接口创建多线程，以及这种方式相较于继承`Thread`类的优势。 一、实现Runnable接口创建多线程 1. **步骤** 当一个类需要继承其他类而不能直接继承`Thread`类时，可以选择...
基于JAVA的多线程实现方法-实现Runnable接口
08-01
基于JAVA的多线程实现方法-实现Runnable接口 将需要实现多线程的类声明为实现Runnable接口的类，实现run()方法，并将线程体放在该方法里。
Java面向对象程序设计-并发（实现Runnable接口）.pptx
11-04
实现Runnable接口需要创建一个Thread类的实例，并将Runnable对象传递给Thread的构造函数。然后，调用Thread的start()方法来启动线程。 下面是一个实现Runnable接口的示例代码： ```java public static void main...
java实现多线程的两种方式继承Thread类和实现Runnable接口的方法
09-01
在Java中，创建多线程有两种主要的方式：继承`Thread`类和实现`Runnable`接口。这两种方式都是为了实现程序的并发执行，即允许多个任务在同一时间片内交替执行。下面我们将详细讨论这两种方法及其区别。 ### 继承...
Java设计一个银行帐户类（继承与多态）
07-01
Java设计一个银行帐户类，成员变量包括账号、储户姓名、开户时间、身份证号码、存款余额等帐户信息，成员方法包括存款、取款操作。
两个人AB通过一个账户A在柜台取钱和B在ATM机取钱-java篇
weixin_40544651的博客
02-12 3313
钱的数量要设置成一个静态的变量。两个人要取的同一个对象值 import java.util.Random; import java.util.concurrent.atomic.AtomicInteger; /** * @Author: 张 * @Date: 2019/2/11 15:00 * @Version: 1.0 * @Description: 1.0 */ public cl...
多线程编程：两个人A、B同时对一个账户取钱（A从ATM取，B从柜台取）
weixin_41762621的博客
10-20 7258
分析： 1）账户的钱必须设置是静态的 2）所有人操作的是同一个账户，操作的时候要加同步锁 代码： package ThreadTest; import java.util.Objects; public class Bank { // 假设一个账户有1000块钱 static double money = 1000; // 柜台Counter取钱的方法 priva...
java - 继承 ，重写
请叫我王老魔
12-11 405
java 是单继承的， 一个子类只能从一个父类那里继承，即一个孩子只能有一个父亲，但是一个父亲可以有多个孩子。extends 关键字当生成子类对象时，默认情况下，首先调用父类的无参数（默认）构造函数，–>>然后再调用子类的构造函数. 意味着首先生成父亲的对象，然后再生成孩子， 如果父类中没有默认构造函数，那么程序会报错。 但是使用super()关键字可以显示的调用父类的某一个制定的构造函数，而不
java多线程存钱，取钱例子
qq_17524035的博客
12-09 2232
java多线程存钱，取钱例子
java基础 day14数据安全，银行账户取款例子，synchronized()使用、面试题，死锁，线程安全
weixin_43734992的博客
03-27 687
数据安全 关于多线程并发环境下，数据的安全问题 为什么这个是重点?以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写. 最重要的是:你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据:在多线程并发的环境下是否是安全的。(重点:***** ) 什么时候数据在多线程并发的环境下会存在安全问题呢? 三个条件:条件1:多线程并发，条件2:有共享数据，条件3:共享数据有修改的行
201711671103《Java程序设计》多线程的应用案例
CHENCHWT的博客
11-24 286
两个人AB通过一个账户A在柜台取钱和B在ATM机取钱！ 1.先创建一个Bank类 代码：package bank; public class Bank {           static int money = 1000;   // 假设一个账户有1000块钱 // 柜台Counter取钱的方法 public void Counter(int money) { // 参数是每次取走的钱  ...
银行业务（多线程+同步锁+自定义异常）
小程同学
08-21 234
案例描述： 此小项目，是用多线程和 Sychronized 模仿银行账号的并发处理，通过自定义异常，在账目出现错误时，抛出合理异常。 案例结构： Bank.java public class Bank { private String name; private int money; public Bank(String name, int money) { this.name = name; this.money = money; } publi.
Java特别篇-关于线程创建的三种方式的总结对比
最新发布
02-04
- 与继承Thread类相比，这种方式更加灵活，因为一个类可以同时实现多个接口，而不仅仅是Runnable。此外，通过这种方式，避免了Java的单继承限制。 - 通过匿名内部类或lambda表达式，实现Runnable接口的代码更为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值