java中死锁

㈠ java开发中，什么是死锁(Deadlock)如何分析和避免死锁

死锁是指两个以上的线程永远阻塞的情况，这种情况产生至少需要两个以上的线程和两个以上的资源。
分析死锁，需要查看Java应用程序的线程转储，需要找出那些状态为BLOCKED的线程和他们等待的资源。每个资源都有一个唯一的id，用这个id可以找出哪些线程已经拥有了它的对象锁。
避免嵌套锁，只在需要的地方使用锁和避免无限期等待是避免死锁的通常办法。

㈡ java中死锁的概念是什么给个例子

packagelock;

{
	
	privateStringlock1="lock1";//锁1
	privateStringlock2="lock2";//锁2
	privatebooleanflag=true;//执行标志

	@Override
	publicvoidrun(){
		
		try{
			if(flag){
				flag=false;
				step1:synchronized(lock1){//第一个线程查看lock1锁旗标状态，发现可用，为lock1设置锁旗标后，开始执行任务。此时lock1已经被锁。
					System.out.println(Thread.currentThread().getName()+"开始执行第1个任务");
					Thread.sleep(100);//睡眠等待，此时线程2在执行
					step3:synchronized(lock2){//第一个线程查看lock2锁旗标状态，发现lock2被锁定，等待。
						System.out.println(Thread.currentThread().getName()+"开始执行第2个任务");
					}
				}
			}else{
				flag=true;
				step2:synchronized(lock2){//第二个线程查看lock2锁旗标状态，发现可用，为lock2设置锁旗标后，开始执行任务。此时lock2已经被锁。
					System.out.println(Thread.currentThread().getName()+"开始执行第1个任务");
					Thread.sleep(100);////睡眠等待，此时线程1在执行
					step4:synchronized(lock1){//第二个线程查看lock1锁旗标状态，发现lock1被锁定，等待。
						System.out.println(Thread.currentThread().getName()+"开始执行第2个任务");
					}
				}
			}
		}catch(InterruptedExceptione){
			e.printStackTrace();
		}
	}

}


packagelock;

/**
*死锁测试类
*@authorremind
*/
publicclassTest{

	publicstaticvoidmain(String[]args){
		//开启两个线程
		Tasktask=newTask();
		newThread(task,"线程1").start();
		newThread(task,"线程2").start();
	}
}

我在里边加入了4个阶段setp1、2、3、4。可以配合看一下。

死锁原理：两个线程，两把锁，同步执行。

1、线程1把锁1的状态设置为占用（锁旗标）,然后查看锁2状态，发现锁2状态为被占用，处于等待。

2、线程2把锁2的状态设置为占用（锁旗标）,然后查看锁1状态，发现锁1状态为被占用，处于等待。

两个线程互相等待，线程1不释放锁1，等待锁2。线程2不释放锁2，等待锁1。死锁形成。

㈢ Java 多线程中 什么是死锁有什么作用

所谓死锁:
是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。

㈣ java多线程中的死锁，活锁，饥饿，无锁都是什么鬼

死锁发生在当一些进程请求其它进程占有的资源而被阻塞时。

另外一方面，活锁不会被阻塞，而是不停检测一个永远不可能为真的条件。除去进程本身持有的资源外，活锁状态的进程会持续耗费宝贵的CPU时间。

最后，进程会处于饥饿状态是因为持续地有其它优先级更高的进程请求相同的资源。不像死锁或者活锁，饥饿能够被解开。例如，当其它高优先级的进程都终止时并且没有更高优先级的进程到达。

㈤ java的死锁是什么，如何避免死锁

