文章目录
- 线程的死锁
介绍
【线程的安全问题】
由于多个线程同时运行时，多个线程表现得不可控，即每个线程在某个实可运行到什么阶段是不可控的，所以，如果这些线程需要对同一个数据进行修改，则最终的值就不可控，即线程的安全问题。
使用synchronized互斥锁可以解决线程的安全问题。
【使用synchronized】
1、使用 synchronized(对象) {代码} 的语法将需要锁定的代码进行锁定，锁定的对象必须是相对于多个线程而言的，访问到的是同一个对象。
2、使用synchronized修饰方法，表示锁定该方法中的所有代码，当锁定方法时，锁定的对象就是 this，所以，如果某代码不能够 synchronized(this)实现互斥锁，则使用 synchronized修饰方法是无效的。
【小结】
当出现线程安全问题时，使用synchronized("hello")所著所有代码即可
线程的安全问题描述
我们用线程模拟一个取钱过程
Bank类
public class Bank {
public static int count = 5000;
}
Person类
public class Person extends Thread {
public Person(String name) {
super(name);
}
public void run() {
System.out.println(getName() + "开始取钱，当前余额：" + Bank.count);
Bank.count -= 4000;
System.out.println(getName() + "取钱结束，当前余额：" + Bank.count);
}
}
Main
public class Main {
public static void main(String[] args) {
Person p = new Person("我");
p.start();
}
}
运行程序：
刚才是正常情况下的取钱，如果 2 个人同时取钱会怎样呢，我们来模拟下：
Test
public class Main {
public static void main(String[] args) {
Person p1 = new Person("我");
Person p2 = new Person("妈妈");
p1.start();
p2.start();
}
}
再次运行程序：
我们发现金额变成负数了，对金额加一个判断能不能解决这个问题呢？
Person
public class Person extends Thread {
public Person(String name) {
super(name);
}
public void run() {
if (Bank.count >= 4000) {
Bank.count -= 4000;
System.out.println(getName() + "取钱结束，当前余额：" + Bank.count);
} else {
System.out.println(getName() + "取钱失败");
}
}
}
执行程序：
或
执行多次可能出错，为了增加出错几率，修改代码：
Person
public class Person extends Thread {
public Person(String name) {
super(name);
}
public void run() {
System.out.println(getName() + "开始取钱，当前余额：" + Bank.count);
if (Bank.count >= 4000) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Bank.count -= 4000;
System.out.println(getName() + "取钱结束，当前余额：" + Bank.count);
} else {
System.out.println(getName() + "取钱失败");
}
}
}
运行程序：
出现这种结果的原因由于是 2 个线程交替执行，执行过程如下图所示，可能 红色线程执行到判断Bank.account>=4000，判断通过了，就停下切换到了蓝色线程，而蓝色线程也执行到判断Bank.account>=4000，由于余额并没有减少，所以判断也通过了，所以会减少 2 次。所以即使我们加了判断也是没有用的。
而且我们增加了Thread.sleep(1);程序的错误就必然出现，红色线程执行到Bank.account>=4000，就 sleep，换蓝色线程执行Bank.account>=4000，2次判断都通过了，程序必然出错。
synchronized
第一种写法
想解决这个问题我们可以让if(){}这段语句能整体一次性执行，使用synchronized互斥锁可以解决线程的安全问题，代码如下：
public class Person extends Thread {
public Person(String name) {
super(name);
}
public static Object lock = new Object();
public void run() {
System.out.println(getName() + "开始取钱，当前余额：" + Bank.count);
synchronized (lock) {
if (Bank.count >= 4000) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Bank.count -= 4000;
System.out.println(getName() + "取钱结束，当前余额：" + Bank.count);
} else {
System.out.println(getName() + "取钱失败");
}
}
}
}
绝对靠谱的锁可以在里边放一个字符串
synchronized("hello_world");
或者保证变量前有static
public static Object lock = new Object();
不可以用一个变量存一个字符串，因为每 new 一个新对象，字符串变量也会 new 一个，也可能程序运行过程中这个字符串会进行运算而改变值
运行程序：
第二种写法
如果implements Runnable接口，那么也可以这样写：
synchronized(this)
我们改变 Person 代码
Person
public class Person implements Runnable {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void run() {
System.out.println(getName() + "开始取钱，当前余额：" + Bank.count);
synchronized (this) {
if (Bank.count >= 4000) {
Bank.count -= 4000;
System.out.println(getName() + "取钱结束，当前余额：" + Bank.count);
} else {
System.out.println(getName() + "取钱失败");
}
}
}
}
Main
public class Main {
public static void main(String[] args) {
Person p1 = new Person("我");
Person p2 = new Person("妈妈");
Thread t1 = new Thread(p1);
Thread t2 = new Thread(p2);
t1.start();
t2.start();
}
}
运行程序：
Person 中的代码也可以这样写：
public synchronized void run() {
System.out.println(getName() + "开始取钱，当前余额：" + Bank.count);
if (Bank.count >= 4000) {
Bank.count -= 4000;
System.out.println(getName() + "取钱结束，当前余额：" + Bank.count);
} else {
System.out.println(getName() + "取钱失败");
}
}
线程的死锁
【线程的死锁】
当存在 2 个或以上的线程时，每个线程都锁定某个对象的同时，还尝试去锁定被其他线程已经锁定的对象，就会出现死锁。
我们来模拟一个死锁
新建 DeadLockThread
public class DeadLockThread extends Thread {
public int flag;
public static Object lock1 = new Object();
public static Object lock2 = new Object();
public DeadLockThread(int flag) {
this.flag = flag;
}
public void run() {
if (flag == 1) {
synchronized (lock1) {
System.out.println("锁住了lock1");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2) {
System.out.println("锁住了lock2");
}
}
} else {
synchronized (lock2) {
System.out.println("锁住了lock2");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1) {
System.out.println("锁住了lock1");
}
}
}
}
}
Main
public class Main {
public static void main(String[] args) {
DeadLockThread t1 = new DeadLockThread(1);
DeadLockThread t2 = new DeadLockThread(2);
t1.start();
t2.start();
}
}
运行结果：程序会卡住，一直执行不完，这种嵌套的锁就会出现死锁。
