Java学习笔记45（多线程二：安全问题以及解决原理）

线程安全问题以及解决原理：

多个线程用一个共享数据时候出现安全问题

一个经典案例：

电影院卖票，共有100座位，最多卖100张票，买票方式有多种，网上购买、自主售票机、排队购买

三种方式操作同一个共享数据，这时候会出现安全问题：

示例：

package demo1;

public class Tickets implements Runnable {
private int ticket = 100;

public void run(){
while(true){
if (ticket>0) {
System.out.println(Thread.currentThread().getName()+"出售第"+ticket--+"张票");
}
}
}
}

package demo1;

public class ThreadDemo {
public static void main(String[] args) {
Tickets t = new Tickets();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t0.start();
t1.start();
t2.start();
}
}

一般不会出现问题，但是要想到这种问题

但是，假设只剩下最后最后一张票，一个线程抢到CPU资源执行，在判断结束时候，CPU资源被其他线程抢到，其他线程判断然后执行，

这时候轮到开始时候的线程，由于已经判断完，继续执行，这时候票数就会变成负数，这里就出现了问题

解决方法：

同步代码块

原理：一个线程进入数据操作的时候，阻止其他线程执行

package demo1;

public class Tickets implements Runnable {
private int ticket = 100;
private Object obj1 = new Object();
public void run() {
while (true) {
synchronized (obj1) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");
}
}
}
}
}

不过，虽然安全了，但是运行速度下降

但是，我们为了安全性可以不顾及速度，无论如何都要保证安全性

这里传入的对象参数简称作：同步锁，专业名称：对象监视器

原理：

没有锁的线程不能执行，只能等待

线程遇到同步代码块后判断是否有同步锁，如果有，拿走锁，进入同步中执行，执行完毕后将锁对象还回去

另一个线程遇到代码块后没有锁，无法进入，原来的线程把锁还回去之后新线程再获取锁，循环下去

这里明显可以看出，这么多的过程，速度自然就慢下来了

采用同步方法解决问题：

优点：代码量更低

package demo1;

public class Tickets implements Runnable {
private int ticket = 100;

public void run() {
while (true) {
payTicket();
}
}

public synchronized void payTicket() {
//同步方法的对象锁是本类对象引用：即为this
//静态方法的锁是本类类名.class
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");
}
}
}

缺点：如果出现了异常，方法的锁对象没有释放，不出同步，锁不会释放

这里就需要用到一个Lock接口：

提供了更广泛的锁定操作

改进之前的售票案例：

package demo1;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Tickets implements Runnable {
private int ticket = 100;
private Lock lock = new ReentrantLock();

public void run() {
while (true) {
lock.lock();
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");
}
lock.unlock();
}
}
}

死锁：

同步锁引发的弊端：

当线程任务中出现了多个同步时，如果同步中嵌套了其他的同步，这时候就会引发一种现象，程序出现无限等待，这种现象称之为死锁

通俗解释：两个人吃一碗面，却只有一双筷子，两个人一人抢到一支筷子，规定不能用手抓，这时候就无法吃面

代码实现：

package demo1;

public class LockA {
private LockA(){}

public final static LockA locka =new LockA();
}

package demo1;

public class LockB {
private LockB(){}

public final static LockB lockb =new LockB();
}

package demo1;

public class DeadLock implements Runnable {
private int i = 0;

public void run() {
while (true) {
if (i % 2 == 0) {
synchronized (LockA.locka) {
System.out.println("if...locka");
synchronized (LockB.lockb) {
System.out.println("if...lockb");
}
}
} else {
synchronized (LockB.lockb) {
System.out.println("else...lockb");
synchronized (LockA.locka) {
System.out.println("else...locka");
}
}
}
i++;
}
}
}

package demo1;

public class DeadLockDemo {
public static void main(String[] args) {
DeadLock dead = new DeadLock();
Thread t0 = new Thread(dead);
Thread t1 = new Thread(dead);
t0.start();
t1.start();
}
}

运行后发现，会卡在某一处不动，但是并没有停止