一、线程安全问题
多线程操作共享变量，由于该共享变量不是立刻可见的，读写不具备原子性，所以存在线程安全问题
二、售票案例
模拟售票案例，库存有10张票，有3个窗口(3个子线程)分别去卖，直到库存为0；
java
public class MyCount {
public int ticket = 10;
public void sell() {
//调用多个线程去把ticket减到0
for (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减到0
for (int i = 0; i < 3; i++){
new Thread(()->{
while (true){
// 加synchronized
synchronized (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减到0
Window 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;
@Override
public 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减到0
for (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减到0
for (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减到0
for (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()后
