using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AspNetCore.ZookeeperConsole
{
    /// <summary>
    /// 基于Zookeeper的分布式鎖
    /// </summary>
    public class ZookeeperLocker : IDisposable
    {
        /// <summary>
        /// 單點(diǎn)鎖
        /// </summary>
        static object locker = new object();
        /// <summary>
        /// Zookeeper集群地址
        /// </summary>
        string[] address;
        /// <summary>
        /// Zookeeper操作輔助類
        /// </summary>
        ZookeeperHelper zookeeperHelper;

        /// <summary>
        /// 構(gòu)造函數(shù)
        /// </summary>
        /// <param name="lockerPath">分布式鎖的根路徑</param>
        /// <param name="address">集群地址</param>
        public ZookeeperLocker(string lockerPath, params string[] address) : this(lockerPath, 0, address)
        {
        }
        /// <summary>
        /// 構(gòu)造函數(shù)
        /// </summary>
        /// <param name="lockerPath">分布式鎖的根路徑</param>
        /// <param name="sessionTimeout">回話過期時(shí)間</param>
        /// <param name="address">集群地址</param>
        public ZookeeperLocker(string lockerPath, int sessionTimeout, params string[] address)
        {
            this.address = address.ToArray();

            zookeeperHelper = new ZookeeperHelper(address, lockerPath);
            if (sessionTimeout > 0)
            {
                zookeeperHelper.SessionTimeout = sessionTimeout;
            }
            if (!zookeeperHelper.Connect())
            {
                throw new Exception("connect failed:" + string.Join(",", address));
            }
            lock (locker)
            {
                if (!zookeeperHelper.Exists())//根節(jié)點(diǎn)不存在則創(chuàng)建
                {
                    zookeeperHelper.SetData("", "", true);
                }
            }
        }
        /// <summary>
        /// 生成一個(gè)鎖
        /// </summary>
        /// <returns>返回鎖名</returns>
        public string CreateLock()
        {
            var path = Guid.NewGuid().ToString().Replace("-", "");
            while (zookeeperHelper.Exists(path))
            {
                path = Guid.NewGuid().ToString().Replace("-", "");
            }
            return CreateLock(path);
        }
        /// <summary>
        /// 使用指定的路徑名稱設(shè)置鎖
        /// </summary>
        /// <param name="path">鎖名，不能包含路徑分隔符（/）</param>
        /// <returns>返回鎖名</returns>
        public string CreateLock(string path)
        {
            if (path.Contains("/"))
            {
                throw new ArgumentException("invalid path");
            }
            return zookeeperHelper.SetData(path, "", false, true);
        }
        /// <summary>
        /// 獲取鎖
        /// </summary>
        /// <param name="path">鎖名</param>
        /// <returns>如果獲得鎖返回true，否則一直等待</returns>
        public bool Lock(string path)
        {
            return LockAsync(path).GetAwaiter().GetResult();
        }
        /// <summary>
        /// 獲取鎖
        /// </summary>
        /// <param name="path">鎖名</param>
        /// <param name="millisecondsTimeout">超時(shí)時(shí)間，單位：毫秒</param>
        /// <returns>如果獲得鎖返回true，否則等待指定時(shí)間后返回false</returns>
        public bool Lock(string path, int millisecondsTimeout)
        {
            return LockAsync(path, millisecondsTimeout).GetAwaiter().GetResult();
        }
        /// <summary>
        /// 異步獲取鎖等等
        /// </summary>
        /// <param name="path">鎖名</param>
        /// <returns>如果獲得鎖返回true，否則一直等待</returns>
        public async Task<bool> LockAsync(string path)
        {
            return await LockAsync(path, System.Threading.Timeout.Infinite);
        }
        /// <summary>
        /// 異步獲取鎖等等
        /// </summary>
        /// <param name="path">鎖名</param>
        /// <param name="millisecondsTimeout">超時(shí)時(shí)間，單位：毫秒</param>
        /// <returns>如果獲得鎖返回true，否則等待指定時(shí)間后返回false</returns>
        public async Task<bool> LockAsync(string path, int millisecondsTimeout)
        {
            var array = await zookeeperHelper.GetChildrenAsync("", true);
            if (array != null && array.Length > 0)
            {
                var first = array.FirstOrDefault();
                if (first == path)//正好是優(yōu)先級(jí)最高的，則獲得鎖
                {
                    return true;
                }

                var index = array.ToList().IndexOf(path);
                if (index > 0)
                {
                    //否則添加監(jiān)聽
                    var are = new AutoResetEvent(false);
                    var watcher = new NodeWatcher();
                    watcher.NodeDeleted += (ze) =>
                    {
                        are.Set();
                    };
                    if (await zookeeperHelper.WatchAsync(array[index - 1], watcher))//監(jiān)聽順序節(jié)點(diǎn)中的前一個(gè)節(jié)點(diǎn)
                    {
                        if (!are.WaitOne(millisecondsTimeout))
                        {
                            return false;
                        }
                    }

                    are.Dispose();
                }
                else
                {
                    throw new InvalidOperationException($"no locker found in path:{zookeeperHelper.CurrentPath}");
                }
            }
            return true;
        }
        /// <summary>
        /// 釋放資源
        /// </summary>
        public void Dispose()
        {
            zookeeperHelper.Dispose();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace AspNetCore.ZookeeperConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            //Zookeeper連接字符串，采用host:port格式，多個(gè)地址之間使用逗號(hào)（,）隔開
            string[] address = new string[] { "192.168.209.133:2181", "192.168.209.133:2181", "192.168.209.133:2181" };
            //會(huì)話超時(shí)時(shí)間,單位毫秒
            int sessionTimeOut = 10000;
            //鎖節(jié)點(diǎn)根路徑
            string lockerPath = "/Locker";

            for (var i = 0; i < 10; i++)
            {
                string client = "client" + i;
                //多線程模擬并發(fā)
                new Thread(() =>
                {
                    using (ZookeeperLocker zookeeperLocker = new ZookeeperLocker(lockerPath, sessionTimeOut, address))
                    {
                        string path = zookeeperLocker.CreateLock();
                        if (zookeeperLocker.Lock(path))
                        {
                            //模擬處理過程
                            Console.WriteLine($"【{client}】獲得鎖:{DateTime.Now}");
                            Thread.Sleep(3000);
                            Console.WriteLine($"【{client}】處理完成:{DateTime.Now}");
                        }
                        else
                        {
                            Console.WriteLine($"【{client}】獲得鎖失敗:{DateTime.Now}");
                        }
                    }
                }).Start();
            }
                        
            Console.ReadKey();
        }
    }
}