多进程调用共享资源 - 逻辑时钟+广播算法实现

本文主要参考Lamport算法,是对多进程调用共享资源算法的一个具体实现.业务场景为分布式中,使用dubbo调用后台某个服务,该服务部署有多个,服务中有对hdfs写的操作,要知道hdfs每次只支持一个客户端去写,所以这就是个多进程互斥访问共有资源的问题.下面是主要实现代码,具体业务可根据使用场景做调整:

public class WriteHDFS {

    //本地用一个LinkedHashMap做时间戳存储
    private static TreeMap<Long, String> queue = new TreeMap<Long, String>();
    //每个服务初始化序号为0
    private static long num = 0;
    //最长心跳间隔
    private static int MAX_TIME = 10000;
    private static Date time1 = null;
    private static Date time2 = null;
    static Consumer statToHdfs = null;

    public static void WriteHdfs(StatService statService, UserService userService) throws Exception {
        //服务所在主机地址
        String local = InetAddress.getLocalHost().getHostAddress();

        InetAddress ip = InetAddress.getByName("255.255.255.255");
        DatagramSocket sendDs = new DatagramSocket();
        //将本地序号,ip封装后广播发送
        HashMap<Long, String> sendMap = new HashMap<Long, String>();

        /**
         * 接收广播线程,更新序号
         */
        new Thread(new Runnable(){
            @Override
            public void run() {
                //接收广播,将序号更新
                DatagramSocket recvDs = null;
                try {
                    recvDs = new DatagramSocket(8888);
                    byte[] buf = new byte[1024];
                    DatagramPacket recvDp = new DatagramPacket(buf, buf.length);
                    recvDs.receive(recvDp);
                    String revStr = recvDp.getData().toString();
                    JSONObject data = JSONObject.parseObject(revStr);
                    if (data.containsKey("startData") || data.containsKey("endData")) {
                        @SuppressWarnings("unchecked")
                        HashMap<Integer, String> revMap = (HashMap<Integer, String>) data.get("startData");
                        //遍历revMap,并放入本地队列
                        for(Integer key:revMap.keySet()) {
                            if (num <= key)
                                num = key;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    recvDs.close();
                }
            }
        }).start();

        /**
         * 发送广播线程,更新队列
         */
        new Thread(new Runnable(){
            @Override
            public void run() {
                //DatagramSocket sendDs = null;
                //当要获取资源时,序号自增1,并广播通知其他服务
                try {
                    num++;
                    sendMap.put(num, local);
                    JSONObject startObj = new JSONObject();
                    startObj.put("startData", sendMap);
                    String startStr = startObj.toJSONString();
                    DatagramPacket sendDp = new DatagramPacket(startStr.getBytes(),startStr.getBytes().length, ip, 8888);
                    sendDs.send(sendDp);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

        /**
         * 接收广播,更新队列判断是否可以获取资源
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                //接收广播,并比较key-value,直到获取资源
                while(true) {

                    //比较queue中最小key和此时num,以及主机ip,如果相同则表示可以获得资源
                    if (queue.firstKey() == num && queue.get(queue.firstKey()) == local) {
                        // 开启将数据周期写入Hdfs线程
                        //此处为写hdfs业务逻辑,已省略xxxxxxx

                        //queue移除首元素
                        queue.remove(queue.firstKey());
                        //资源释放,广播通知其他服务
                        JSONObject endObj = new JSONObject();
                        endObj.put("endData", sendMap);
                        String endStr = endObj.toJSONString();
                        DatagramPacket freeDp = new DatagramPacket(endStr.getBytes(),endStr.getBytes().length, ip, 8888);
                        try {
                            sendDs.send(freeDp);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        sendDs.close();
                        break;
                    }

                    DatagramSocket ds = null;
                    try {
                        ds = new DatagramSocket(8888);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    byte[] bf = new byte[1024];
                    DatagramPacket dp = new DatagramPacket(bf, bf.length);
                    try {
                        ds.receive(dp);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    String str = dp.getData().toString();
                    JSONObject obj = JSONObject.parseObject(str);
                    if (obj.containsKey("startData")) {
                        @SuppressWarnings("unchecked")
                        HashMap<Long, String> revMap = (HashMap<Long, String>) obj.get("startData");
                        //遍历revMap,并放入本地队列
                        for(Long key:revMap.keySet()) {

                            if (!queue.containsKey(key)) {
                                queue.put(key, revMap.get(key));
                                //建立和正在使用资源服务的心跳连接,如果挂掉就从队列删除key-value
                                Timer timer = new Timer();
                                timer.scheduleAtFixedRate(new TimerTask() {
                                    @Override
                                    public void run() {
                                        //向正在使用资源的服务发送心跳包
                                        try {
                                            @SuppressWarnings("resource")
                                            DatagramSocket reqSocket = new DatagramSocket();
                                            JSONObject reqObj = new JSONObject();
                                            reqObj.put("requestData", local);
                                            String reqStr = reqObj.toJSONString();
                                            DatagramPacket reqDp = new DatagramPacket(reqStr.getBytes(),
                                                    reqStr.getBytes().length, new InetSocketAddress(revMap.get(key), 8888));
                                            reqSocket.send(reqDp);
                                            time1 = new Date();
                                        } catch (Exception e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }, 1000, 3000);
                                if(time1 != null && time2 != null && Math.abs(time1.getTime() - time2.getTime())/1000 > MAX_TIME) {
                                    queue.remove(key);
                                }
                            }

                        }
                    }
                    if (obj.containsKey("requestData")) {
                        String reqHost = (String) obj.get("requestData");
                        try {
                            @SuppressWarnings("resource")
                            DatagramSocket repSocket = new DatagramSocket();
                            JSONObject repObj = new JSONObject();
                            repObj.put("reponseData", local);
                            String repStr = repObj.toJSONString();
                            DatagramPacket repDp = new DatagramPacket(repStr.getBytes(),
                                    repStr.getBytes().length, new InetSocketAddress(reqHost, 8888));
                            repSocket.send(repDp);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    if (obj.containsKey("reponseData")) {
                        time2 = new Date();
                    }
                    if (obj.containsKey("endData")) {
                        @SuppressWarnings("unchecked")
                        HashMap<Long, String> revMap = (HashMap<Long, String>) obj.get("endData");
                        //遍历revMap,从本地队列删除对应key-value
                        for(Long key:revMap.keySet()) {
                            if (queue.containsKey(key))
                                queue.remove(key);
                        }
                    }

                }
            }
        }).start(); 
    }   
}

需要用三个线程实现,主要原因是接受广播的方法是阻塞的.一个线程用来发送广播,一个用来接收广播,最后一个用来判断本地队列是否获取资源,如果为否则继续接收广播更新队列;队列用TreeMap顺序存储,如果获取资源的服务挂掉则可以通过心跳判断来更新本地队列;