线程
1.线程的介绍
程序：是为了完成特定任务、用某种语言编写一组指令的集合。(代码)
进程：进程指运行中的程序。启动进程，操作系统会分配内存空间。进程是程序的一次执行过程，或是一个正在运行的进程。是动态过程：有它自己的产生、存在和消亡的过程。
线程：线程由进程创建，是进程的一个实体。一个进程可以拥有多个线程。
单线程：同一个时期，只允许执行一个线程。
多线程：同一个时刻，可以执行多个线程。
package com.ghfedu; /** * @author admin * @version */ public class CpuNum { public static void main(String[] args) { Runtime runtime = Runtime.getRuntime();//获取当前电脑的cpu数量/核心数 int cpuNums = runtime.availableProcessors(); System.out.println("当前有cpu个数=" +cpuNums); } }并发：同一个时刻，多个任务交替执行。(单核cpu实现的多任务就是并发)
并行：同一个时刻，多个时刻同时执行。(多核cpu可以实现并行)
2.线程使用
继承Thread类，重写run方法。
package com.ghfedu; /** * @author admin * 演示通过继承Thread类创建线程 */ public class thread01 { public static void main(String[] args) throws InterruptedException { //创建Cat对象，可以当做线程使用 Cat cat = new Cat(); /* 1. public synchronized void start() { start0(); } 2. //start0();是本地方法，是JVM调用底层是C/C++实现 //真正实现多线程的效果是start0();而不是run private native void start0(); */ cat.start();//启动线程->最终执行cat的run方法 //cat.run();//run方法就是一个普通的方法，没有真正启动线程。从而必须执行完run方法后，才执行之后的。 //说明：当main线程启动一个子线程Thread-0，主线程不会阻塞，会继续执行 //这时主线程和子线程是交替执行 //使用JConsole可以监控线程 System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字main for (int i = 0; i <10 ; i++) { System.out.println("主线程i=" + i); //让主线程休眠 Thread.sleep(1000); } } } //当一个类继承了Thread类，该类就是一个线程 //重写run方法，写上自己的业务代码 //run Thread类实现了Runnable接口的Run方法 /* @Override public void run() { if (target != null) { target.run(); } } */ class Cat extends Thread{ int times = 0; @Override public void run() {//重写run方法，写上自己的业务逻辑 while(true){ //该线程每个一秒，在控制台输出"喵喵，我是小喵咪" System.out.println("喵喵，我是小喵咪" + (++times) + "线程名=" + Thread.currentThread().getName()); //让该线程休眠1秒 ctrl+alt+T try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (times == 8){ break;//当times到8，退出while，这时线程也就退出 } } } }实现Runnable接口，重写run()方法。
Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时用继承Thread类方法来创建线程，所以通过Runnable接口来创建线程。
package com.ghfedu; /** * @author admin * 通过实现接口Runnable来开发线程 */ public class Thread02 { public static void main(String[] args) { Dog dog = new Dog(); //dog.start();这里不能调用start //创建一个Thread对象，把dog对象(实现Runnable)放入Thread Thread thread = new Thread(dog);//这里底层使用了设计模式：代理模式(静态代理) thread.start(); // Tiger tiger = new Tiger();//实现了Runnable接口 // ThreadProxy threadProxy = new ThreadProxy(tiger); // threadProxy.start(); } } class Animal {} class Tiger extends Animal implements Runnable { @Override public void run() { System.out.println("老虎嗷嗷叫.."); } } //开发线程机制 //线程代理类，模拟一个极简的Thread类 class ThreadProxy implements Runnable {//把Proxy类当作ThreadProxy private Runnable target = null;//属性，类型为Runnable @Override public void run() { if(target != null){ target.run();//动态绑定(运行类型Tiger) } } public ThreadProxy(Runnable target) { this.target = target; } public void start() { start0();//这个方法是真正实现多线程的方法 } public void start0() { run(); } } class Dog implements Runnable{//使用实现Runnable接口，开发线程 int count = 0; @Override public void run() {//普通方法 while(true){ System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName()); //休眠一秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if(count == 10){ break; } } } }多线程执行
package com.ghfedu; /** * @author admin * main线程启动两个子线程 */ public class Thread03 { public static void main(String[] args) { T1 t1 = new T1(); T2 t2 = new T2(); Thread thread1 = new Thread(t1); Thread thread2 = new Thread(t2); thread1.start();//启动第一个线程 thread2.start();//启动第二个线程 } } class T1 implements Runnable { int count = 0; @Override public void run() { while (true) { //每个一秒输出"Hello,world"输出10次 System.out.println("Hello,world" + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 10) { break; } } } } class T2 implements Runnable { int count = 0; @Override public void run() { while (true) { //每个一秒输出"hi"输出5次 System.out.println("hi " + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 5) { break; } } } }继承Thread和实现Runnable的区别
通过继承Thread或者实现Runnable接口来创建线程本质上没有区别。jdk文档中Thread类>本身就实现了Runnable接口。
实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制。
售票系统的问题
package com.ghfedu.ticket; /** * @author admin * 使用多线程，模拟三个窗口同时售票100张 */ 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();//启动售票线程 System.out.println("========使用实现接口的方式来售票========"); SellTicket02 sellTicket02 = new SellTicket02(); new Thread(sellTicket02).start();//第1个线程-窗口 new Thread(sellTicket02).start();//第2个线程-窗口 new Thread(sellTicket02).start();//第3个线程-窗口 } } //使用Thread方式 class SellTicket01 extends Thread { private static int ticketNum = 100;//让多个线程共享ticket @Override public void run() { while(true) { if (ticketNum <= 0) { System.out.println("售票结束..."); break; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } } } //实现接口的方式 class SellTicket02 implements Runnable { private int ticketNum = 100;//让多个线程共享ticket @Override public void run() { while(true) { if (ticketNum <= 0) { System.out.println("售票结束..."); break; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } } }线程终止：当线程完成任务后，会自动退出。还可以通过使用变量来控run方法退出的方式停止线程(通知方式)。
package com.ghfedu.exit_; public class ThreadExit_ { public static void main(String[] args) throws InterruptedException { T t1 = new T(); t1.start(); //如果希望main线程去控制t1线程的终止，必须可以修改loop //让t1退run方法，从而终止t1线程->通知方式 //让主线程休眠10秒，在通知t1线程退出 System.out.println("main线程休眠10s.."); Thread.sleep(10*1000); t1.setLoop(false); } } class T extends Thread { int count = 0; //设置一个控制变量 private boolean loop = true; @Override public void run() { while (loop) { try { Thread.sleep(50);//休眠50毫秒 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("T运行中..." + (++count)); } } public void setLoop(boolean loop) { this.loop = loop; } }
3.线程方法
常用方法
- setName 设置线程名称，使之与参数名name相同
- getName 返回该线程的名称
- start 使该线程开始执行；Java虚拟机底层调用该进程的start0方法
- run 调用线程对象run方法
- setPriority 更改线程的优先级
- getPriority 获取线程的优先级
- sleep 在指定毫秒数内让当前正在执行的线程休息(暂停执行)
- interrupt 中断线程
- start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
- 线程优先级范围
- interrupt中断线程，但并没有真正结束进程。所以一般用于中断正在休眠的线程
- sleep：线程的静态方法，使当前线程休眠
package com.ghfedu.method; /** * @author admin */ public class ThreadMethod01 { public static void main(String[] args) throws InterruptedException { //测试相关的方法 T t = new T(); t.setName("ghf"); t.setPriority(Thread.MIN_PRIORITY); t.start();//启动子线程 //主线程打印5个hi，中断子线程的休眠 for (int i = 0; i < 5; i++) { Thread.sleep(1000); System.out.println("hi" + i); } System.out.println(t.getName() + "线程的优先级=" + t.getPriority());//1 t.interrupt();//当执行到这里时，会中断t线程的休眠 //System.out.println(t.getName()); } } class T extends Thread {//自定义一个线程类 @Override public 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); } catch (InterruptedException e) {//当该线程执行到一个interrupt方法时，就会catch一个异常， //可以加入自己的业务代码 //InterruptedException捕获一个中断异常 System.out.println(Thread.currentThread().getName() + "被interrupt了"); } } } }
- yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以不一定礼让成功。
- join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务。
package com.ghfedu.method; /** * @author admin */ public class ThreadMethod02 { public static void main(String[] args) throws InterruptedException { T2 t2 = new T2(); t2.start(); for (int i = 1; i <= 20; i++) { Thread.sleep(50); System.out.println("主线程(小弟)吃了" + i + "包子"); if(i == 5) { System.out.println("主线程(小弟)让子线程(老大)先吃"); //join线程插队 //t2.join();//这里相当让t2线程先执行完毕 Thread.yield();//礼让不一定成功 System.out.println("子线程(老大)吃完了，主线程(小弟)接着吃.."); } } } } class T2 extends Thread { @Override public void run() { for (int i = 1; i <= 20; i++) { try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("子线程(老大)吃了" + i + "包子"); } } }Exercise
package com.ghfedu.method; /** * @author admin */ public class ThreadMethodExercise { public static void main(String[] args) throws InterruptedException { // T3 t3 = new T3(); // Thread thread = new Thread(t3); Thread thread = new Thread(new T3());//创建子线程 for (int i = 1; i <= 10; i++) { Thread.sleep(1000); System.out.println("hi" + i); if (i == 5) {//说明主线程输出了5次hi thread.start();//启动子线程输出hello.. thread.join();//将子线程插入到主线程，让子线程先执行 } } System.out.println("主线程结束.."); } } class T3 implements Runnable { @Override public void run() { for (int i = 1; i <= 10; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("hello" + i); } System.out.println("子线程结束.."); } }
- 用户线程：也叫工作线程。(线程的任务执行完成或通知方式结束)
- 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束。
- 常见的守护线程：垃圾回收机制。
package com.ghfedu.method; public class ThreadMethod03 { public static void main(String[] args) throws InterruptedException { MyDaemonThread myDaemonThread = new MyDaemonThread(); //主线程结束后，子线程自动结束 myDaemonThread.setDaemon(true);//将子线程设置为守护线程 myDaemonThread.start(); for (int i = 1; i <= 10; i++) { System.out.println("宝强在辛苦的工作..."); Thread.sleep(1000); } } } class MyDaemonThread extends Thread { @Override public void run() { for (; ; ) {//无限循环 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("马蓉和宋喆快乐聊天，哈哈哈..."); } } }
4.线程生命周期
JDK中用Thread.State枚举表示了线程的几种状态。
public static enum Thread.State extends Enum<Thread.State>线程状态，线程可以处于以下状态之一：
- NEW 尚未启动的线程处于此状态。
- RUNNABLE 在Java虚拟机中执行的线程处于此状态。
- BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
- WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING 正在等待另一个线程执行动作到达指定等待时间的线程处于此状态。
- TERMINATED 已退出的线程处于此状态。
package com.ghfedu.state_; 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 { @Override public 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; } } }
5.Synchronized
线程的同步机制
- 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
- 线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
Synchronized具体方法：
- 同步代码块
synchronized(对象) {//得到对象的锁，才能操作同步代码 //需要被同步代码 }
- synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m (String name){ //需要被同步的代码 }
- 使用 synchronized 解决售票问题
package com.ghfedu.syn.ticket; /** * @author admin * 使用多线程，模拟三个窗口同时售票100张 */ 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();//启动售票线程 // System.out.println("========使用实现接口的方式来售票========"); // SellTicket02 sellTicket02 = new SellTicket02(); // // new Thread(sellTicket02).start();//第1个线程-窗口 // new Thread(sellTicket02).start();//第2个线程-窗口 // new Thread(sellTicket02).start();//第3个线程-窗口 SellTicket03 sellTicket03 = new SellTicket03(); new Thread(sellTicket03).start();//第1个线程-窗口 new Thread(sellTicket03).start();//第2个线程-窗口 new Thread(sellTicket03).start();//第3个线程-窗口 } } //实现接口的方式,使用synchronized实现线程同步 class SellTicket03 implements Runnable { private int ticketNum = 100;//让多个线程共享ticket private boolean loop = true;//控制run方法变量 public synchronized void sell(){//同步方法，在同一时刻，只能有一个线程来执行sell方法 if (ticketNum <= 0) { System.out.println("售票结束..."); loop = false; return; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } @Override public void run() { while(loop) { sell();//sell方法是一种同步方法 } } } //使用Thread方式 class SellTicket01 extends Thread { private static int ticketNum = 100;//让多个线程共享ticket @Override public void run() { while(true) { if (ticketNum <= 0) { System.out.println("售票结束..."); break; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } } } //实现接口的方式 class SellTicket02 implements Runnable { private int ticketNum = 100;//让多个线程共享ticket @Override public void run() { while(true) { if (ticketNum <= 0) { System.out.println("售票结束..."); break; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } } }
6.互斥锁
- Java在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
- 每个对象都对应一个可称为"互斥锁"的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象。
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰符时，表明该对象在任一时刻只能有一个线程访问。
- 同步的局限性：导致程序的执行效率要降低。
- 同步方法(非静态的)的锁可以时this，也可以是其他对象(同个对象)。
- 同步方法(静态的)的锁为当前类本身。
package com.ghfedu.syn.ticket; /** * @author admin * 使用多线程，模拟三个窗口同时售票100张 */ 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();//启动售票线程 // System.out.println("========使用实现接口的方式来售票========"); // SellTicket02 sellTicket02 = new SellTicket02(); // // new Thread(sellTicket02).start();//第1个线程-窗口 // new Thread(sellTicket02).start();//第2个线程-窗口 // new Thread(sellTicket02).start();//第3个线程-窗口 SellTicket03 sellTicket03 = new SellTicket03(); new Thread(sellTicket03).start();//第1个线程-窗口 new Thread(sellTicket03).start();//第2个线程-窗口 new Thread(sellTicket03).start();//第3个线程-窗口 } } //实现接口的方式,使用synchronized实现线程同步 class SellTicket03 implements Runnable { private int ticketNum = 100;//让多个线程共享ticket private boolean loop = true;//控制run方法变量 Object object = new Object(); //同步方法(静态的)的锁为当前类本身。 //public synchronized static void m1(){}锁是加在SellTicket03.class //在静态方法中实现一个同步代码块 /*synchronized (SellTicket03.class) { System.out.println("m2"); }*/ public synchronized static void m1(){} public static void m2(){ synchronized (SellTicket03.class) { System.out.println("m2"); } } //public synchronized void sell(){} 是一个同步方法 //这是锁在this对象 //在代码块上写synchronized，同步代码块，互斥锁还是在this对象 public /*synchronized*/ void sell(){//同步方法，在同一时刻，只能有一个线程来执行sell方法 synchronized (/*this*/object) { if (ticketNum <= 0) { System.out.println("售票结束..."); loop = false; return; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } } @Override public void run() { while(loop) { sell();//sell方法是一种同步方法 } } } //使用Thread方式 class SellTicket01 extends Thread { private static int ticketNum = 100;//让多个线程共享ticket @Override public void run() { while(true) { if (ticketNum <= 0) { System.out.println("售票结束..."); break; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } } } //实现接口的方式 class SellTicket02 implements Runnable { private int ticketNum = 100;//让多个线程共享ticket @Override public void run() { while(true) { if (ticketNum <= 0) { System.out.println("售票结束..."); break; } //休眠50毫秒 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票" + "剩余票数" + (--ticketNum)); } } }
- 同步方法如果没有使用static修饰：默认锁对象为this
- 如果方法使用Static修饰，默认锁对象：当前类.class
- 实现：首先分析上锁的代码，选择同步代码块或同步方法。(要求多个线程的锁对象为同一个即可)
7.死锁
- 多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程中一定要避免死锁的发生。
package com.ghfedu.syn.ticket; import com.sun.org.apache.xpath.internal.objects.XObject; /** * @author admin * 模拟线程死锁 */ 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();//保证多线程，共享一个对象，这里使用static static Object o2 = new Object(); boolean flag; public DeadLockDemo(boolean flag){//构造器 this.flag = flag; } @Override public void run() { //下面业务逻辑的分析 /*如果flag为T，线程A就会先得到/持有o1对象锁，然后尝试去获取o2对象锁 * 如果线程A得不到o2对象锁，就会Blocked * 如果flag为F，线程B就会先得到/持有o2对象锁，然后尝试去获取o1对象锁 * 如果线程B得不到o1对象锁，就会*/ if (flag){ synchronized (o1) {//对象互斥锁 System.out.println(Thread.currentThread().getName() + " 进入1"); synchronized (o2) { 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"); } } } } }释放锁
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return。
- 当前线程在同步代码块、同步方法中出现了为处理的Error或Exception，导致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
- 尽量避免使用suspend()、resume()来控制线程，方法不推荐使用。
package com.ghfedu.work; import java.util.Scanner; public class work01 { public static void main(String[] args) { A a = new A(); B b = new B(a); a.start(); b.start(); } } //创建A线程 class A extends Thread{ private boolean loop = true; @Override public void run() { //输出1-100数字 while (loop){ System.out.println((int) (Math.random() * 100 + 1)); //休眠 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } public void setLoop(boolean loop) {//可以修改loop变量 this.loop = loop; } } //直到第二个线程从键盘读取了"Q"命令 class B extends Thread { private A a; private Scanner scanner = new Scanner(System.in); public B(A a) {//构造器中，直接传入 this.a = a; } @Override public void run() { while (true) { //接受用户输入 System.out.println("请输入你的指令'Q'表示退出"); char key = scanner.next().toUpperCase().charAt(0); if (key == 'Q'){ //以通知的方式结束a线程 a.setLoop(false); System.out.println("b线程退出"); break; } } System.out.println("a线程退出.."); } }package com.ghfedu.work; import java.util.concurrent.ThreadLocalRandom; /** * @author admin */ public class work02 { public static void main(String[] args) { T t = new T(); Thread thread1 = new Thread(t); thread1.setName("t1"); Thread thread2 = new Thread(t); thread2.setName("t2"); thread1.start(); thread2.start(); } } //编程取款线程 //涉及到多个线程共享资源，使用实现接口Runnable方式 class T implements Runnable { private int money = 10000; @Override public void run() { while(true){ //使用了synchronized实现了线程同步 //当多个线程执行到这，就会去争夺this对象锁 t //哪个线程争夺(获取)到this对象就执行synchronized代码块，执行完后，会释放this对象锁 //争夺不到this对象锁(非公平锁)，就blocked，准备继续争夺 synchronized (this) { //判断余额是否足够 if (money < 1000) {//每次取1000块 System.out.println("余额不足"); break; } money -= 1000; System.out.println(Thread.currentThread().getName() + "取出了1000 当前余额=" + money); } //休眠1s try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
