Java – Dequeのマルチスレッド処理でデッドロックを回避する方法

Thread 1: lock1を取得しました。
Thread 1: lock2を取得しました。
Thread 2: lock1を取得しました。
Thread 2: lock2を取得しました。

import java.util.concurrent.ConcurrentLinkedQueue;
public class App {
    private static final ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                String item = "アイテム " + i;
                queue.offer(item); // 非ブロッキングでアイテムを追加
                System.out.println("Producer: " + item + "を追加しました。");
                try {
                    Thread.sleep(100); // 一時停止
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                String item = queue.poll(); // 非ブロッキングでアイテムを取得
                if (item != null) {
                    System.out.println("Consumer: " + item + "を取得しました。");
                } else {
                    System.out.println("Consumer: 取得するアイテムがありません。");
                }
                try {
                    Thread.sleep(150); // 一時停止
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
        consumer.start();
    }
}

Consumer: 取得するアイテムがありません。
Producer: アイテム 0を追加しました。
Producer: アイテム 1を追加しました。
Consumer: アイテム 0を取得しました。
Producer: アイテム 2を追加しました。
Consumer: アイテム 1を取得しました。
Producer: アイテム 3を追加しました。
Producer: アイテム 4を追加しました。
Consumer: アイテム 2を取得しました。
Consumer: アイテム 3を取得しました。

  jstack <プロセスID>

import java.util.concurrent.locks.ReentrantLock;

public class App {
    private static final ReentrantLock lock1 = new ReentrantLock();
    private static final ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock()) { // lock1を取得
                    System.out.println("Thread 1: lock1を取得しました。");
                    Thread.sleep(100); // 一時停止
                    if (lock2.tryLock()) { // lock2を取得
                        System.out.println("Thread 1: lock2を取得しました。");
                    } else {
                        System.out.println("Thread 1: lock2を取得できませんでした。");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (lock1.isHeldByCurrentThread()) {
                    lock1.unlock(); // lock1を解放
                }
                if (lock2.isHeldByCurrentThread()) {
                    lock2.unlock(); // lock2を解放
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock()) { // lock2を取得
                    System.out.println("Thread 2: lock2を取得しました。");
                    Thread.sleep(100); // 一時停止
                    if (lock1.tryLock()) { // lock1を取得
                        System.out.println("Thread 2: lock1を取得しました。");
                    } else {
                        System.out.println("Thread 2: lock1を取得できませんでした。");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (lock2.isHeldByCurrentThread()) {
                    lock2.unlock(); // lock2を解放
                }
                if (lock1.isHeldByCurrentThread()) {
                    lock1.unlock(); // lock1を解放
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

Thread 1: lock1を取得しました。
Thread 2: lock2を取得しました。
Thread 1: lock2を取得できませんでした。
Thread 2: lock1を取得できませんでした。