深圳市招聘网站,河北建设厅注册中心网站首页,普通个人简历电子版免费,百度站内搜索提升关键词排名项目代码 https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter17/src/com/yinhai 线程
一、线程相关概念
1.程序
是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码
2.进程 1#xff09;进程是指运行中的程序#x… 项目代码 https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter17/src/com/yinhai 线程
一、线程相关概念
1.程序
是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码
2.进程 1进程是指运行中的程序比如我们使用QQ就启动了一个进程操作系统就会为该进程分配内存空间。当我们使用迅雷又启动了一个进程操作系统将为迅雷分配新的内存空间。 2进程是程序的一次执行过程或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程
3.线程 1线程由进程创建的是进程的一个实体 2一个进程可以拥有多个线程 如下图 3并发:同一个时刻多个任务交替执行造成一种“貌似同时”的错觉简单的说单核cpu实现的多任务就是并发。 4并行:同个时刻多个任务同时执行。多核cpu可以实现并行。并发和并行可能都会同时存在
java查看cpu核数
public class CpuNum {public static void main(String[] args) {Runtime runtime Runtime.getRuntime();int cpuNum runtime.availableProcessors();System.out.println(cpuNum);}
}二、线程基本使用
1.创建线程的两个方式
在java中线程来使用有两种方法。 1继承Thread类重写run方法 2实现Runnable接口重写run方法 2.Thread类使用案例
1)请编写程序,开启一个线程该线程每隔1秒。在控制台输出喵喵 我是小猫咪.
2)对上题改进:当输出8次喵喵我是小猫咪结束该线程
3)使用JConsole监控线程执行情况并画出程序示意图 当主线程结束了可能还有其他的子线程进程可能并没有结束会跑完子线程直到子线程也挂掉了进程就挂掉了
public class Thread01 {public static void main(String[] args) {//创建一个Cat对象当做线程使用Cat cat new Cat();cat.start();//当main线程启动一个子线程 Thread-0主线程不会阻塞会继续执行//这时我们的主线程和Thread 0线程都在执行for (int i 1; i 10; i) {System.out.println(主线程在执行中 i Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
//当一个类继承了Thread类该类就可以当做线程使用
class Cat extends Thread{int time 0;Overridepublic void run() {//往往要重写run方法Thread类实现了Runnable的接口的run方法while (true){System.out.println(喵喵 time Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if(time 80){break;//当time到8次线程就会退出}}}
} 补充为什么使用cat.start再由该方法调用run呢而不是使用cat.run呢很好理解因为如果直接调用run方法主线程并不会并列执行该方法而是由主线程main去调用run方法会导致没有实现多线程也就是阻塞下面的语句这种调用不叫多线程 3.Thread类源码 可以看到 这里的start0是本地方法由JVM调用的而我们重写了该方法的内容所以准确来说是JVM实现了多线程而不是run方法实现多线程 4.Runnable接口
1. java是单继承的在某些情况下一个类可能已经继承了某个父类这时在用继承Thread类方法创建线程显然不可能了。
2. java设计者们提供了另外一个方式创建线程就是通过实现Runnable接口来创建线程实际上底层使用了设计模式[代理模式] 代码模拟
public class Thread02 {public static void main(String[] args) {Dog dog new Dog();//dog.start(); 不能直接调用start方法该接口只有run方法Thread thread new Thread(dog);//创建一个Thread对象把实现了dog对象放入Threadthread.start();// Tiger tiger new Tiger();//实现了 Runnable// ThreadProxy threadProxy new ThreadProxy(tiger);// threadProxy.start();}
}class Dog implements Runnable{//实现Runnable接口开发线程int time 0;Overridepublic void run() {while (true) {System.out.println(汪汪 time Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (time 10){break;}}}
}
3.模拟设计代理模式 可以简单理解为两个类一个ThreadProxy和Tiger都实现了Runnable类在构造器的时候传入tiger到代理对象内此时使用代理对象的start方法就可以动态绑定到我们传入的targer的run方法
public class Thread02 {public static void main(String[] args) {Tiger tiger new Tiger();//实现了 RunnableThreadProxy threadProxy new ThreadProxy(tiger);threadProxy.start();}
}
//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxyprivate Runnable target null;//属性类型是 RunnableOverridepublic void run() {if (target ! null) {target.run();//动态绑定运行类型Tiger}}public ThreadProxy(Runnable target) {this.target target;}public void start() {start0();//这个方法时真正实现多线程方法}public void start0() {run();}
}
class Animal {
}class Tiger extends Animal implements Runnable {Overridepublic void run() {System.out.println(老虎嗷嗷叫....);}
}5.线程使用的基本案例
请编写一个程序创建两个线程一个线程每隔1秒输出hello,world ,输出10次退出一个线程每隔1秒输出hi ,输出5次退出实现Runnable的方式来完成
public class Thread03 {public static void main(String[] args) {T1 t1 new T1();T2 t2 new T2();Thread thread new Thread(t1);Thread thread1 new Thread(t2);thread.start();thread1.start();}
}class T1 implements Runnable {Overridepublic void run() {int i 0;while (true) {System.out.println(hello,world i Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i 10) {break;}}}
}class T2 implements Runnable {int i 0;Overridepublic void run() {while (true) {System.out.println(hi i Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (i 5) {break;}}}
} 6.继承Thread 和 实现Runnable的区别 1) 从java的设计来看通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口 2)实现Runnable接口方式更加适合多个线程共享一个资源的情况并且避免了单继承的限制
三、模拟三个售票窗口 继承Thread类创建三个对象去调用strat方法会出现一个很严重的问题多线程冲突都跑去--ticketNum去了会出现来不及减完就会超卖的现象
public class SellTicket {public static void main(String[] args) {SellTicket01 sellTicket01 new SellTicket01();SellTicket01 sellTicket02 new SellTicket01();SellTicket01 sellTicket03 new SellTicket01();sellTicket01.start();sellTicket02.start();sellTicket03.start();}
}
class SellTicket01 extends Thread{private static int ticketNum 100;Overridepublic void run() {while (true){if(ticketNum 0){System.out.println(售票结束);break;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(该窗口 Thread.currentThread().getName() 卖出了一张票剩余 --ticketNum 张);}}
} 使用Runnable类也会出现上面的情况实际上两个实现的方式本质都一样
public class SellTicket {public static void main(String[] args) {//使用实现Runnable接口方式SellTicket02 sellTicket002 new SellTicket02();new Thread(sellTicket002).start();new Thread(sellTicket002).start();new Thread(sellTicket002).start();}
}class SellTicket02 implements Runnable{private int ticketNum 100;Overridepublic void run() {while (true){if(ticketNum 0){System.out.println(售票结束);break;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(该窗口 Thread.currentThread().getName() 卖出了一张票剩余 --ticketNum 张);}}
} 留下一个问题怎么去解决超卖现象呢看线程同步机制的具体方法内的改善
四、线程终止通知方式 1.当线程完成任务后会自动退出。 2.还可以通过使用变量来控制run方法退出的方式停止线程即通知方式。
public class ThreadExit_ {public static void main(String[] args) {T t new T();t.start();System.out.println(主线程休眠5秒);//如果希望主线程去控制t1的线程终止就需要修改loop变量//让t1退出run方法从而终止t1线程 - 通知方式try {//让主线程休眠10秒再退出Thread线程Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}t.setLoop(false);}
}
class T extends Thread{private int count 0;//设置一个控制变量private boolean loop true;Overridepublic void run() {while (loop) {try {Thread.sleep(50);// 让当前线程休眠50ms} catch (InterruptedException e) {e.printStackTrace();}System.out.println(T 运行中.... (count));}}public void setLoop(boolean loop) {this.loop loop;}
}五、线程的常用方法
第一组常用方法
1. setName //设置线程名称使之与参数name 相同
2. getName //返回该线程的名称
3. start //使该线程开始执行; Java 虚拟机底层调用该线程的startO方法
4. run //调用线程对象 run方法;
5. setPriority //更改线程的优先级
6. getPriority /获取线程的优先级
7. sleep//在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
8. interrupt //中断线程
1.方法注意事项
1. start底层会创建新的线程调用run, run 就是一个简单的方法调用 不会启动新线程
2.线程优先级的范围为1-10 /** * The minimum priority that a thread can have. */
public final static int MIN_PRIORITY 1; /** * The default priority that is assigned to a thread. */
public final static int NORM_PRIORITY 5; /** * The maximum priority that a thread can have. */
public final static int MAX_PRIORITY 10;3. interrupt中断线程但并没有真正的结束线程。所以一般用于中断正在休眠线程 Thread 线程在执行任务时会周期性地检查中断状态。当 Thread.interrupt() 被调用时线程会在适当的时机检测到中断状态并终止执行。 Thread.currentThread().isInterrupted();获取当前是否Interrupted 需要注意的是interrupt() 方法并不会强制终止线程而是提供了一种协作的机制线程可以根据中断状态自行决定是否终止。 如果线程不检查中断状态或者没有处理 InterruptedException 异常它可能会继续执行。 所以在下列代码中我们catch了InterruptedException 异常但并没有退出线程的操作导致程序继续执行也就是中断了线程的休眠状态 4. sleep线程的静态方法使当前线程休眠
public class ThreadMethod01 {public static void main(String[] args) throws InterruptedException {//测试相关的方法T t new T();t.setName(yinhai);t.setPriority(Thread.MIN_PRIORITY);//1t.start();//启动子线程//主线程打印5 hi ,然后就中断 子线程的休眠for(int i 1; i 5; i) {Thread.sleep(1000);System.out.println(hi i);}System.out.println(t.getName() 线程的优先级 t.getPriority());//1t.interrupt();//当执行到这里就会中断 t线程的休眠.}
}class T extends Thread { //自定义的线程类Overridepublic void run() {while (true) {for (int i 0; i 100; i) {//Thread.currentThread().getName() 获取当前线程的名称System.out.println(Thread.currentThread().getName() 吃包子~~~~ i);}try {System.out.println(Thread.currentThread().getName() 休眠中~~~);Thread.sleep(20000);//20秒} catch (InterruptedException e) {//当该线程执行到一个interrupt 方法时就会catch 一个 异常, 可以加入自己的业务代码//InterruptedException 是捕获到一个中断异常.System.out.println(Thread.currentThread().getName() 被 interrupt了);}}}
}第二组yield、join
1. yield:线程的礼让。让出cpu,让其他线程执行但礼让的时间不确定所以也不一定礼让成功。本意上也是让出cpu给其他线程插队 2. join:线程的插队。插队的线程一旦插队成功一定会成功则肯定先执行完插入的线程所有的任务。 案例:创建一个子线程,每隔1s输出hello输出10 次主线程每隔1秒输出hi输出10次.要求:两个线程同时执行当主线程输出5次后就让子线程运行完毕主线程再继续。
public class ThreadMethod02 {public static void main(String[] args) throws InterruptedException {T2 t2 new T2();t2.start();for(int i 1; i 10; i) {Thread.sleep(1000);System.out.println(主线程(小弟) 吃了 i 包子);if(i 5) {System.out.println(主线程(小弟) 让 子线程(老大) 先吃);//join, 线程插队t2.join();// 这里相当于让t2 线程先执行完毕// Thread.yield();//礼让不一定成功..System.out.println(线程(老大) 吃完了 主线程(小弟) 接着吃..);}}}
}class T2 extends Thread {Overridepublic void run() {for (int i 1; i 10; i) {try {Thread.sleep(1000);//休眠1秒} catch (InterruptedException e) {e.printStackTrace();}System.out.println(子线程(老大) 吃了 i 包子);}}
}如果是礼让yield不一定成功 课堂练习 public class ThreadMethodExercise {public static void main(String[] args) throws InterruptedException {Thread t3 new Thread(new T3());//创建子线程for (int i 1; i 10; i) {System.out.println(hi i);if(i 5) {//说明主线程输出了5次 hit3.start();//启动子线程 输出 hello...t3.join();//立即将t3子线程插入到main线程让t3先执行}Thread.sleep(1000);//输出一次 hi, 让main线程也休眠1s}System.out.println(主线程结束);}
}class T3 implements Runnable {private int count 0;Overridepublic void run() {while (true) {System.out.println(hello (count));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (count 10) {System.out.println(子线程结束);break;}}}
}第三组用户线程和守护线程
1.用户线程也叫工作线程以当线程的任务执行完成或通知方式来结束
2.守护线程一般是为工作线程服务的当所有的用户线程结束守护线程自动结束
3.常见的守护线程:垃圾回收机制
public class ThreadMethod03 {public static void main(String[] args) throws InterruptedException {MyDaemonThread myDaemonThread new MyDaemonThread();//如果我们希望当main线程结束后子线程自动结束,只需将子线程设为守护线程即可myDaemonThread.setDaemon(true);//该线程设置为守护线程myDaemonThread.start();for( int i 1; i 10; i) {//main线程System.out.println(宝强在辛苦的工作...);Thread.sleep(1000);}}
}class MyDaemonThread extends Thread {public void run() {for (; ; ) {//无限循环try {Thread.sleep(1000);//休眠1000毫秒} catch (InterruptedException e) {e.printStackTrace();}System.out.println(马蓉和宋喆快乐聊天哈哈哈~~~);}}
}六、线程的生命周期 官方API文档指出有6种状态 七个则是Runnable里的可执行的里的细分状态Ready和Running状态取决于调度器选中执行不是start()后就立马执行要取决底层调度器是否执行该线程
线程状态图 public class ThreadState_ {public static void main(String[] args) throws InterruptedException {T t new T();System.out.println(t.getName() 状态 t.getState());t.start();while (Thread.State.TERMINATED ! t.getState()) {System.out.println(t.getName() 状态 t.getState());Thread.sleep(500);}System.out.println(t.getName() 状态 t.getState());}
}
class T extends Thread {Overridepublic void run() {while (true) {for (int i 0; i 10; i) {System.out.println(hi i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}break;}}
}
线程同步机制
一、线程同步机制
1.在多线程编程一些敏感数据不允许被多个线程同时访问此时就使用同步访问技术保证数据在任何时刻最多有一个线程访问以保证数据的完整性。 2.也可以这里理解线程同步即当有一个线程在对内存进行操作时其他线程都不可以对这个内存地址进行操作直到该线程完成操作其他线程才能对该内存地址进行操作。
二、线程同步具体方法
1.Synchronized 1)同步代码块synchronized (对象) { //得到对象的锁才能操作同步代码 //需要被同步代码; } 2) synchronized还可以放在方法声明中 表示整个方法为同步方法 public synchronized void m (String name){ //需要被同步的代码 } 3)如何理解:就好像某小伙伴上厕所前先把门关上(上锁)完事后再出来(解锁)那么其它小伙伴就可在使用厕所了 4)使用synchronized解决售票问题
public class SellTicket {public static void main(String[] args) {SellTicket02 sellTicket002 new SellTicket02();new Thread(sellTicket002).start();new Thread(sellTicket002).start();new Thread(sellTicket002).start();}
}
//实现接口方法使用synchronized实现线程同步
class SellTicket02 implements Runnable{private int ticketNum 100;public synchronized boolean sellTick(){//同步方法同一时间只有一个线程来执行sellTick方法if(ticketNum 0){System.out.println(售票结束);return false;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(该窗口 Thread.currentThread().getName() 卖出了一张票剩余 --ticketNum 张);return true;}Overridepublic void run() {while (sellTick()){}}
} 注意 这时候运行状态不一定都会平均分配到到每一个线程上因为是不公平锁三个都在抢这个锁谁抢到就是谁的分析同步原理看下
三、分析同步原理
三个进程去抢这把锁当有一个抢到之后进入run方法输出打印车票然后归还锁到对象上随后加入Blocked进程状态三个一起抢这把锁一直重复执行到结束没抢到的进入Blocked状态抢到的进入Runnable状态执行后退出 四、互斥锁
1Java在Java语言中引入了对象互斥锁的概念来保证共享数据操作的完整性。
2每个对象都对应于一个可称为互斥锁”的标记这个标记用来保证在任一一时刻只能有一个线程访问该对象。
3关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时表明该对象在任一时刻只能由一个线程访问
4同步的局限性:导致程序的执行效率要降低
5同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
6同步方法(静态的)的锁为当前类本身。
public class SellTicket {public static void main(String[] args) {SellTicket02 sellTicket002 new SellTicket02();Thread thread1 new Thread(sellTicket002);Thread thread2 new Thread(sellTicket002);Thread thread3 new Thread(sellTicket002);thread1.start();thread2.start();thread3.start();}
}//实现接口方法使用synchronized实现线程同步
class SellTicket02 implements Runnable {private int ticketNum 10;Object object new Object();//6同步方法(静态的)的锁为当前类本身。//1. public synchronized static void m1() {} 锁是加在 SellTicket03.classpublic synchronized static void m1() {}//2. 如果在静态方法中要实现一个同步代码块需要像以下方式处理public static void m2() {synchronized (SellTicket02.class) {System.out.println(m2);}}//5同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)//同步方法同一时间只有一个线程来执行sellTick方法public /*synchronized*/ boolean sellTick() {//2.这时锁在this对象也可以在代码块上写synchronize同步代码块synchronized (/*this*/ object) {if (ticketNum 0) {System.out.println(售票结束);return false;}System.out.println(该窗口 Thread.currentThread().getName() 卖出了一张票剩余 --ticketNum 张);try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}return true;}}Overridepublic void run() {while (sellTick()) {}}public int getTicketNum() {return ticketNum;}
}
1.注意事项
1.同步方法如果没有使用static修饰:默认锁对象为this
2.如果方法使用static修饰默认锁对象:当前类.class
3.实现的落地步骤: 需要先分析上锁的代码 选择同步代码块或同步方法如果可以最好用代码块作用域小 要求多个线程的锁对象为同一个即可!
//使用Thread方式
// new SellTicket01().start();
// new SellTicket01().start();
class SellTicket01 extends Thread {private static int ticketNum 100;//让多个线程共享 ticketNum//这样锁不住无法保证锁的对象是同一个public void m1() {synchronized (this) {System.out.println(hello);}}
}
五、线程的死锁
1.基本介绍 多个线程都占用了对方的锁资源但不肯相让导致了死锁在编程是一定要避免死锁的发生.
2.模拟线程死锁
public class DeadLock_ {public static void main(String[] args) {//模拟死锁现象DeadLockDemo A new DeadLockDemo(true);A.setName(A线程);DeadLockDemo B new DeadLockDemo(false);B.setName(B线程);A.start();B.start();}
}//线程
class DeadLockDemo extends Thread {static Object o1 new Object();// 保证多线程共享一个对象,这里使用staticstatic Object o2 new Object();boolean flag;public DeadLockDemo(boolean flag) {//构造器this.flag flag;}Overridepublic void run() {//下面业务逻辑的分析//1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁//2. 如果线程A 得不到 o2 对象锁就会Blocked//3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁//4. 如果线程B 得不到 o1 对象锁就会Blockedif (flag) {synchronized (o1) {//对象互斥锁, 下面就是同步代码System.out.println(Thread.currentThread().getName() 进入1);synchronized (o2) { // 这里获得li对象的监视权System.out.println(Thread.currentThread().getName() 进入2);}}} else {synchronized (o2) {System.out.println(Thread.currentThread().getName() 进入3);synchronized (o1) { // 这里获得li对象的监视权System.out.println(Thread.currentThread().getName() 进入4);}}}}
} 线程不是并行的 有可能出现A线程拿完锁走完了才到B线程也很好的反应了锁的单独拿的性质 六、释放锁
1.释放锁的条件
1)当前线程的同步方法、同步代码块执行结束 案例:上厕所 完事出来
2)当前线程在同步代码块、同步方法中遇到break、 return。 案例:没有正常的完事经理叫他修改bug,不得已出来
3)当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束 案例:没有正常的完事发现忘带纸不得已出来
4)当前线程在同步代码块、同步方法中执行了线程对象的wait()方法当前线程暂停并释放锁。 案例:没有正常完事觉得需要酝酿下所以出来等会再进去
2.下面的操作不会释放锁
1)线程执行同步代码块或同步方法时程序调用Thread.sleep()、 Thread.yield()方法暂停当前线程的执行不会释放锁 案例:上厕所 太困了在坑位上眯了一会
2)线程执行同步代码块时其他线程调用了该线程的suspend()方法将该线程挂起该线程不会释放锁。 提示:应尽量避免使用suspend()和resume()来控制线程这两个方法不再推荐使用 本章作业
1.通知方式完成线程终止
(1)在main方法中启动两个线程
(2)第1个线程循环随机打印100以内的整数
(3)直到第2个线程从键盘读取了Q 命令。 为什么不用Listener因为KeyListener 主要是用于监听和处理用户在图形用户界面 (GUI) 中的键盘输入事件。在 GUI 应用程序中事件驱动编程模型允许程序在用户与应用程序界面交互时响应输入事件。 在控制台应用程序中使用 KeyListener 不是常见的做法因为控制台通常不提供直接的键盘事件处理功能也没有 GUI 元素来接收键盘输入事件。控制台应用程序通常是基于命令行的它们等待用户输入然后以文本形式处理用户的命令或数据。 public class Homework01 {public static void main(String[] args) {PrintNum printNum new PrintNum();new Thread(printNum).start();new Thread(new MyListener(printNum)).start();}
}class PrintNum implements Runnable{private boolean loop true;//通知方式需要定义一个变量接受退出指令public void setLoop(boolean loop) {this.loop loop;}Overridepublic void run() {while (loop) {synchronized (this) {try {System.out.println((int)(Math.random()*100));//随机数Thread.sleep(2000);} catch (Exception e) {e.printStackTrace();}}}System.out.println(PrintNum进程退出);}
}
class MyListener implements Runnable{private PrintNum printNum;//需要定义一个printNum面向对象保证我们改的和运行的是同一个对象Scanner myScanner new Scanner(System.in);public MyListener(PrintNum printNum) {this.printNum printNum;//构造器传入Print的对象}Overridepublic void run() {synchronized (this){while (true) {System.out.println(Q退出等待用户输入...);char a myScanner.next().charAt(0);if (a Q) {printNum.setLoop(false);System.out.println(Listener进程退出);break;}else{System.out.println(退出失败 输入Q退出);}}}}
} 2.线程同步
(1)有2个用户分别从同一个卡上取钱(总额: 10000)
(2)每次都取1000,当余额不足时就不能取款了
(3)不能出现超取现象 - 线程同步问题 public class Homework02 {public static void main(String[] args){Bank bank new Bank();Thread thread1 new Thread(bank);Thread thread2 new Thread(bank);thread1.start();thread2.start();}
}class Bank implements Runnable {private int bakAccount 10000;public int getBakAccount() {return bakAccount;}Overridepublic void run() {//1. 这里使用 synchronized 实现了线程同步//2. 当多个线程执行到这里时就会去争夺 this对象锁//3. 哪个线程争夺到(获取)this对象锁就执行 synchronized 代码块, 执行完后会释放this对象锁//4. 争夺不到this对象锁就blocked 准备继续争夺//5. this对象锁是非公平锁.synchronized (this) {while (true) {if (bakAccount 0) {System.out.println(取完);break;}System.out.println(Thread.currentThread().getName() 取出1000余额剩余 (bakAccount - 1000));try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}}}}
} 如果想要让两个线程近似交替运行取完--bankAccount后休眠不要使用synchronized包起来即可。锁如果包括休眠的话会等另一个线程休眠完后一起抢。不包起来就会一个线程开始休眠另一个线程直接抢锁 总结一下执行过快两个thread基本上是同时启动的所以会出现两个争抢的情况如果想两个线程不抢在主线程内加一个sleep即可 thread1.start(); Thread.sleep(200); thread2.start();