我们先看看这样一个生活中的例子：在一条河上有一座桥，桥面较窄，只能容纳一辆汽车通过，无法让两辆汽车并行。如果有两辆汽车A和B分别由桥的两端驶上该桥，则对于A车来说，它走过桥面左面的一段路（即占有了桥的一部分资源），要想过桥还须等待B车让出右边的桥面，此时A车不能前进；对于B车来说，它走过桥面右边的一段路（即占有了桥的一部分资源），要想过桥还须等待A车让出左边的桥面，此时B车也不能前进。两边的车都不倒车，结果造成互相等待对方让出桥面，但是谁也不让路，就会无休止地等下去。这种现象就是死锁。如果把汽车比做进程，桥面作为资源，那麽上述问题就描述为：进程A占有资源R1，等待进程B占有的资源Rr；进程B占有资源Rr，等待进程A占有的资源R1。而且资源R1和Rr只允许一个进程占用，即：不允许两个进程同时占用。结果，两个进程都不能继续执行，若不采取其它措施，这种循环等待状况会无限期持续下去，就发生了进程死锁。
在计算机系统中，涉及软件，硬件资源都可能发生死锁。例如：系统中只有一台CD-ROM驱动器和一台打印机，某一个进程占有了CD-ROM驱动器，又申请打印机；另一进程占有了打印机，还申请CD-ROM。结果，两个进程都被阻塞，永远也不能自行解除。
所谓死锁，是指多个进程循环等待它方占有的资源而无限期地僵持下去的局面。很显然，如果没有外力的作用，那麽死锁涉及到的各个进程都将永远处于封锁状态。从上面的例子可以看出，计算机系统产生死锁的根本原因就是资源有限且操作不当。即：一种原因是系统提供的资源太少了，远不能满足并发进程对资源的需求。这种竞争资源引起的死锁是我们要讨论的核心。例如：消息是一种临时性资源。某一时刻，进程A等待进程B发来的消息，进程B等待进程C发来的消息，而进程C又等待进程A发来的消息。消息未到，A，B，C三个进程均无法向前推进，也会发生进程通信上的死锁。另一种原因是由于进程推进顺序不合适引发的死锁。资源少也未必一定产生死锁。就如同两个人过独木桥，如果两个人都要先过，在独木桥上僵持不肯后退，必然会应竞争资源产生死锁；但是，如果两个人上桥前先看一看有无对方的人在桥上，当无对方的人在桥上时自己才上桥，那麽问题就解决了。所以，如果程序设计得不合理，造成进程推进的顺序不当，也会出现死锁。

㈥ 如何理解Java中的死锁

死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。“synchronized”关键词的作用是，确保在某个时刻只有一个线程被允许执行特定的代码块，因此，被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时，线程会给对象加锁，而这个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁。

由于这个原因，在使用“synchronized”关键词时，很容易出现两个线程互相等待对方做出某个动作的情形。代码一是一个导致死锁的简单例子。

//代码一
class Deadlocker {
int field_1;
private Object lock_1 = new int[1];
int field_2;
private Object lock_2 = new int[1];

public void method1(int value) {
“synchronized” (lock_1) {
“synchronized” (lock_2) {
field_1 = 0; field_2 = 0;
}
}
}

public void method2(int value) {
“synchronized” (lock_2) {
“synchronized” (lock_1) {
field_1 = 0; field_2 = 0;
}
}
}
}

参考代码一，考虑下面的过程：

◆ 一个线程（ThreadA）调用method1()。

◆ ThreadA在lock_1上同步，但允许被抢先执行。

◆ 另一个线程（ThreadB）开始执行。

◆ ThreadB调用method2()。

◆ ThreadB获得lock_2，继续执行，企图获得lock_1。但ThreadB不能获得lock_1，因为ThreadA占有lock_1。

◆ 现在，ThreadB阻塞，因为它在等待ThreadA释放lock_1。

◆ 现在轮到ThreadA继续执行。ThreadA试图获得lock_2，但不能成功，因为lock_2已经被ThreadB占有了。

◆ ThreadA和ThreadB都被阻塞，程序死锁。

当然，大多数的死锁不会这么显而易见，需要仔细分析代码才能看出，对于规模较大的多线程程序来说尤其如此。好的线程分析工具，例如JProbe Threadalyzer能够分析死锁并指出产生问题的代码位置。

隐性死锁

隐性死锁由于不规范的编程方式引起，但不一定每次测试运行时都会出现程序死锁的情形。由于这个原因，一些隐性死锁可能要到应用正式发布之后才会被发现，因此它的危害性比普通死锁更大。下面介绍两种导致隐性死锁的情况：加锁次序和占有并等待。

加锁次序

当多个并发的线程分别试图同时占有两个锁时，会出现加锁次序冲突的情形。如果一个线程占有了另一个线程必需的锁，就有可能出现死锁。考虑下面的情形，ThreadA和ThreadB两个线程分别需要同时拥有lock_1、lock_2两个锁，加锁过程可能如下：

◆ ThreadA获得lock_1；

◆ ThreadA被抢占，VM调度程序转到ThreadB；

◆ ThreadB获得lock_2；

◆ ThreadB被抢占，VM调度程序转到ThreadA；

