多线程售票问题
package ticket; public class SellTicket { public static void main(String[] args) { SellTicket01 ticket01 = new SellTicket01(); SellTicket01 ticket02 = new SellTicket01(); SellTicket01 ticket03 = new SellTicket01(); ticket01.start(); ticket02.start(); ticket03.start(); } } class SellTicket01 extends Thread{ static int ticketNum = 100; @Override public 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 的时候， 他们三者同时进行售卖 ，导致三个线程同时进行，然后就会超卖两张
解决方案：
- 通知线程退出
- 线程中断
通知线程退出
public class Thread01 { public static void main(String[] args) throws Exception{ int count = 0; //1. 创建一个cat对象，可以当作一个线程来使用 Cat cat = new Cat(); cat.start(); //休息10 秒 让其退出 Thread.sleep(10000); cat.loop = false; //当main方法执行一个线程 之后 ，主线程不会阻塞 ，会继续执行 } } class Cat extends Thread{ int times = 0; boolean loop = true; //todo 通过重写run方法，来实现自己的业务逻辑 @Override public void run() { // 实现了Runnable接口的run方法 while(loop){ System.out.println("执行一次" + "次数" +(++times)+ "线程名:" + Thread.currentThread().getName()); //让其休眠一秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
在main方法中控制变量，让另一个线程退出
运行结果：
线程中断
就是让正在休眠的线程停止休眠， 继续工作的意思
package Thread; public class Thread01 { public static void main(String[] args) throws Exception{ int count = 0; //1. 创建一个cat对象，可以当作一个线程来使用 Cat cat = new Cat(); cat.start(); //休息10 秒 让其退出 Thread.sleep(1000); // cat.loop = false; System.out.println("线程停止休眠 ，继续执行" ); cat.interrupt(); //中断子线程的休眠 //Thread.sleep(5000); //当main方法执行一个线程 之后 ，主线程不会阻塞 ，会继续执行 } } class Cat extends Thread{ int times = 0; boolean loop = true; //todo 通过重写run方法，来实现自己的业务逻辑 @Override public void run() { // 实现了Runnable接口的run方法 while(loop){ System.out.println("执行一次" + "次数" +(++times)+ "线程名:" + Thread.currentThread().getName()); //让其休眠一秒 try { System.out.println("休眠中--"); Thread.sleep(10000); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName() + "被interrupt了"); } } } }
线程插队
- yield ：将线程让出来，让其他线程执行
- join ： 线程的插队。 插队线程一旦插队成功 ，则肯定先执行完插入的线程所有的任务
用户、守护 线程
- 用户线程： 也叫工作线程， 当线程的任务执行完成或者通知方式结束
- 守护线程： 一般是为工作线程服务的，当所有的用户线程结束， 守护线程自动结束
- 常见的守护线程 ： 垃圾回收机制
如何将一个线程设置为守护线程？
public class Thread02 { public static void main(String[] args) throws Exception{ Dog dog = new Dog(); Catt catt = new Catt(); Thread thread1 = new Thread(dog); //Runnable方式实现 设置为守护线程 ，然后在启动 thread1.setDaemon(true); thread1.start(); //Thread 实现 设置为守护线程 ，然后在启动 catt.setDaemon(true); catt.start(); for (int i = 0; i < 10; i++) { System.out.println("test... "); Thread.sleep(1000); } } } class Dog implements Runnable{//通过Runnable接口实现线程 int times = 0; @Override public void run() { while (true){ System.out.println("执行一次" + "次数" +(++times)+ " 线程1名:" + Thread.currentThread().getName()); //让其休眠一秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Catt extends Thread{//通过Runnable接口实现线程 int times = 0; @Override public void run() { while (true){ System.out.println("执行一次" + "次数" +(++times)+ " 线程2 名:" + Thread.currentThread().getName()); //让其休眠一秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
通过//Runnable方式实现 设置为守护线程 ，然后在启动 thread1.setDaemon(true); 的方式实现设置守护线程
注意顺序 ，先设置 再执行
线程的生命周期
线程的7大状态
jdk官方文档中可以看出有六个
但是从我们的线程生命周期转换图可以看出 我们将Runnable(可运行状态)细化为Ready（就绪） 和Running（真正运行）两个状态
线程生命周期转换图
案例
public class Thread02 { public static void main(String[] args) throws Exception{ Catt catt = new Catt(); //Thread 实现 设置为守护线程 ，然后在启动 System.out.println(catt.getName() + " 状态 " + catt.getState()); catt.start(); while(Thread.State.TERMINATED != catt.getState()){ System.out.println(catt.getName() + " 状态 " + catt.getState()); Thread.sleep(500); } System.out.println(catt.getName() + " 状态 " + catt.getState()); } } class Catt extends Thread{//通过Runnable接口实现线程 int times = 0; @Override public void run() { while (times != 5){ System.out.println("执行一次" + "次数" +(++times)+ " 线程2 名:" + Thread.currentThread().getName()); //让其休眠一秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
运行结果：
线程同步机制—-Synchronized
- 在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性
- 也可以这样理解：线程同步，即当有一个线程在对内存进行操作试试，其他的线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作
Synchronized
同步具体方法
同步代码块
//得到对象的锁，才能操作同步代码 synchronized(对象){ //需要被同步的代码 }
同步方法
public synchronized void m(String name){ //需要被同步的代码 }
具体理解 ，不管有多少线程来，在某一时刻，只能有一个线程访问
分析同步原理
假设 t1 抢到锁之后就开始执行代码 ，当执行完之后就会把锁放回去 ，然后t1、t2、t3 三个继续抢这个锁
互斥锁
- java语言中引入了互斥锁的概念 ，来保证共享数据操作的完整性
- 每个对象都对应一个可以称为“互斥锁”的标记， 这个标记用来保证在任意时刻，只能有一个线程访问
- 同步的局限性： 导致程序的执行效率降低
- 同步方法（静态的） 的锁为当前类本身
- 同步方法（非静态的） 的锁可以是this ，也可以是其他对象 （必须是同一对象，可以是不同引用）
**注意事项： **
线程死锁
- 多个线程都占用了对方的所资源， 但是不肯想让 ，导致死锁， 在编程时一定要避免
上述情况导致o1、o2都无法释放，导致死锁
必须避免这种两个锁互相锁
释放锁
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return
- 当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception，导致程序异常结束
- 当前线程在同步代码块、同步方法中执行了wait（）方法，当前线程暂停，并且释放锁
下面的操作不会释放锁
