死锁

死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成一种互相等待的现象，若无外力作用，它们都将无法继续下去。

常见的死锁情况有以下几种：

1. 同时申请多个资源，在不释放资源的情况下等待其他资源，相互之间形成死循环。
2. 循环等待。一个进程等待其他进程所占用的资源，而这些进程也在等待该进程已经占用的资源。

预防死锁

1. 尽量避免一个进程同时申请多个资源。
2. 破除占有并等待条件。一旦一个进程占有了一个资源，却又申请了另一个资源而不能立即得到，则该进程应释放已占有的资源。
3. 破除循环等待条件。预防死锁的最好方法是对系统资源进行合理分配和调度，以免进程发生死锁。

处理死锁

当死锁出现时，常见的处理方式有以下几种：

1. 撤销进程。把部分进程全部撤销，直至撤销了造成死锁的进程。
2. 撤销资源。将某个或几个占用资源的进程的资源收回，让他们去争夺其他资源。
3. 进行回滚操作。当一个事务发生死锁后，可以通过回滚操作来回到初始状态。

示例代码

class DeadLock implements Runnable {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    private int number;

    public DeadLock(int number) {
        this.number = number;
    }

    @Override
    public void run() {
        if (number == 1) {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                }

                System.out.println("Thread 1: Waiting for lock 2...");

                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 and 2...");
                }
            }
        } else {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                }

                System.out.println("Thread 2: Waiting for lock 1...");

                synchronized (lock1) {
                    System.out.println("Thread 2: Holding lock 1 and 2...");
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new DeadLock(1));
        Thread t2 = new Thread(new DeadLock(2));
        t1.start();
        t2.start();
    }
}

上述代码是一个死锁的示例，其中两个线程分别占用了两个共享资源，但是它们的请求顺序不一样，导致了死锁。可以通过调整它们的请求顺序避免死锁。