sample code for simulating merging two nodes and a relationship in between in a concurrent safe way

mergeConnectedNodes.java

    private void mergeConnectedNodes(Label myLabel, RelationshipType relationshipType, String propertyKey, String valueA, String valueB) {
        try (Transaction tx = db.beginTx()) {

            // get or create start end node
            Node a = mergeAndLockNode(myLabel, propertyKey, valueA);
            Node b = mergeAndLockNode(myLabel, propertyKey, valueB);
            grabLocksInConsistentOrder(tx, a,b);


            boolean aIsCheaper = a.getDegree(relationshipType) < b.getDegree(relationshipType);
            Node cheaperNode = aIsCheaper ? a : b;
            Node otherNode = aIsCheaper ? b : a;

            if (!hasRelationshipBetween(cheaperNode, otherNode, relationshipType)) {
                cheaperNode.createRelationshipTo(otherNode, relationshipType);
            }
            tx.success();
        }
    }

    private boolean hasRelationshipBetween(Node cheaperNode, Node otherNode, RelationshipType relationshipType) {
        boolean result = false;
        for (Relationship r : cheaperNode.getRelationships(relationshipType)) { // consider direction here if reltype is directional in real life
            if (r.getOtherNode(cheaperNode).equals(otherNode)) {
                return true;
            }
        }
        return result;
    }

    private Node mergeAndLockNode(Label myLabel, String propertyKey, Object propertyValue) {
        Node node = db.findNode(myLabel, propertyKey, propertyValue);
        if (node == null) {
            node = db.createNode(myLabel);
            node.setProperty(propertyKey, propertyValue);
        }
        return node;
    }

    private void grabLocksInConsistentOrder(Transaction tx, Node... nodes) {
        SortedMap<Long, Node> orderedNodesById = new TreeMap<>();
        for (Node node : nodes) {
            orderedNodesById.put(node.getId(), node);
        }
        for (Node node: orderedNodesById.values()) {
            tx.acquireWriteLock(node);
        }
    }