Ⅰ java线程死锁问题
当M=2 N=2 W=2的时候，假定N个进程分别为N1，N2。
如果N1进程获取到1个R资源，同时N2进程也获取到1个R资源，M=2，W=2，两者都不能满足最大需求，也都不释放资源，都等待R资源，就会造成死锁。
但是当M=4 N=3，W=2的时候，假定N个进程分别为N1，N2，N3。
最坏的情况是，进程N1、N2、N3同是获取到1个R资源，而M=4，W=2，还有一个空闲的R资源，不管是进程N1、N2、N3中的哪个进程获取到空闲资源，都可以满足最大需求，获取到最后一个空闲R资源的进程满足需求，进入运行状态，另外两个进程等待，满足需求的进程运行结束后释放资源，将有两个空闲的R资源，剩下两个等待的进程都能满足需求，所以不会陷入死锁。
互斥使用是不能同时使用，但是如果资源不足，每个进程都占用一部分资源却不能满足需求，而且都不释放自身占用的那部分资源，都陷入等待状态，就会造成死锁。
如果(w-1)*N+1<=M就不会造成死锁，反之，如果(w-1)*N+1>M就有可能造成死锁。
Ⅱ Java多线程死锁的问题
代码已修改，可能出现的问题，（1）sleep时间过短，线程2还没启动，票已卖完
（2）两个while是死循环，票卖完了没退出
（3）死锁的原因怀疑是两个Obj锁的冲突，可能是两个线程各拿到一个锁，均没有解锁机制，所以我删除了show方法中的obj锁
classTicketimplementsRunnable
{
Objectobj=newObject();
booleanflag=true;
{
while(tick>0)
{
synchronized(obj)//obj锁
{
show();
}
}
}
else
{
while(tick>0)show();
}
}
publicsynchronizedvoidshow(){//this锁
if(tick>0){
try{
Thread.sleep(100);
}catch(Exceptione){
}
System.out.println(Thread.currentThread().getName()+"code.........:"+tick--);
}
}
}
publicclassDeadLockDemo
{
publicstaticvoidmain(String[]args){
Tickett=newTicket();
Threadt1=newThread(t);
Threadt2=newThread(t);
t1.start();
try{Thread.sleep(10);}catch(Exceptione){}
t.flag=false;
t2.start();
}
}
Ⅲ 怎么处理JAVA多线程死锁问题
对资源采用同步，还有银行家算法
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系 银行家算法
统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。 要解释银行家算法，必须先解释操作系统安全状态和不安全状态。 安全序列是指一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
安全状态
如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态
不存在一个安全序列。不安全状态不一定导致死锁。
算法的实现
初始化
由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。
银行家算法
在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。 银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。它是最具有代表性的避免死锁的算法。 设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。 (1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转(2)；否则，出错。 (2)如果REQUEST [cusneed] [i]<= AVAILABLE[cusneed][i]，则转(3)；否则，出错。 (3)系统试探分配资源，修改相关数据： AVAILABLE[i]-=REQUEST[cusneed][i]; ALLOCATION[cusneed][i]+=REQUEST[cusneed][i]; NEED[cusneed][i]-=REQUEST[cusneed][i]; (4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
安全性检查算法
(1)设置两个工作向量Work=AVAILABLE;FINISH (2)从进程集合中找到一个满足下述条件的进程， FINISH==false; NEED<=Work; 如找到，执行(3)；否则，执行(4) (3)设进程获得资源，可顺利执行，直至完成，从而释放资源。 Work+=ALLOCATION; Finish=true; GOTO 2 (4)如所有的进程Finish= true，则表示安全；否则系统不安全。
Ⅳ 面试题：Java线程死锁怎么解决
1，互斥条件
2，请求和保持条件
3，不剥夺条件
4，环路等待条件 你把其中一个条件解除了就能解决死锁这道面试题 我上次去公司我就是这样回答了 过了~
Ⅳ Java线程死锁如何避免这一悲剧
欢迎进入Java社区论坛，与200万技术人员互动交流 >>进入Java线程死锁需要如何解决，这个问题一直在我们不断的使用中需要只有不断的关键。不幸的是，使用上锁会带来其他问题。让我们来看一些常见问题以及相应的解决方法：Java线程死锁Java线程死锁是一个经典的多线程问题，因为不同的线程都在等待那些根本不可能被释放的锁，从而导致所有的工作都无法完成。假设有两个线程，分别代表两个饥饿的人，他们必须共享刀叉并轮流吃饭。他们都需要获得两个锁：共享刀和共享叉的锁。
假如线程 “A”获得了刀，而线程“B”获得了叉。线程“A”就会进入阻塞状态来等待获得叉，而线程“B”则阻塞来等待“A”所拥有的刀。这只是人为设计的例子，但尽管在运行时很难探测到，这类情况却时常发生。虽然要探测或推敲各种情况是非常困难的，但只要按照下面几条规则去设计系统，就能够避免Java线程死锁问题：
让所有的线程按照同样的顺序获得一组锁。这种方法消除了 X 和 Y 的拥有者分别等待对方的资源的问题。
将多个锁组成一组并放到同一个锁下。前面Java线程死锁的例子中，可以创建一个银器对象的锁。于是在获得刀或叉之前都必须获得这个银器的锁。
将那些不会阻塞的可获得资源用变量标志出来。当某个线程获得银器对象的锁时，就可以通过检查变量来判断是否整个银器集合中的对象锁都可获得。如果是，它就可以获得相关的锁，否则，就要释放掉银器这个锁并稍后再尝试。
最重要的是，在编写代码前认真仔细地设计整个系统。多线程是困难的，在开始编程之前详细设计系统能够帮助你避免难以发现Java线程死锁的问题。
Volatile 变量，volatile 关键字是 Java 语言为优化编译器设计的。以下面的代码为例：
1.class VolatileTest {
2.public void foo() {
3.boolean flag = false;
4.if(flag) {
5.//this could happen6.}
7.}
8.}
一个优化的编译器可能会判断出if部分的语句永远不会被执行，就根本不会编译这部分的代码。如果这个类被多线程访问， flag被前面某个线程设置之后，在它被if语句测试之前，可以被其他线程重新设置。用volatile关键字来声明变量，就可以告诉编译器在编译的时候，不需要通过预测变量值来优化这部分的代码。
无法访问的Java线程死锁有时候虽然获取对象锁没有问题，线程依然有可能进入阻塞状态。在 Java 编程中IO就是这类问题最好的例子。当线程因为对象内的IO调用而阻塞时，此对象应当仍能被其他线程访问。该对象通常有责任取消这个阻塞的IO操作。造成阻塞调用的线程常常会令同步任务失败。如果该对象的其他方法也是同步的，当线程被阻塞时，此对象也就相当于被冷冻住了。
其他的线程由于不能获得对象的Java线程死锁，就不能给此对象发消息（例如，取消 IO 操作）。必须确保不在同步代码中包含那些阻塞调用，或确认在一个用同步阻塞代码的对象中存在异步方法。尽管这种方法需要花费一些注意力来保证结果代码安全运行，但它允许在拥有对象的线程发生阻塞后，该对象仍能够响应其他线程。
Ⅵ 什么是java线程死锁，如何解决死锁问题
比如有两个线程执行，线程t1，
线程t2
t1
需要获取方法A的锁标志，同时方法A调用了方法B，t1获取了A的锁标志，并获取了B的锁标志，才能完成执行
同时t2也在执行，t2获取方法B的锁标志，方法B调用了方法A,t2也需要获取两个方法A,B的锁标志才能执行完成
当t1
获取了A方法的锁标志，同时t2获取了B方法的锁标志
那么t1会等待t2释放方法B的锁标志，t2也在等待t1释放方法A的锁标志，这样就形成了死锁，都在等待....
Ⅶ JAVA多线程死锁问题
1. Java中导致死锁的原因
Java中死锁最简单的情况是，一个线程T1持有锁L1并且申请获得锁L2，而另一个线程T2持有锁L2并且申请获得锁L1，因为默认的锁申请操作都是阻塞的，所以线程T1和T2永远被阻塞了。导致了死锁。这是最容易理解也是最简单的死锁的形式。但是实际环境中的死锁往往比这个复杂的多。可能会有多个线程形成了一个死锁的环路，比如：线程T1持有锁L1并且申请获得锁L2，而线程T2持有锁L2并且申请获得锁L3，而线程T3持有锁L3并且申请获得锁L1，这样导致了一个锁依赖的环路：T1依赖T2的锁L2，T2依赖T3的锁L3，而T3依赖T1的锁L1。从而导致了死锁。
从这两个例子，我们可以得出结论，产生死锁可能性的最根本原因是：线程在获得一个锁L1的情况下再去申请另外一个锁L2，也就是锁L1想要包含了锁L2，也就是说在获得了锁L1，并且没有释放锁L1的情况下，又去申请获得锁L2，这个是产生死锁的最根本原因。另一个原因是默认的锁申请操作是阻塞的。
2. Java中如何避免死锁
既然我们知道了产生死锁可能性的原因，那么就可以在编码时进行规避。Java是面向对象的编程语言，程序的最小单元是对象，对象封装了数据和操作，所以Java中的锁一般也是以对象为单位的，对象的内置锁保护对象中的数据的并发访问。所以如果我们能够避免在对象的同步方法中调用其它对象的同步方法，那么就可以避免死锁产生的可能性。如下所示的代码，就存在死锁的可能性：
public class ClassB {
private String address;
// ...
public synchronized void method1(){
// do something
}
// ... ...
}
public class ClassA {
private int id;
private String name;
private ClassB b;
// ...
public synchronized void m1(){
// do something
b.method1();
}
// ... ...
}
上面的ClassA.m1()方法，在对象的同步方法中又调用了ClassB的同步方法method1()，所以存在死锁发生的可能性。我们可以修改如下，避免死锁：
public class ClassA {
private int id;
private String name;
private ClassB b;
// ...
public void m2(){
synchronized(this){
// do something
}
b.method1();
}
// ... ...
}
这样的话减小了锁定的范围，两个锁的申请就没有发生交叉，避免了死锁的可能性，这是最理性的情况，因为锁没有发生交叉。但是有时是不允许我们这样做的。此时，如果只有ClassA中只有一个m1这样的方法，需要同时获得两个对象上的锁，并且不会将实例属性 b 溢出(return b;)，而是将实例属性 b 封闭在对象中，那么也不会发生死锁。因为无法形成死锁的闭环。但是如果ClassA中有多个方法需要同时获得两个对象上的锁，那么这些方法就必须以相同的顺序获得锁。
比如银行转账的场景下，我们必须同时获得两个账户上的锁，才能进行操作，两个锁的申请必须发生交叉。这时我们也可以打破死锁的那个闭环，在涉及到要同时申请两个锁的方法中，总是以相同的顺序来申请锁，比如总是先申请 id 大的账户上的锁 ，然后再申请 id 小的账户上的锁，这样就无法形成导致死锁的那个闭环。
public class Account {
private int id; // 主键
private String name;
private double balance;
public void transfer(Account from, Account to, double money){
if(from.getId() > to.getId()){
synchronized(from){
synchronized(to){
// transfer
}
}
}else{
synchronized(to){
synchronized(from){
// transfer
}
}
}
}
public int getId() {
return id;
}
}
这样的话，即使发生了两个账户比如 id=1的和id=100的两个账户相互转账，因为不管是哪个线程先获得了id=100上的锁，另外一个线程都不会去获得id=1上的锁(因为他没有获得id=100上的锁)，只能是哪个线程先获得id=100上的锁，哪个线程就先进行转账。这里除了使用id之外，如果没有类似id这样的属性可以比较，那么也可以使用对象的hashCode()的值来进行比较。
上面我们说到，死锁的另一个原因是默认的锁申请操作是阻塞的，所以如果我们不使用默认阻塞的锁，也是可以避免死锁的。我们可以使用ReentrantLock.tryLock()方法，在一个循环中，如果tryLock()返回失败，那么就释放以及获得的锁，并睡眠一小段时间。这样就打破了死锁的闭环。
比如：线程T1持有锁L1并且申请获得锁L2，而线程T2持有锁L2并且申请获得锁L3，而线程T3持有锁L3并且申请获得锁L1
此时如果T3申请锁L1失败，那么T3释放锁L3，并进行睡眠，那么T2就可以获得L3了，然后T2执行完之后释放L2, L3，所以T1也可以获得L2了执行完然后释放锁L1, L2，然后T3睡眠醒来，也可以获得L1, L3了。打破了死锁的闭环。
这些情况，都还是比较好处理的，因为它们都是相关的，我们很容易意识到这里有发生死锁的可能性，从而可以加以防备。很多情况的场景都不会很明显的让我们察觉到会存在发生死锁的可能性。所以我们还是要注意：
一旦我们在一个同步方法中，或者说在一个锁的保护的范围中，调用了其它对象的方法时，就要十而分的小心：
1）如果其它对象的这个方法会消耗比较长的时间，那么就会导致锁被我们持有了很长的时间；
2）如果其它对象的这个方法是一个同步方法，那么就要注意避免发生死锁的可能性了；
最好是能够避免在一个同步方法中调用其它对象的延时方法和同步方法。如果不能避免，就要采取上面说到的编码技巧，打破死锁的闭环，防止死锁的发生。同时我们还可以尽量使用“不可变对象”来避免锁的使用，在某些情况下还可以避免对象的共享，比如 new 一个新的对象代替共享的对象，因为锁一般是对象上的，对象不相同了，也就可以避免死锁，另外尽量避免使用静态同步方法，因为静态同步相当于全局锁。还有一些封闭技术可以使用：比如堆栈封闭，线程封闭，ThreadLocal，这些技术可以减少对象的共享，也就减少了死锁的可能性。
Ⅷ 求解java多线程的死锁
你这是同步锁，锁的是A对象。有线程跟你一样用 A对象当锁的时候 ，只会有一条线程 来执行 B。其他线程都得等待。
1.A区域究竟什么对象可以作为锁?
对象，类对象。类对象 全局只有一个 比如 A.class ，当有人用到 这个类对象的时候 就会将其锁住。不让其他线程进入。
2.是不是我在一个线程中将A这个对象作为锁,在另一个线程中对A这个对象进行操作,就会发生死锁?
死锁的根本原因1）是多个线程涉及到多个锁，这些锁存在着交叉，所以可能会导致了一个锁依赖的闭环；2）默认的锁申请操作是阻塞的。所以要避免死锁，就要在一遇到多个对象锁交叉的情况，就要仔细审查这几个对象的类中的所有方法，是否存在着导致锁依赖的环路的可能性。要采取各种方法来杜绝这种可能性。
你这样 锁不到的。举个例子 死锁 就是 x线程 锁住了 A对象 然后 调用B对象的方法，y线程 锁住了B对象调用A对象的方法，两边 都在互相尝试获取对方的锁，但是拿不到。因为 x锁住了A对象。y锁住了B对象。他们互相拿不到 就叫死锁。这只是个例子还有很多。
3不是说任何对象都可以作为一把锁吗?那么每一个锁我使用一个独立的成员对象作为锁,不就是可以很容易避开死锁吗？为什么说死锁很容易发生?
你每个锁用一个独立的成员对象作为锁，没问题，只要没有存在交叉。上面那个例子一样。
避免死锁是一件困难的事，遵循以下原则有助于规避死锁：
1、只在必要的最短时间内持有锁，考虑使用同步语句块代替整个同步方法；
2、尽量编写不在同一时刻需要持有多个锁的代码，如果不可避免，则确保线程持有第二个锁的时间尽量短暂；
3、创建和使用一个大锁来代替若干小锁，并把这个锁用于互斥，而不是用作单个对象的对象级别锁；
Ⅸ java线程死锁问题。。。。
你这个程序几乎瞬间就跑完了，构造不了下面这样一个死锁的情形：
第一个拿到 o2 锁准备去拿 o1 锁，另一个拿到 o1 锁准备去拿 o2 锁。
因为启动线程本身也都是需要一些准备工作的，这样第二线程启动开始跑的时候可能第一个线程已经跑完了，它们两个家伙根本不曾同时活在世上，哪来的缘分。
如果不加 sleep 就能死锁的话，你需要把现在 run() 方法里面的代码放进一个 for 循环，比如：
public void run() {
for(int i = 0; i < 1000; i++) {
// 把你原来的代码贴在这里。
}
}
Ⅹ java多线程死锁问题
public class Test520 {//测试类
public static void main(String[] args) {
Test1 t1=new Test1();//构造线程1
Test2 t2=new Test2();//构造线程2
t1.start();//启动线程1
t2.start();//启动线程2
}
}
class Test1 extends Thread{//线程类1
public void run() {//线程类1的run方法
synchronized (A.class) {//线程类1获取A类的锁
new A().a();//构建A类调用a方法，线程可以执行到这里
synchronized (B.class) {//线程1请求获取B类的锁，看后面的代码我们知道B类的锁在线程2中，形成死锁
new B().b();//构造B类，调用b方法，这语句无法执行，因线程1始终无法获得已被线程2获得的B类锁
}
}
}
}
class Test2 extends Thread{//线程类2
public void run() {//线程类2的run方法
synchronized (B.class) {//线程2获取了B类的锁，因此线程1无法在调用a方法后获取B类锁执行后面的语句
new A().a();//构造A类对象调用a方法，此语句可以执行
synchronized (A.class) {//线程2请求A类锁，A类锁此时被线程1持有
new B().b();//如果线程2能够获取A类锁，就能执行这一步，测试知道，无法执行到这句
}
}
}
}
class A{//测试类
public void a() {
System.out.println("a");
}
}
class B{//测试类
public void b() {
System.out.println("b");
}
}