死锁机制

• 介绍: 死锁是由于不同的进程拥有对方需要的被锁资源,又在相互请求对方的被锁资源造成的无限等待局面

1 JAVA中的死锁

1.1 死锁示例

两个死锁类

package deadlock;

import java.util.List;

public class A extends Thread {
    private List listA; //A,B两个类共享同一个listA和listB
    private List listB;

    public A(List listA, List listB) {
        this.listA = listA;
        this.listB = listB;
    }

    public void lockListA() {
        synchronized (listA) {  //请求listA的对象锁
            System.out.println("listA locked");
            try {
                sleep(2 * 1000);    //休息2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (listB) {  //请求listB的对象锁
                listB.add("B");
                System.out.println(listB.toString());
            }
        }
        System.out.println("listA unlocked");

    }

    public void run() {
        lockListA();
    }
}

package deadlock;

import java.util.List;

public class B extends Thread{
    private List listA;
    private List listB;

    public B(List listA, List listB) {
        this.listA = listA;
        this.listB = listB;
    }

    public void lockListB() {
        synchronized (listB) {
            System.out.println("listB locked");
            try {
                sleep(5 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (listA) {
                listA.add("A");
                System.out.println(listA.toString());
            }
        }
        System.out.println("listB unlocked");

    }

    public void run() {
        lockListB();
    }
}

运行主方法

package deadlock;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List a = new ArrayList();
        List b = new ArrayList();

        A threadA = new A(a, b);
        B threadB = new B(a, b);

        threadA.start();
        threadB.start();
    }
}

运行结果: 

listA locked
listB locked

 可以看到locked以后就不能unlocked了,也就是进入了死锁,听我分析:

1. threadA.start()调用了lockListA()方法,这时候listA的对象锁被threadA获取,然后threadA进入sleep 2秒的过程
2. threadB.start()调用了lockListB()方法,这时候listB的对象锁被threadB获取,然后threadB进入sleep 5秒的过程
3. 2秒后,threadA醒来,threadA请求listB的对象锁,此时threadB处于sleep状态,listB的对象锁被threadB持有,所以threadA坐等threadB释放对象锁
4. 又过了3秒,threadB醒来,threadB请求listA的对象锁,此时threadA处于等待阻塞状态(正在等threadB释放listB的对象锁),还没有释放listA的锁,所以threadB也只有等待threadA释放listA的对象锁,于是threadB也进入阻塞状态
5. 于是,threadA和threadB都进入了阻塞,于是就无限阻塞下去了...

1.2 同步方法的常用写法

一般来说,我们在写线程安全的方法时都会这样写,如下:

package threadsafe;

import java.util.ArrayList;
import java.util.List;

public class ThreadSafeClass {
    List<Integer> intList;

    public ThreadSafeClass() {
        intList = new ArrayList<Integer>();
    }

    public void addElement() {
        synchronized (this) {   //调用此方法是,将自己锁死
            Integer elem = (int)(Math.random() * 100);
            intList.add(elem);
        }
    }
}

package threadsafe;

import java.util.ArrayList;
import java.util.List;

public class MyThread extends Thread{
    ThreadSafeClass threadSafeClass;

    public MyThread(ThreadSafeClass tsc) {
        threadSafeClass = tsc;
    }

    public void run() {
        threadSafeClass.addElement();   //多线程执行此方法只能一步一步来,因为要获取本对象锁
    }
}

1.4 JAVA自己实现的线程安全类

1.4.1 Vector一族

先谈谈Vector和ArrayList,我们都知道Vector和ArrayList功能类似,他们的区别在于Vector是线程安全的,而ArrayList不是,那么Vector的线程安全是如何实现的呢

查看源码可以发现他的方法多是synchronized的(这里我就不贴源码了,有兴趣的同学可以去查查),也就是说他的实现和我上面说的类似,这种方法的缺点其实就是效率比较低下,因为加锁是很消耗效率的

1.4.2 ConccurentLinkedQueue

这里以ConcurrentLinkedQueue为例,查看源码看不到synchronized之类的东西,这里引用网摘的一段话:

先来回顾之前提到过的ConcurrentHashMap，它是一个以Concurrent开头的并发集合类，其原理是通过增加锁和细化锁的粒度来提高并发度。

另一个值得一提的Concurrent是ConcurrentLinkedQueue。这个类采用了另一种提高并发度的方式：非阻塞算法（Non-blocking），第一次实现了无锁的并发。

也就是说ConcurrentLinkedQueue并不是采用加锁的方式实现线程同步的,这个非阻塞算法大家有兴趣可以去研究一下

2 数据库中的死锁

数据库中的死锁常出现在事物中,这里我不写具体的代码了,举个例子随便聊聊

比如数据库中有两个表

现在又两个事务:

事务A:

BEGIN;

SELECT * FROM user WHERE userId = ? FOR UPDATE;

DELETE FROM message WHERE messageId = ?;

COMMIT;

事务B:

BEGIN;

SELECT * FROM message WHERE messageId = ? FOR UPDATE;

UPDATE user SET userName = 'test' WHERE userId = ?;

COMMIT;

假设现在两个事务同时运行,userId = 1, messageId = 1,就会造成死锁

因为事务A首先对userId=1的那行加上行锁,事务B也同时对messageId=1的那行加上行锁

然后事务A想DELETE messageId=1的那行,就必须等待事务B结束,释放messageId=1的那行的行锁

而事务B想UPDATE userId=1的那行,也必须等待事务A结束,释放userId=1的那行的行锁

这样相互等待,就死锁了