多线程问题

张_涛

多线程中死锁是怎么回事？举两个案例详细讲讲

pphdsny3 · pphdsny3

public class DeadLockDemo {
public static void main(String[] args) {
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
while(true)
{
synchronized(MyLock.locka)
{
System.out.println(Thread.currentThread().getName()+"...if locka ");
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName()+"..if lockb");
}
}
}
}
else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName()+"..else lockb");
synchronized(MyLock.locka)
{
System.out.println(Thread.currentThread().getName()+".....else locka");
}
}
}
}
}
}

复制代码

在上面那代码中存在着两个锁locka和lockb，和两个线程t1，t2，当t1拿到locka锁，申请lockb锁，但是此时t2已经拿到lockb锁，而它也在申请locka锁，这时候他们分别都拿着对方锁要的锁不放，这样就就会一直僵持下去，就这样一直消耗着系统资源。这就形成了死锁

刘圣伟 · 刘圣伟

//死锁，代码
public class Deadlock {

private static boolean flase;

public static void main(String[] args) {
//
Thread a = new Thread(new Test(true));
Thread b = new Thread(new Test(flase));
a.start();
b.start();

}

}
//死锁例子代码
class Test implements Runnable{
static Object a=new Object();
static Object b = new Object();
private boolean flag;
Test(boolean flag){
this.flag=flag;
}
public void run(){
if (flag){
synchronized (a)//t1 进来，就锁上了，不过他再往下执行还需要B锁，才可以，
{
System.out.println("a lock ,需要B");
synchronized (b)
{
System.out.println("B lock ,需要A");
}
}
}
else{
synchronized (b)///t2 进来，就锁上了，不过他再往下执行还需要a锁，才可以
{
System.out.println("B lock ,需要A");
synchronized (a)
{
System.out.println("a lock ,需要B");
}
}

}
}
}

在多线程中，当我们嵌套使用，同步的，时候，就有可能出现，死锁的情况，
像例子中，
T1 进程需要 T2进程的锁，而T2需要T1的锁，
应为他们是同步代码块，所以，2个进程都需要，彼此的锁，但他们都不会放，会一直等待下去，就形成了死锁的情况，
当进程多的时候，嵌套锁就更容易，形成，死锁，
所有，我们同步代码的时候，不提倡，嵌套锁，
1.5 以后，也出现了，LOCK，显形锁（代码中可以看到的锁，）来替代，同步中看不到的锁，。更方便使用。

杨健yj · 杨健yj

产生死锁的原因是A锁和B锁互相等待，直接上代码

package test;
class Lock
{
public static void main(String[] args)
{
PersonA p1 = new PersonA("林青霞",20,1);
PersonA p2 = new PersonA("麦蒂",40,0);
Thread t1 = new Thread(p1);
Thread t2 = new Thread(p2);
t1.start();
t2.start();
t1.run();
t2.run();
}
}
class PersonA implements Runnable
{
//可以定义两个锁，为了保证唯一性这里定义为静态
static String a = new String("A锁");
static String b = new String("B锁");
String name;
int age;
int sexual;//0代表男人，1代表女人
public PersonA(String name,int age,int sexual)
{
this.name=name;
this.age=age;
this.sexual=sexual;
}
public void run()
{
while (true)
{
if (sexual>0)
{
synchronized(a)//t1进来上了a锁，
{
{
System.out.print("女人***");
}
synchronized(b)//此时b锁已被t2上了，就进不去了所以t1卡在这里
{
{
System.out.print(this.name);
System.out.print("--");
System.out.println(this.age);
}
}
}
}
else
{
synchronized(b)//t2进来上了b锁，
{
{
System.out.print("男人***");
}
synchronized(a)//此时a锁已被t1上了，就进不去了所以t2卡在这里；于是互相卡住
{
{
System.out.print(this.name);
System.out.print("--");
System.out.println(this.age);
}
}
}
}
}
}
}

复制代码

胡刚涛 · 胡刚涛

在多线程中，最容易出现死锁的案例就是，不是使用的同一把锁，比如如下代码：

public class TickDemo {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  Tick t=new Tick();
  Thread t1=new Thread(t);
  Thread t2=new Thread(t);
  t1.start();
  try {
Thread.sleep(10);
  } catch (Exception e) {
// TODO: handle exception
  }
  t.flag=false;
  t2.start();
}
}
class Tick implements Runnable{
private int tick=1000;
Object obj=new Object();
boolean flag=true;

public void run() {
  // TODO Auto-generated method stub
  if(flag){
while(true){
synchronized (obj) {
   show();//问题在这，当一个线程进来时拿到 obj的锁，调用show函数，但是shoe函数具备的是this的锁，就会出现死锁
}
}
  }
  else
while(true){
show();
}
}
public synchronized void show(){//这个是用的this锁
  synchronized (obj) {
if(tick>0){
try {
   Thread.sleep(10);
} catch (Exception e) {
   // TODO: handle exception
}
System.out.println(Thread.currentThread().getName()+"....."+tick--);
}
  }
}

}
看一下红色的文字，帮助你理解一下
如果不太清楚建议你看看毕老师的视频第十一天的15个视频关于死锁的一定会明白

张扬123 · 张扬123

class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag=flag;
}
public void run()
{
if (flag)
{
synchronized(MyLock.locka)[color=Red]a锁里面有b锁[/color]
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
else
{
synchronized(MyLock.lockb)[color=Red]b锁里面有a锁[/color]
{
System.out.println("else lockb");
synchronized(MyLock.locka)
{
System.out.println("else locka");
}
}
}
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
class DeadLockTest
{
public static void main(String[] args)
{
Thread t1=new Thread(new Test(true));
Thread t2=new Thread(new Test(false));
t1.start();
t2.start();
}
}

复制代码

两个锁相互要，就形成了死锁。就像买了杯豆浆，你拿着吸管，我拿着豆浆，你问我要豆浆，我问你要吸管，到最后咱俩谁都别喝。哈哈。

李菁 · 李菁

同一个应用程序需要并行处理多件任务，那就可以创建多个线程。但是线程多了，往往会出现冲突，使程序无法再进行下去了。这就是“死锁”。
举个例子，就像3个人在玩3个球。规则：每个人都必须先拿到自己左手边的球，才能拿自己右边的球，两手都有球之后，才能把球都放下。
如果三个人刚好都只拿到左手边的球，都等着拿右手边的球，但是因为谁都不能放手，所以三个人都在等待。这就造成了死锁

帐号		自动登录	找回密码
密码			加入黑马

多线程问题

评分

6 个回复

黑马骑士勋章