집 > 기사 > Java > Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

WBOY앞으로: 2023-05-09 17:10:081310검색

Problem Demonstration

polling lock을 사용하지 않았을 때 이런 문제가 발생할 수 있습니다.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class DeadLockByReentrantLock {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockA.lock(); // 加锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    lockB.lock(); // 加锁
                    try {
                        System.out.println("线程 1:获取到锁 B!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                }
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }
}

위 코드의 실행 결과는 다음과 같습니다.

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

위 결과에서 알 수 있듯이, 이때 프로그램에서는 스레드들이 서로를 기다리다가 서로의 (잠금) 자원을 얻으려고 하는 상황이 발생합니다. 이는 전형적인 교착 상태 문제입니다.

폴링 잠금의 간단한 버전

교착 상태 문제가 발생하면 폴링 잠금을 사용하여 이를 해결할 수 있습니다. 구현 아이디어는 중간에 잠금이 있는 경우 폴링을 통해 여러 잠금을 얻는 것입니다. 롤백 작업, 현재 스레드가 소유한 모든 잠금을 해제하고 다음 재실행을 기다립니다. 이렇게 하면 여러 스레드가 동시에 잠금 리소스를 소유하고 점유하는 것을 방지할 수 있으므로 교착 상태 문제를 직접 해결할 수 있습니다. 폴링 잠금은 다음과 같습니다.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SolveDeadLockExample2 {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    private static void pollingLock(Lock lockA, Lock lockB) {
        // 轮询锁
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }
            // 等待一秒再继续执行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

위 코드의 실행 결과는 다음과 같습니다.

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

위 결과에서 알 수 있듯이 프로그램에서 폴링 잠금을 사용하면 폴링 잠금이 발생하지 않습니다. 교착상태 문제가 있지만 위의 폴링 잠금은 완벽하지 않습니다. 이 폴링 잠금에는 어떤 문제가 있는지 살펴보겠습니다.

문제 1: 무한 루프

위의 간단한 폴링 잠금 버전을 사용하면 스레드가 계속해서 잠금 리소스를 점유하거나 오랫동안 잠금 리소스를 점유하면 폴링 잠금이 무한 루프 상태에 들어가게 됩니다. , 잠금 리소스를 계속 획득하려고 시도하며 이로 인해 새로운 문제와 불필요한 성능 오버헤드가 발생합니다. 구체적인 예는 다음과 같습니다.

카운터 예시

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SolveDeadLockExample {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 如果此处代码未执行，线程 2 一直未释放锁资源
                    // lockB.unlock(); 
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    public static void pollingLock(Lock lockA, Lock lockB) {
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }
            // 等待一秒再继续执行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

위 코드의 실행 결과는 다음과 같습니다.

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

위 결과에서 알 수 있듯이 Thread 1 Polling Lock은 무한 루프 상태에 들어갔습니다.

최적화된 버전

위의 무한 루프 상황에 대응하여 다음 두 가지 아이디어를 개선할 수 있습니다.

최대 개수 제한 추가: n번 잠금 획득 시도 이후 잠금이 해제되지 않음 아직 잠금을 획득하지 못한 경우 잠금 획득에 실패한 것으로 간주되며 실패 전략을 실행한 후 폴링이 종료됩니다(실패 전략은 로깅 또는 기타 작업일 수 있음)
최대 시간 제한 추가: n 잠금을 획득하려고 시도한 후 초가 경과한 경우 폴링이 수행되지 않습니다. 잠금을 획득한 경우 잠금 획득에 실패한 것으로 간주하고 실패 정책이 실행된 후 폴링을 종료합니다.

무한 루프 문제를 해결하려면 위 전략 중 하나를 선택하세요. 구현 비용을 위해 최대 횟수를 폴링하여 폴링 잠금을 개선할 수 있습니다.

구체적인 구현 코드는 다음과 같습니다.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockB.lock(); // 加锁
                System.out.println("线程 2:获取到锁 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 2:等待获取 A...");
                    lockA.lock(); // 加锁
                    try {
                        System.out.println("线程 2:获取到锁 A!");
                    } finally {
                        lockA.unlock(); // 释放锁
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 线程 2 忘记释放锁资源
                    // lockB.unlock(); // 释放锁
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     *
     * maxCount：最大轮询次数
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 轮询次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一秒再继续尝试获取锁
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

위 코드의 실행 결과는 다음과 같습니다.

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

위 결과를 보면 폴링 잠금을 개선하면 무한 루프 문제가 발생하지 않는다는 것을 알 수 있습니다. 특정 횟수만큼 시도한 후 실행을 종료합니다.

문제 2: 스레드 고갈

위 폴링 잠금의 폴링 대기 시간은 다음 코드에서 볼 수 있듯이 고정된 시간입니다.

// 等待 1s 再尝试获取（轮询）锁
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

이로 인해 특별한 상황에서 스레드 고갈 문제가 발생할 수 있습니다. 다음 예와 같이 폴링 잠금이 잠금을 얻을 수 없는 문제입니다.

카운터 예시

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } finally {
                        lockB.unlock(); // 释放锁
                    }
                    // 等待一秒之后继续执行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循环次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(获取锁需要的时间)
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一秒再继续尝试获取锁
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

위 코드의 실행 결과는 다음과 같습니다.

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

위 결과에서 알 수 있듯이 스레드 1(폴링 잠금)이 성공적으로 잠금을 획득하지 못한 이유입니다. 결과는 다음과 같습니다. 스레드 1 각 폴의 대기 시간은 1초로 고정되고 스레드 2도 동일한 빈도를 가지며 1초마다 잠금을 획득합니다. 이로 인해 스레드 2는 항상 잠금을 먼저 성공적으로 획득하지만 스레드 1은 항상 잠금을 획득합니다. "배고프다". "dead"인 경우

실행 프로세스는 아래 그림과 같습니다.

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?

최적화된 버전

다음으로 폴링 잠금의 고정 대기 시간을 고정으로 개선할 수 있습니다. time + Random time

, 이는 동일한 잠금 획득 빈도로 인한 폴링 잠금의 "기아" 문제를 피할 수 있습니다. 구체적인 구현 코드는 다음과 같습니다.

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SolveDeadLockExample {
    private static Random rdm = new Random();

    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 创建锁 A
        Lock lockB = new ReentrantLock(); // 创建锁 B

        // 创建线程 1(使用轮询锁)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 调用轮询锁
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 运行线程

        // 创建线程 2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    lockB.lock(); // 加锁
                    System.out.println("线程 2:获取到锁 B!");
                    try {
                        System.out.println("线程 2:等待获取 A...");
                        lockA.lock(); // 加锁
                        try {
                            System.out.println("线程 2:获取到锁 A!");
                        } finally {
                            lockA.unlock(); // 释放锁
                        }
                    } finally {
                        lockB.unlock(); // 释放锁
                    }
                    // 等待一秒之后继续执行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 运行线程
    }

    /**
     * 轮询锁
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循环次数计数器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 尝试获取锁
                System.out.println("线程 1:获取到锁 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(获取锁需要的时间)
                    System.out.println("线程 1:等待获取 B...");
                    if (lockB.tryLock()) { // 尝试获取锁
                        try {
                            System.out.println("线程 1:获取到锁 B!");
                        } finally {
                            lockB.unlock(); // 释放锁
                            System.out.println("线程 1:释放锁 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 释放锁
                    System.out.println("线程 1:释放锁 A.");
                }
            }

            // 判断是否已经超过最大次数限制
            if (count++ > maxCount) {
                // 终止循环
                System.out.println("轮询锁获取失败,记录日志或执行其他失败策略");
                return;
            }

            // 等待一定时间(固定时间 + 随机时间)之后再继续尝试获取锁
            try {
                Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定时间 + 随机时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

위 코드의 실행 결과는 다음과 같습니다.

Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까? 위 결과에서 스레드 1(폴링 잠금)이 임의 대기 시간을 추가한 후에는 스레드 기아 문제가 발생하지 않음을 알 수 있습니다.

위 내용은 Java에서 폴링 잠금을 사용할 때 문제를 해결하는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명：

이 기사는 yisu.com에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제

이전 기사：Java 프록시 패턴의 분석 예시입니다.다음 기사：Java 프록시 패턴의 분석 예시입니다.