什么是死锁以及避免死锁

一、定义

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。当线程进入对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调用wait方法，才释放资源，在此期间，其他线程将不能进入该代码块。当线程互相持有对方所需要的资源时，会互相等待对方释放资源，如果线程都不主动释放所占有的资源，将产生死锁。

当然死锁的产生是必须要满足一些特定条件的：

1.互斥条件：进程对于所分配到的资源具有排它性，即一个资源只能被一个进程占用，直到被该进程释放

2.请求和保持条件：一个进程因请求被占用资源而发生阻塞时，对已获得的资源保持不放。

3.不剥夺条件：任何一个资源在没被该进程释放之前，任何其他进程都无法对他剥夺占用

4.循环等待条件：当发生死锁时，所等待的进程必定会形成一个环路（类似于死循环），造成永久阻塞。

package com.sxy.thread;

/**

当某个线程占有某个共享资源的锁时，如果另外一个线程也想获得这把锁运行就需要使用wait() 和notify()/notifyall()方法来进行线程通讯了。c、当其他线程调用pthread_cond_signal或pthread_cond_broadcast时，会唤醒相应条件变量等待的线程，此时被唤醒的线程，可以参与调度了，此时被唤醒的线程继续执行pthread_cond_wait()函数，函数pthread_cond_wait()返回之前，会重新给条件变量对应的互斥量上锁，在这里就是nready.mutex，若该函数成功返回，则当前线程有重新获得了nready.mutex锁，当然nready.mutex也可能被其他线程继续占有，此时线程再次阻塞。①、死锁：线程a占有资源a，线程b占有资源b，线程a申请占有资源b，同时要求占有资源b之后才释放资源a，而线程b申请占有资源a，同时要求占有资源a之后才释放资源b，这样两个线程互相永久等待对方释放资源，这就是死锁。

5． 将dll注入系统进程，运行之后释放det.bat 删除自身 6． 病毒文件注入explorer.exe 或winlogon.exe 循环等待,利用它们的空间运行自己，实现隐蔽运行。有很多封装的线程库中有这样的函数 condwait函数，这个函数的主要意义就是释放互斥量，等待信号量，然后再持有互斥量后返回多线程如何避免死锁，主要用于多线程运行状态下，等待一个信号通知，然后继续运行。同步嵌套是产生死锁的常见情景，从上面的代码中我们可以看出，当t1线程拿到锁a后，睡眠2秒，此时线程t2刚好拿到了b锁，接着要获取a锁，但是此时a锁正好被t1线程持有，因此只能等待t1线程释放锁a，但遗憾的是在t1线程内又要求获取到b锁，而b锁此时又被t2线程持有，到此结果就是t1线程拿到了锁a同时在等待t2线程释放锁b，而t2线程获取到了锁b也同时在等待t1线程释放锁a，彼此等待也就造成了线程死锁问题。

wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁。- wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁。•新建 (born) :新建的线程处于新建状态•就绪 (ready) : 在创建线程后，它将处于就绪状态，等待 start() 方法被调用•运行 (running) : 线程在开始执行时进入运行状态•睡眠 (sleeping) : 线程的执行可通过使用 sleep() 方法来暂时中止。

* 谁也无法继续运行，即产生了死锁。

*

* @author sunxy

*/

public class DeadLock {

public static void main(String[] args) {

dead_lock();

}

private static void dead_lock() {

// 两个资源

final Object resource1 = "resource1";

final Object resource2 = "resource2";

// 第一个线程，想先占有resource1,再尝试着占有resource2

Thread t1 = new Thread() {

public void run() {

// 尝试占有resource1

synchronized (resource1) {

// 成功占有resource1

System.out.println("Thread1 1:locked resource1");

// 休眠一段时间

try {

Thread.sleep(50);

} catch (InterruptedException e) {

e.printStackTrace();

}

// 尝试占有resource2，如果不能占有，该线程会一直等到

synchronized (resource2) {

System.out.println("Thread1 1:locked resource2");

}

}

}

};

// 第二个线程，想先占有resource2，再占有resource1

Thread t2 = new Thread() {

public void run() {

// 尝试占有resource2

synchronized (resource2) {

// 成功占有resource2

System.out.println("Thread 2 :locked resource2");

// 休眠一段时间

try {

Thread.sleep(50);

} catch (InterruptedException e) {

e.printStackTrace();

}

// 尝试占有resource1，如果不能占有，该线程会一直等到

synchronized (resource1) {

System.out.println("Thread1 2:locked resource1");

}

}

}

};

// 启动线程

t1.start();

t2.start();

}

}

死锁的另一种：递归死锁，举例：

所谓递归函数就是自调用函数，在函数体内直接或间接的调用自己，即函数的嵌套是函数本身。

递归方式有两种:直接递归和间接递归，直接递归就是在函数中出现调用函数本身。间接递归，指函数中调用了其他函数，而该其他函数又调用了本函数。

那什么时候使用递归呢？一般来说当你要在某段代码逻辑中使用循环迭代的时候但是迭代的次数在迭代之前无法知晓的情况下使用递归。打个比方你要在一个文件夹中查找某个文件，而这个文件夹底下有N多子文件夹和文件，当你在不知道有多少层文件夹和文件的情况下你就得用到递归了。

递归的优点就是让代码显得很简洁，同时有些应用场景不得不使用递归比如前面说的找文件。递归是个好东西但是在某些时候也会给你带来一些麻烦。比如在多线程的环境下使用递归，遇到了多线程那么就不得不面对同步的问题。而递归程序遇到同步的时候很容易出问题。多线程的递归就是指递归链中的某个方法由另外一个线程来操作，以下代码的意思都是这个意思即调用recursive()和businessLogic()并非一个线程(如果是在一个线程中就不存在死锁问题，例如下面的recursive变成private就不存在问题。)