◆ ThreadA试图获得lock_2，但lock_2被ThreadB占有，所以ThreadA阻塞；

◆ 调度程序转到ThreadB；

◆ ThreadB试图获得lock_1，但lock_1被ThreadA占有，所以ThreadB阻塞；

◆ ThreadA和ThreadB死锁。

必须指出的是，在代码丝毫不做变动的情况下，有些时候上述死锁过程不会出现，VM调度程序可能让其中一个线程同时获得lock_1和lock_2两个锁，即线程获取两个锁的过程没有被中断。在这种情形下，常规的死锁检测很难确定错误所在。

占有并等待

如果一个线程获得了一个锁之后还要等待来自另一个线程的通知，可能出现另一种隐性死锁，考虑代码二。

//代码二
public class queue {
static java.lang.Object queueLock_;
Procer procer_;
Consumer consumer_;

public class Procer {
void proce() {
while (!done) {
“synchronized” (queueLock_) {
proceItemAndAddItToQueue();
“synchronized” (consumer_) {
consumer_.notify();
}
}
}
}

public class Consumer {
consume() {
while (!done) {
“synchronized” (queueLock_) {
“synchronized” (consumer_) {
consumer_.wait();
}
();
}
}
}
}
}
}

在代码二中，Procer向队列加入一项新的内容后通知Consumer，以便它处理新的内容。问题在于，Consumer可能保持加在队列上的锁，阻止Procer访问队列，甚至在Consumer等待Procer的通知时也会继续保持锁。这样，由于Procer不能向队列添加新的内容，而Consumer却在等待Procer加入新内容的通知，结果就导致了死锁。

在等待时占有的锁是一种隐性的死锁，这是因为事情可能按照比较理想的情况发展—Procer线程不需要被Consumer占据的锁。尽管如此，除非有绝对可靠的理由肯定Procer线程永远不需要该锁，否则这种编程方式仍是不安全的。有时“占有并等待”还可能引发一连串的线程等待，例如，线程A占有线程B需要的锁并等待，而线程B又占有线程C需要的锁并等待等。

要改正代码二的错误，只需修改Consumer类，把wait()移出“synchronized”()即可。

㈦ 什么是java多线程中的死锁

一个进程在等待一个不可能发生的事，即进程死锁，如果一个或多个进程产生死锁，就会造成系统死锁。
3、死锁发生的必要条件
(1)、互斥条件：一个资源每次只能被一个进程使用，在操作系统中这是真实存在的情况。
(2)、保护和等待条件：有一个进程已获得了一些资源，但因请求其他资源被阻塞时，对已获得的资源保持不放。
(3)、不剥夺条件：有些系统资源是不可剥夺的，当某个进程已获得这种资源后，系统不能强行收回，只能由进程使用完时自己释放。
(4)、环路等待条件：若干个进程形成环行链，每个都占用对方要申请的下一个资源。

㈧ java怎么避免死锁

解决方式:
1、尽量使用tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时可以退出防止死锁。
2、尽量使用java.util.concurrent(jdk 1.5以上)包的并发类代替手写控制并发，比较常用的是ConcurrentHashMap、ConcurrentLinkedQueue、AtomicBoolean等等，实际应用中java.util.concurrent.atomic十分有用，简单方便且效率比使用Lock更高 。
3、尽量降低锁的使用粒度，尽量不要几个功能用同一把锁 。
4、尽量减少同步的代码块。

㈨ JAVA中，线程死锁是什么意思

两个或者多个线程之间相互等待，导致线程都无法执行，叫做线程死锁。
产生死锁的条件：
1.有至少一个资源不能共享
2.至少有一个任务必须持有一个资源并且等待获取另一个被别的任务持有的资源
3.资源不能任务抢占
4.必须有循环等待
高淇Java300集视频教程对线程死锁有详细的讲解。

㈩ 如何避免Java多线程中的死锁

死锁产生的必要条件
产生死锁必须同时满足以下四个条件，只要其中任一条件不成立，死锁就不会发生。
互斥条件：进程要求对所分配的资源（如打印机）进行排他性控制，即在一段时间内某 资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。
不剥夺条件：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能 由获得该资源的进程自己来释放（只能是主动释放)。
请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源 已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。
循环等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被 链中下一个进程所请求。即存在一个处于等待状态的进程集合{Pl, P2, ..., pn}，其中Pi等 待的资源被P(i+1)占有（i=0, 1, ..., n-1)，Pn等待的资源被P0占有