一、线程安全问题
多线程操作共享变量,由于该共享变量不是立刻可见的,读写不具备原子性,所以存在线程安全问题
二、售票案例
模拟售票案例,库存有10张票,有3个窗口(3个子线程)分别去卖,直到库存为0;
java">public class MyCount {public int ticket = 10;public void sell() {//调用多个线程去把ticket减到0for (int i = 0; i < 3; i++){new Thread(()->{while (true){if (ticket>0){//模拟售票耗费时间0.1秒try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket--;System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);}else {break;}}},"线程"+i).start();}}public static void main(String[] args) {MyCount myCount = new MyCount();myCount.sell();}
}
出现超卖和重卖的问题
三、Sychronized
3.1 修饰代码块
将同步代码块用sychronized(){ }
标记。操作相同的共享变量的线程竞争的锁对象必须是同一个,放在小括号里。
java"> public void sell() {//调用多个线程去把ticket减到0for (int i = 0; i < 3; i++){new Thread(()->{while (true){// 加synchronizedsynchronized (MyCount.class){if (ticket>0){//模拟售票耗费时间0.1秒try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket--;System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);}else {break;}}}},"线程"+i).start();}}
修改synchronized的锁对象,发现锁失效了。
原因是每个线程里都有各自的obj对象,不是同一个。
3.2 修饰方法
注意:这里多个Thread使用的是同一个实现了Runnable接口的类的对象
java">public class MyCount {public void sell() {//调用多个线程去把ticket减到0Window w = new Window();for (int i = 0; i < 3; i++){new Thread(w,"线程"+i).start();}}public static void main(String[] args) {MyCount myCount = new MyCount();myCount.sell();}
}class Window implements Runnable{private int ticket = 10;@Overridepublic void run() {while (true){this.sell();}}synchronized void sell(){if (ticket>0){//模拟售票耗费时间0.1秒try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket--;System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);}}
}
3.3 synchronized总结
- 任意对象都可以作为同步锁。
- 同步方法的锁:静态方法(类名.class)、非静态方法(this)
- 同步代码块:自己指定,很多时候也是指定为this或类名.class
四、Reentrantlock
4.2 使用流程
使用流程
- 实例化 ReentrantLock
- 调用锁定方法lock()
- 调用解锁方法unlock()
如果同步代码块会有异常,要把unlock()写到finally
java">import java.util.concurrent.locks.ReentrantLock;public class MyCount {public int ticket = 10;private final ReentrantLock lock = new ReentrantLock();public void sell() {//调用多个线程去把ticket减到0for (int i = 0; i < 3; i++){new Thread(()->{while (true){//获取锁lock.lock();//需要保证线程安全的代码try{if (ticket>0){//模拟售票耗费时间0.1秒try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket--;System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);}else {break;}}finally {//释放锁lock.unlock();}}},"线程"+i).start();}}public static void main(String[] args) {MyCount myCount = new MyCount();myCount.sell();}
}
默认是非公平锁,也就是后来的线程也可能抢到锁。
4.2 公平锁
公平锁:线程会排队,排在前面的先获得锁。如果这个锁是公平锁,那么线程来的时候会检查队列里是否有别的线程在排队,如果有的话就进队列里让别的线程先运行。
java">private final ReentrantLock lock = new ReentrantLock(true);
4.3 尝试获取锁tryLock()
- 不管锁有没有获取到,都会继续向下执行,而不会阻塞。
- 有返回值,返回是否成功获取到了锁
java"> public void sell() {//调用多个线程去把ticket减到0for (int i = 0; i < 3; i++){new Thread(()->{while (true){//获取锁boolean tried = lock.tryLock();System.out.println(Thread.currentThread().getName()+"尝试获取锁:"+tried);//需要保证线程安全的代码try{if (ticket>0){//模拟售票耗费时间0.1秒try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket--;System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);}else {break;}}finally {//释放锁lock.unlock();}}},"线程"+i).start();}}
这里抛出异常是因为,没有获取到锁但是却有调用了unlock()
所以需要在unlock之前判断一下是否获取到了锁
java"> public void sell() {//调用多个线程去把ticket减到0for (int i = 0; i < 3; i++){new Thread(()->{while (true){//获取锁boolean tried = lock.tryLock();//需要保证线程安全的代码try{//如果获取成功if (tried){if (ticket>0){//模拟售票耗费时间0.1秒try {Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}ticket--;System.out.println(Thread.currentThread().getName()+"把ticket减到了"+ticket);}else {break;}}}finally {//释放锁if (tried){lock.unlock();}}}},"线程"+i).start();}}
4.3 lockInterrruptibly()可中断地获取锁
正解:当t1执行时间很长,t2(获取锁时采用lockInterrruptibly()方式)一直在等待获取锁,一直获取不到,这时候t2可以被别的线程中断。
如果t2是lock方式获取锁,那他只能陷入无休止的等待获取锁的过程中,不能直接被中断
这是错误的:线程t1调用lockInterrruptibly()方法获取锁后,别的线程可以立刻打断t1的执行
java"> public void sell() throws InterruptedException {Thread t1 = new Thread(() -> {try {lock.lock();System.out.println("t1 start");Thread.sleep(Long.MAX_VALUE);System.out.println("t1 end");} catch (InterruptedException e) {System.out.println("t1 被中断");} finally {lock.unlock();}});t1.start();// 阻塞1秒,保证上面的线程先执行,先获取到锁Thread.sleep(1000);Thread t2 = new Thread(() -> {try {lock.lockInterruptibly();System.out.println("t2 start");Thread.sleep(Long.MAX_VALUE);System.out.println("t2 end");} catch (InterruptedException e) {System.out.println("t2 被中断");} finally {//lock.unlock();}});t2.start();Thread.sleep(3000);t2.interrupt();}
将lock.lockInterruptibly()改为lock.lock()后