浅谈线程死锁

死锁是指两个或两个以上的线程在执行过程中，由于竞争同步锁而产生的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的线程称为死锁。
锁案例：

public class LockR1 {

public static LockR1 r1 = new LockR1();

}

public class LockR2 {

public static LockR2 r2 = new LockR2();

}
public class DeadLock implements Runnable {

private boolean flag;
public DeadLock(boolean flag){
    this.flag = flag;
}
public void run() {
    while (true){
        if(flag){
            synchronized (LockR1.r1){
                System.out.println("if...获取r1锁");
                synchronized (LockR2.r2)
                    System.out.println("if...获取r2锁");
                }
            }
        }else{
           
            synchronized (LockR2.r2){
                System.out.println("else...获取r2锁");
              synchronized (LockR1.r1){
                    System.out.println("else...获取r1锁");
                }
            }
        }
    }
}

}

public class DeadLockTest {

public static void main(String[] args) {
    DeadLock d1 = new DeadLock(true);
    DeadLock d2 = new DeadLock(false);

    Thread t1 = new Thread(d1);
    Thread t2 = new Thread(d2);

    t1.start();
    t2.start();
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
线程同步-概念,synchronized,锁对象的选择，锁池状态：
同步代码块：线程操作的共享数据进行同步。synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
同步方法：当一个方法中的所有代码，全部是线程操作的共享数据的时候，可以将整个方法进行同步。使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
购票系统：

public class Ticket implements Runnable {

private int ticket = 100;

@Override
public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while (true) {
        if (ticket > 0) {//有票 可以卖
            //出票操作
            //使用sleep模拟一下出票时间 
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //获取当前线程对象的名字 
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在卖:" + ticket--);
        }
    }
}

}
测试
public static void main(String[] args) {

//创建线程任务对象
Ticket ticket = new Ticket();
//创建三个窗口对象
Thread t1 = new Thread(ticket, "窗口1");
Thread t2 = new Thread(ticket, "窗口2");
Thread t3 = new Thread(ticket, "窗口3");

//同时卖票
t1.start();
t2.start();
t3.start();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
同步代码块

public class Ticket implements Runnable{

private int ticket = 100;
private Object lock = new Object();
/*
 * 执行卖票操作
 */
@Override
public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while(true){
        synchronized (lock) {
            if(ticket>0){//有票 可以卖
                //出票操作
                //使用sleep模拟一下出票时间 
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //获取当前线程对象的名字 
                String name = Thread.currentThread().getName();
                System.out.println(name+"正在卖:"+ticket--);
            }
        }
    }
}

}
同步方法

public class Ticket implements Runnable{
private int ticket = 100;
/*
 * 执行卖票操作
 */
@Override
public void run() {
    //每个窗口卖票的操作 
    //窗口 永远开启 
    while(true){
        sellTicket();
    }
} 
/*
 * 锁对象 是 谁调用这个方法 就是谁 
 *   隐含 锁对象 就是  this
 *    
 */
public synchronized void sellTicket(){
    if(ticket>0){//有票 可以卖    
        //出票操作
        //使用sleep模拟一下出票时间 
        try {
              Thread.sleep(100);
        } catch (InterruptedException e) {
              e.printStackTrace();
        }
        //获取当前线程对象的名字 
        String name = Thread.currentThread().getName();
        System.out.println(name+"正在卖:"+ticket--);
    }
}

}

谢谢！