九、curator recipes之不可重入锁InterProcessSemaphoreMutex

最新推荐文章于 2024-08-08 16:08:16 发布

转载最新推荐文章于 2024-08-08 16:08:16 发布 · 426 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/lay2017/p/10274906.html

文章标签：

#大数据

本文深入探讨了recipes的InterProcessSemaphoreMutex，一种不可重入的互斥锁，详细解释了其工作原理，如何避免死锁，以及在多线程环境下使用时的注意事项。通过具体的Java代码示例，演示了如何在实际项目中应用这种锁。

简介

recipes的InterProcessSemaphoreMutex是一种不可重入的互斥锁，也就意味着即使是同一个线程也无法在持有锁的情况下再次获得锁，所以需要注意，不可重入的锁很容易在一些情况导致死锁，比如你写了一个递归。

官方文档：http://curator.apache.org/curator-recipes/shared-lock.html

javaDoc：http://curator.apache.org/curator-recipes/shared-lock.html

代码示例

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessSemaphoreMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class SemaphoreMutexDemo {
    private static CuratorFramework client = CuratorFrameworkFactory.newClient("localhost:2181", new ExponentialBackoffRetry(3000, 3));
    private static String path = "/locks/semaphore/0001";
    static {
        client.start();
    }

    public static void main(String[] args) throws Exception {
        startThread0();
        Thread.sleep(10);
        startThread1();
        Thread.sleep(50000);
        client.close();
    }

    private static void startThread0() {
        new Thread(() -> {
            InterProcessSemaphoreMutex lock = new InterProcessSemaphoreMutex(client, path);
            try {
                System.out.println("thread0 acquiring");
                lock.acquire();
                System.out.println("thread0 acquired");
                System.out.println("thread0 sleep for 3s");
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    lock.release();
                    System.out.println("thread0 release");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    private static void startThread1() {
        new Thread(() -> {
            InterProcessSemaphoreMutex lock = new InterProcessSemaphoreMutex(client, path);
            try {
                System.out.println("thread1 acquiring");
                lock.acquire();
                System.out.println("thread1 acquired");
                System.out.println("thread1 sleep for 3s");
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    lock.release();
                    System.out.println("thread1 release");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}