文章目录
多线程
1.Process与Thread
-
说起进程,就不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,就是一个静态的概念
-
而进程则是执行程序的一次执行过程,它是一个动态的概念。是系统资源分配的单位
-
通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的单位
注意:很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器。如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错局。
核心概念:
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程
- main()称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统密切相关的,先后顺序是不能认为的干预的
- 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
- 线程会带来额外的开销,如cpu调度时间,并发控制开销
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
2.线程创建
-
三种创建方式
2.1 Thread
- 自定义线程类继承Thread类
- 重写run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
public static void main(String() args){
//创建线程对象
StartThreadl t=new StartThreadl();
t.start();
}
public class StartThreadl extends Thread{
@Override
public void run(){
//线程体
for(int i=1;i<20;i++){
System.out.println("我在听课")
}
}
}
线程不一定立即执行,CPU安排调度
Class Thread
Java.lang.Objeect
java.lang.Thread
-
线程是程序中执行的线程,Java虚拟机允许应用程序同时执行多个执行线程
-
每个线程都有优先权。具有较高优先级的线程优先于优先级较低的线程执行,每个线程可能不会被标记为守护程序。当在某个线程中运行的代码创建一个新的Thread对象时,新县城线程的优先级最初设置为等于创建线程的优先级,并且当且仅当创建线程是守护进程时才是守护线程
-
当Java虚拟机启动时,通常由一个非守护进程线程(通常调用某些指定类的名为main的方法)。Java虚拟机将继续执行线程,指导发生以下任一情况:
- 已经调用Runtime类的exit方法,并且安全管理器已经允许进行退出操作
- 所有不是守护进程线程的线程都已经死亡,无论是从调用返回到run方法还是抛出超出run方法的run
-
创建一个新的执行线程有两种方法,一个是将一个类声明为Thread的子类。这个子类应该重写run类的方法Thread。然后可以分配并启动子类的实例。另一种方法是
package com.kuang.demo1;
//创建线程方式一:继承Thread()类,重写run()方法,调用start开启线程
//总结:注意,线程开启不一定立即执行,由CPU调度执行
public class TestThraed1 extends Thread{
@Override
public void run() {
//run方法线程体
for(int i=0;i<20;i++){
System.out.println("我在看代码"+i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
TestThraed1 testThraed1=new TestThraed1();
//调用start()方法开启线程
testThraed1.start();
for(int i=0;i<20;i++){
System.out.println("我在学习多线程"+i);
}
}
}
案例:下载图片
package com.kuang.demo1;
import com.sun.xml.internal.ws.api.server.WebServiceContextDelegate;
import org.apache.commons.io.FileUtils;
import java.io.IOException;
import java.io.File;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class TestThread2 extends Thread{
private String url;//网络图片地址
private String name;//保存的文件名
public TestThread2(String url,String name){
this.url=url;
this.name=name;
}
//下载图片的线程体
@Override
public void run() {
WebDownloader webDownloader=new WebDownloader();
webDownloader.downloader(url,name);
System.out.println("下载的文件名为:"+name);
}
public static void main(String[] args) {
TestThread2 t1=new TestThread2("https://i0.hdslb.com/bfs/space/cb1c3ef50e22b6096fde67febe863494caefebad.png@2560w_400h_100q_1o.webp","1.jpg");
TestThread2 t2=new TestThread2("https://i0.hdslb.com/bfs/space/cb1c3ef50e22b6096fde67febe863494caefebad.png@2560w_400h_100q_1o.webp","2.jpg");
TestThread2 t3=new TestThread2("https://i0.hdslb.com/bfs/space/cb1c3ef50e22b6096fde67febe863494caefebad.png@2560w_400h_100q_1o.webp","2.jpg");
//先下载t1
t1.start();
//然后是t2
t2.start();
//最后是t3
t3.start();
}
}
//下载器
class WebDownloader{
//下载方法
public void downloader(String url,String name){
try{
FileUtils.copyURLToFile(new URL(url),new File(name));
}catch(IOException e){
e.printStackTrace();
System.out.println("IO异常,downloader方法出现问题");
}
}
}
2.2 实现Runnable
- 定义MyRunnable类实现Runnable接口
- 实现run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
package com.kuang.demo1;
//创建线程方式2,实现runnable接口,重写run方法,执行线程需要丢入runnable接口实现类,调用start方法
public class TestThread3 implements Runnable{
public void run() {
//run方法线程体
for(int i=0;i<20;i++){
System.out.println("我在看代码"+i);
}
}
public static void main(String[] args) {
//创建runnable接口实现的类对象
TestThread3 testThread3=new TestThread3();
//创建线程对象,通过线程对象来开启我们的线程,代理
//Thread thread=new Thread();
//thread.start();
new Thread(testThread3).start();
for(int i=0;i<2000;i++){
System.out.println("我在学习多线程"+i);
}
}
}
小结:
-
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程:子类对象.start()
- 不建议使用:避免OOP单继承局限性
-
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程:传入目标对象+Thread对象.start()
- 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
//一份资源 StartThread4 staion=new StartThread4(); //多个代理 new Thread(station,"小明").start(); new Thread(station,"老师").start(); new Thread(station,"小红").start();
package com.kuang.demo1; //多个线程同时操作同一个对象 //买火车票的例子 //发现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱 public class TestThread4 implements Runnable{ //票数 private int ticketNums=10; @Override public void run() { while(true){ if(ticketNums<=0){ break; } //模拟延时 try{ Thread.sleep(200); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票"); } } public static void main(String[] args){ TestThread4 ticket=new TestThread4(); new Thread(ticket,"小明").start(); new Thread(ticket,"老师").start(); new Thread(ticket,"黄牛党").start(); new Thread(ticket,"黄牛党").start(); new Thread(ticket,"黄牛党").start(); } }
案例:龟兔赛跑-Race
- 首先来个赛道距离,然后要离终点越来越近
- 判断比赛是否结束
- 打印出胜利者
- 龟兔赛跑开始
- 故事中是乌龟赢的,兔子需要睡觉,所以我们要模拟兔子睡觉
- 终于,乌龟赢得比赛
package com.kuang.demo1;
//模拟龟兔赛跑
public class Race implements Runnable{
//胜利者
private static String winner;
@Override
public void run() {
for(int i=0;i<=100;i++){
//模拟兔子休息
if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
try{
Thread.sleep(10);
}catch(InterruptedException e){
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag=gameOver(i);
//如果比赛结束了,就停止程序
if(flag){
break;
}
System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
}
}
//判断是否完成比赛
private boolean gameOver(int steps){
//判断是否有胜利者
if(winner!=null){//已经存在胜利者了
return true;
}{
if(steps==100){
winner=Thread.currentThread().getName();
System.out.println("winner is"+winner);
}
}
return false;
}
public static void main(String[] args) {
Race race=new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
2.3 实现Callable接口(了解即可)
- 实现Callable接口,需要返回值类型
- 重写call方法,需要抛出异常
- 创建目标对象
- 创建执行服务:ExecutorService ser=Executors.newFixedThreadPool(1);
- 提交执行:Future result1=ser.submit(t1);
- 获取结果:boolean r1=result1.get()
- 关闭服务:ser.shutdownNow();
package com.kuang.demo2;
import com.kuang.demo1.TestThread2;
import com.sun.org.apache.xpath.internal.operations.Bool;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
//线程创建方式三:实现
/*
callable的好处
1.可以定义返回值
2.可以抛出异常
*/
public class TestCallable implements Callable<Boolean>{
private String url;//网络图片地址
private String name;//保存的文件名
public TestCallable(String url,String name){
this.url=url;
this.name=name;
}
//下载图片的线程体
@Override
public Boolean call() {
WebDownloader webDownloader=new WebDownloader();
webDownloader.downloader(url,name);
System.out.println("下载的文件名为:"+name);
return true;
}
public static void main(String[] args) throws Exception{
TestCallable t1=new TestCallable("https://i0.hdslb.com/bfs/space/cb1c3ef50e22b6096fde67febe863494caefebad.png@2560w_400h_100q_1o.webp","1.jpg");
TestCallable t2=new TestCallable("https://i0.hdslb.com/bfs/space/cb1c3ef50e22b6096fde67febe863494caefebad.png@2560w_400h_100q_1o.webp","2.jpg");
TestCallable t3=new TestCallable("https://i0.hdslb.com/bfs/space/cb1c3ef50e22b6096fde67febe863494caefebad.png@2560w_400h_100q_1o.webp","3.jpg");
//创建执行服务
ExecutorService ser= Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> r1=ser.submit(t1);
Future<Boolean> r2=ser.submit(t2);
Future<Boolean> r3=ser.submit(t3);
//获取结果
boolean rs1=r1.get();
boolean rs2=r2.get();
boolean rs3=r3.get();
System.out.println(rs1);
System.out.println(rs2);
System.out.println(rs3);
//关闭服务
ser.shutdownNow();
}
}
class WebDownloader{
//下载方法
public void downloader(String url,String name){
try{
FileUtils.copyURLToFile(new URL(url),new File(name));
}catch(IOException e){
e.printStackTrace();
System.out.println("IO异常,downloader方法出现问题");
}
}
}
2.4 静态代理
你:真实角色
婚庆公司:代理你,帮你处理结婚的事
结婚:实现都实现结婚接口即可
演示:实现静态代理对比Thread
//静态代理总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处
// 代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
You you=new You();//你要结婚
new Thread(()-> System.out.println("我爱你")).start();
new WeddingCompany(new You()).HappyMarry();
WeddingCompany weddingCompany=new WeddingCompany(new You());
weddingCompany.HappyMarry();
}
}
interface Marry{
//四大喜事 久旱逢甘露,他乡遇故知,洞房花烛夜,金榜题名时
void HappyMarry();
}
class You implements Marry{
@Override
public void HappyMarry() {
System.out.println("要结婚了");
}
}
//代理角色,帮助你结婚
class WeddingCompany implements Marry{
//代理谁
private Marry targrt;
public WeddingCompany(Marry targrt){
this.targrt=targrt;
}
@Override
public void HappyMarry() {
before();
this.targrt.HappyMarry();
after();
}
private void after(){
System.out.println("结婚之后,收尾款");
}
private void before(){
System.out.println("结婚之前,布置");
}
}
2.5 Lamda表达式
-
希腊字母表中排序第十一位的字母,英文名称为Lambda
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
(params)->expression[表达式]
(params)->statement[表达式]
(params)->{statemrnts}
a->System.out.println(" i like lambda–>"+a);
new Thread(()->System.out.println(“多线程学习。”)).start();
-
为什么使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉了一堆没有意义的代码,只留下核心的逻辑
-
也许你会说,我看了lambda表达式,不但不觉得简洁。反而觉得更乱,看不懂了。那是因为我们还没有习惯,用的多了,看习惯了,就好了。
-
理解Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在
-
函数式接口的定义
-
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口
public interface Runnable{ public abstract void run(); }
-
对于函数式接口,我们可以通过lambda表达式来创建该接口的对象
演示:代码推导lambda表达式
package com.kuang.lambda; //推导lambda表达式 public class TestLambda1 { //3,静态内部类 static class Like2 implements ILike{ @Override public void lambda() { System.out.println("i like lambda2"); } } public static void main(String[] args) { ILike like=new Like(); like.lambda(); like=new Like2(); like.lambda(); //4.局部内部类 class Like3 implements ILike{ @Override public void lambda() { System.out.println("i like lambda2"); } } like =new Like3(); like.lambda(); //5.匿名内部类,没有类的名称,必须借助接口或者父类 like=new ILike(){ @Override public void lambda() { System.out.println("i like lambda4"); } }; like.lambda(); //6.用lambda简化 like=()->{ System.out.println("i like lambda5"); }; like.lambda(); } } //1.定义一个函数式接口 interface ILike{ void lambda(); } //2.实现类 class Like implements ILike{ @Override public void lambda() { System.out.println("i like lambda"); } }
package com.kuang.lambda; public class TestLambda2 { public static void main(String[] args) { //1.lambda表示简化 ILove love=(int a)->{ { System.out.println("i love you-->"+a); } }; //简化1.参数类型 love=(a)->{ System.out.println("i love you-->"+a); }; //简化2,简化括号 love=a->{ System.out.println("i love you-->"+a); }; //简化3:去掉花括号 love =a-> System.out.println("i love you-->"+a); //总结: //lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹 //前提是接口为函数式接口 //多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号 love.love(251); } } interface ILove{ void love(int a); }
-
3 线程状态(五大状态)
3.1 线程状态
3.2 线程方法
3.3 停止线程
- 不推荐使用JDK提供的stop(),destroy()。【已废弃】
- 推荐线程自己停止下来
- 建议使用一个标志位进行终止变量,当flag=false,则终止线程运行。
package com.kuang.state;
public class TestStop implements Runnable{
//1.设置一个标志位
private boolean flag=true;
@Override
public void run() {
int i=0;
while(flag){
System.out.println("run……Thread"+i++);
}
}
//2.设置一个公开的方法停止线程,转换标志位
public void stop(){
this.flag=false;
}
public static void main(String[] args) {
TestStop testStop=new TestStop();
new Thread(testStop).start();
for(int i=0;i<1000;i++){
System.out.println("main"+i);
if(i==900){
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println("线程该停止了");
}
}
}
}
3.4 线程休眠
- sleep(时间)指定当前线程阻塞的毫秒数
- sleep存在异常InterruptedException
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延迟,倒计时等
- 每一个对象都有一个锁,sleep不会释放锁
演示:计时
package com.kuang.state;
import java.text.SimpleDateFormat;
import java.util.Date;
//模拟倒计时
public class TestSleep2 {
public static void main(String[] args) {
//打印当前系统时间
Date startTime=new Date(System.currentTimeMillis());//获取系统当前时间
while(true){
try{
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime=new Date(System.currentTimeMillis());//更细当前时间
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
//模拟倒计时
public static void tenDown() throws InterruptedException{
int num=10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if(num<=0){
break;
}
}
}
}
3.5 线程礼让
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将线程从运行状态转为就绪状态
- 让CPU重新调度,礼让不一定成功,看CPU心情
package com.kuang.state;
//测试礼让线程
//礼让不一定成功,看CPU心情
public class TestYield {
public static void main(String[] args) {
MyYield myYield=new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始执行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程停止执行");
}
}
3.6 Join
- Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
- 可以想象成插队
package com.kuang.state;
//测试Join方法,想象为插队
public class TestJoin implements Runnable{
@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println("线程vip来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testJoin=new TestJoin();
Thread thread=new Thread(testJoin);
thread.start();
//主线程
for(int i=0;i<500;i++){
if(i==200){
thread.join();//插队
}
System.out.println("main"+i);
}
}
}
3.7 线程状态观测
-
Thread.State
线程状态。线程可以处于以下状态之一:
-
NEW
尚未启动的线程处于此状态
-
RUNNABLE
在Java虚拟机中执行的线程处于此状态
-
BLOCKED
被阻塞等待监视器锁定的线程处于此状态
-
WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
-
TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
-
TERMINATED
已退出的线程处于此状态
-
一个线程可以在给定时间点处于一个状态,这些状态是不反应任何操作系统线程状态的虚拟机状态
package com.kuang.state;
//观察测试线程的状态
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread=new Thread(()->{
for(int i=0;i<5;i++){
try{
Thread.sleep(1000);
}catch (InterruptedException e){
System.out.println("///");
}
}
});
//观察状态
Thread.State state=thread.getState();
System.out.println(state);
//观察启动后
thread.start();
state=thread.getState();
System.out.println(state);//run
while(state!=Thread.State.TERMINATED){//只要线程不终止,就一直输出状态
Thread.sleep(100);
state=thread.getState();//更新线程状态
System.out.println(state);//输出状态
}
}
}
3.8 线程优先级
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行
- 线程的优先级用数字来表示,范围是1-10
- Thread.MIN_PRIORITY=1;
- Thread.MAX_PRIORITY=10;
- Thread.NORM_PRIORITY=5;
- 使用以下方式改变或者获取优先级
- getPriority().setPriority(int ***)
优先级的设定建议在start()调度前
优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用了,这都是看CPU的调度
package com.kuang.state;
import java.sql.SQLClientInfoException;
public class TestPriority {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority=new MyPriority();
Thread t1=new Thread(myPriority);
Thread t2=new Thread(myPriority);
Thread t3=new Thread(myPriority);
Thread t4=new Thread(myPriority);
Thread t5=new Thread(myPriority);
Thread t6=new Thread(myPriority);
//先设置优先级
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
t4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
3.9 守护(daemon)线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如:后台记录操作日志,监控内存,垃圾回收等待
package com.kuang.state;
//测试守护线程
//上帝守护你
public class TestDaemon {
public static void main(String[] args) {
God god =new God();
You you=new You();
Thread thread=new Thread();
thread.setDaemon(true);//默认是false表示用户线程,正常的线程都是用户线程
thread.start();//上帝守护线程启动
new Thread(you).start();//用户线程启动
}
}
//上帝
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("上帝保佑着你");
}
}
}
//你
class You implements Runnable{
@Override
public void run() {
for(int i=0;i<36500;i++){
System.out.println("记得开心");
}
System.out.println("goodbye!world!");//hello.world
}
}
3.10 线程同步(多个线程操作同一个资源)
-
并发:同一个对象被多个线程同时操作
-
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象。这时候我们就需要线程同步,线程同步其实就是一种等待机制,多个需要同时访问,此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用
-
形成条件:队列+锁
-
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可,存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下,加锁释放锁会导致比较多的上下文切换,和调度延时,引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题
package com.kuang.syn; import java.util.ArrayList; import java.util.List; //线程不安全的集合 public class UnsafeList { public static void main(String[] args) throws InterruptedException { List<String> list=new ArrayList<String>(); for(int i=0;i<10000;i++){ new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } Thread.sleep(3000); System.out.println(list.size()); } }
package com.kuang.syn; //不安全的买票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station=new BuyTicket(); new Thread(station,"苦逼的我").start(); new Thread(station,"苦逼的我们").start(); new Thread(station,"可恶的黄牛党").start(); } } class BuyTicket implements Runnable{ //票 private int ticketNums=10; boolean flag=true;//外部停止方式 @Override public void run() { //买票 while(flag){ try{ buy(); }catch(InterruptedException e){ e.printStackTrace(); } } } private void buy() throws InterruptedException { //判断是否有票 if(ticketNums<=0){ flag=false; return; } //模拟延时 Thread.sleep(100); //买票 System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--); } }
package com.kuang.syn; //不安全的取钱 //俩个人去银行取钱,账户 public class UnsafeBank { public static void main(String[] args) { //账户 Account account=new Account(100,"结婚基金"); Drawing you=new Drawing(account,50,"ni"); Drawing girl=new Drawing(account,100,"girl"); you.start(); girl.start(); } } //账户 class Account{ int money;//余额 String name;//卡名 public Account(int money,String name){ this.money=money; this.name=name; } } //银行:模拟取款 class Drawing extends Thread{ Account account;//账户 //取了多少钱 int drawingMoney; //现在手里有多少钱 int nowMoney; public Drawing(Account account,int drawingMoney,String name){ super(name); this.account=account; this.drawingMoney=drawingMoney; } //取钱 @Override public void run() { if(account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"钱不够,取不了"); return; } try{ Thread.sleep(1000); }catch (InterruptedException e){ e.printStackTrace(); } //卡内余额 account.money=account.money-drawingMoney; //你手里的钱 nowMoney=nowMoney+drawingMoney; System.out.println(account.name+"余额为:"+account.money); System.out.println(this.getName()+"手里的钱"+nowMoney); } }