publicclassTest{

publicvoidrecursive(){

this.businessLogic();

}

publicsynchronizedvoidbusinessLogic(){

System.out.println("处理业务逻辑");

信息,是否要求服务商进行数据保存,如何对这些数据进行证据保存,也给解决知识产权纠纷的。应用推广时，可结合选定的应用示范领域，基于综合科技信息数据管理工具多线程如何避免死锁，按照知识组织体系实例库建设的数据规范及质量要求，对收集到的科技文献、科研机构、科研人员、基金项目、科学数据等多类型综合科技信息资源的规范性及数据质量进行质量检查，基于科研本体描述框架和语义模型，完成各类信息资源的批量加载和人工审核，完成科研本体实例库的构建和知识资源的深度关联，并通过领域科研信息环境支撑技术平台，进行应用示范系统的快速构建与发布。//这个就是调用数据访问方法，如这里是调用manager.personmanagerimpl.getlist(),并用result保存执行的结果（数据访问的结果）,如这里调用了getlist()方法，会先打印出"getpersonfromdb"，然后将结果集放入到result里面去，这里由于使用的是自己配置只能放入10个元素的ehcache，所以这里的result是arraylist，它里面存放的是elementdata[10]，并将getlist得到的结果放入到elementdata里面去了system.out.println("setintocache")。

this.recursive();

}

}

以上这段代码就是个能形成死锁的代码，事实上这个“synchronized”放在“businessLogic()”和“recursive()”都会形成死锁，并且是多线程的情况下就会锁住！他的逻辑顺序是先执行recursive()方法然后接下来执行businessLogic()方法同时将businessLogic()方法锁住，接下来程序进入businessLogic()方法内部执行完打印语句后开始执行recursive()，进入recursive()后准备执行businessLogic()，等等问题来了！之前执行的businessLogic()的锁还没有放开这次又执行到这里了，当然是的了，形成了死锁！从这个例子我们总结出来一个规律就是在递归的时候在递归链上面的方法上加锁肯定会出现死锁（所谓递归链就是指recursive()链向businessLogic()，businessLogic()又链回recursive()），解决这个问题的方法就是避免在递归链上加锁，请看以下的例子

publicclassTest{

publicvoidrecursive(){

this.businessLogic();

}

publicvoidbusinessLogic(){

System.out.println("处理业务逻辑");

this.saveToDB();

this.recursive();

}

publicsynchronizedvoidsaveToDB(){

System.out.println("保存到");

}

}

saveToDB()不在这条递归链上面自然不会出现死锁，所以说在递归中加锁是件很危险的事情，实在逃不过要加锁就加在最小的粒度的程序代码上以减小死锁的概率。

避免死锁：

在有些情况下死锁是可以避免的。本文将展示三种用于避免死锁的技术：

当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。

如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。看下面这个例子：

Thread 1:
  lock A 
  lock B
Thread 2:
   wait for A
   lock C (when A locked)
Thread 3:
   wait for A
   wait for B
   wait for C

如果一个线程（比如线程3）需要一些锁，那么它必须按照确定的顺序获取锁。它只有获得了从顺序上排在前面的锁之后，才能获取后面的锁。

例如，线程2和线程3只有在获取了锁A之后才能尝试获取锁C(译者注：获取锁A是获取锁C的必要条件)。因为线程1已经拥有了锁A，所以线程2和3需要一直等到锁A被释放。然后在它们尝试对B或C加锁之前，必须成功地对A加了锁。

顺序锁也是对读写锁的一种优化，对于顺序锁，读者绝不会被写者阻塞，也就说，读者可以在写者对被顺序锁保护的共享资源进行写操作时仍然可以继续读，而不必等待写者完成写操作，写者也不需要等待所有读者完成读操作才去进行写操作。java线程之间的通信总是隐式进行 java并发模型—硬件视图 内存空间 共享对象 共享对象 共享对象 内存中的jvm 对象 程之间共享 线程1 线程2 处理器a 处理器b 处理器c 处理器d java并发模型—操作系统视图 jvm进程 hotspot vm中， java线程被 java线程 java线程 java线程 映射为本地操作系 统线程 linux kernel 操作系统内核 直接调度java 线程给可用的cpu处理器a 处理器b 处理器c 处理器d 编译器和处理器喜欢不择手段的冒险源代码 编译器优化 指令级并行 内存系统的 最终执行的 的重排序 的重排序 重排序 指令序列 编译器的 重排序 重排序 指令级并行的 处理器的 重排序 重排序 内存系统的 重排序 顺序一致性内存模型的原型结构 处理器a 处理器b 处理器c 处理器c a3 b2 d1 程序顺 a2 b1 c3 d2 序不变 a1 c2 每个内存 c1 单元一个 fifo队列内存单元 1 2 3 4 5 6 7 8 9 10 11 12 13 … … n顺序一致性内存模型的程序员视图 线程 线程 线程 线程 … 2 3 n 1 内存 顺序一致性内存模型的2 大特性 特性2 线程a 的程序顺序 操作的执行整体上无序，但两个线程 都只能看到这个执行顺序。注： 这种集合的遍历是无序的，即遍历顺序可能不同于 $obj 中元素的定义顺序 （据目前所知，是根据键的字母排序的）。

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-114015-1.html