use a Builder to create ConsistentHash<Node>

invoking add(Node, replica) for all nodes rebuild the internal Table many times. Using a builder, Table is only created (and sorted) once
also avoid creating a fresh new Hash object (java 8 lambdas, I miss you)

core/src/main/java/hudson/model/Queue.java

@@ -1073,16 +1073,18 @@ public class Queue extends ResourceController implements Saveable {
 
     private void makeBuildable(BuildableItem p) {
         if(Jenkins.FLYWEIGHT_SUPPORT && p.task instanceof FlyweightTask && !ifBlockedByHudsonShutdown(p.task)) {
-            ConsistentHash<Node> hash = new ConsistentHash<Node>(new Hash<Node>() {
-                public String hash(Node node) {
-                    return node.getNodeName();
-                }
-            });
+
+            ConsistentHash.Builder<Node> builder = new ConsistentHash.Builder<Node>(NODE_HASH);
+
             Jenkins h = Jenkins.getInstance();
             // Even if master is configured with zero executors, we may need to run a flyweight task like MatrixProject on it.
-            hash.add(h, Math.max(h.getNumExecutors()*100, 1));
-            for (Node n : h.getNodes())
-                hash.add(n, n.getNumExecutors()*100);
+            builder.add(h, Math.max(h.getNumExecutors() * 100, 1));
+
+            for (Node n : h.getNodes()) {
+                builder.add(n, n.getNumExecutors() * 100);
+            }
+
+            ConsistentHash<Node> hash = builder.build();
 
             Label lbl = p.getAssignedLabel();
             for (Node n : hash.list(p.task.getFullDisplayName())) {
@@ -1101,6 +1103,13 @@ public class Queue extends ResourceController implements Saveable {
         p.enter(this);
     }
 
+
+    private static Hash<Node> NODE_HASH = new Hash<Node>() {
+        public String hash(Node node) {
+            return node.getNodeName();
+        }
+    };
+
     private boolean makePending(BuildableItem p) {
         // LOGGER.info("Making "+p.task+" pending"); // REMOVE
         p.isPending = true;

core/src/main/java/hudson/util/ConsistentHash.java

@@ -201,13 +201,13 @@ public class ConsistentHash<T> {
     }
 
     public ConsistentHash(Hash<T> hash) {
-        this(hash,100);
+        this(hash, 100);
     }
 
     public ConsistentHash(Hash<T> hash, int defaultReplication) {
         this.hash = hash;
         this.defaultReplication = defaultReplication;
-        this.table = new Table(); // initial empty table
+        refreshTable();
     }
 
     public int countAllPoints() {
@@ -244,7 +244,7 @@ public class ConsistentHash<T> {
      * Removes the node entirely. This is the same as {@code add(node,0)}
      */
     public void remove(T node) {
-        add(node,0);
+        add(node, 0);
     }
 
     /**
@@ -254,6 +254,11 @@ public class ConsistentHash<T> {
      * This is the only function that manipulates {@link #items}.
      */
     public synchronized void add(T node, int replica) {
+        addInternal(node, replica);
+        refreshTable();
+    }
+
+    private void addInternal(T node, int replica) {
         if(replica==0) {
             items.remove(node);
         } else {
@@ -263,9 +268,13 @@ public class ConsistentHash<T> {
                 points[i] = new Point(md5(seed+':'+i),node);
             items.put(node,points);
         }
+    }
+
+    private void refreshTable() {
         table = new Table();
     }
 
+
     /**
      * Compresses a string into an integer with MD5.
      */
@@ -335,4 +344,24 @@ public class ConsistentHash<T> {
     public Iterable<T> list(String queryPoint) {
         return list(md5(queryPoint));
     }
+
+    public static class Builder<T> {
+
+        final ConsistentHash<T> c;
+
+        public Builder(Hash hash) {
+            c = new ConsistentHash<T>(hash);
+        }
+
+        public Builder add(T node, int replica) {
+            c.addInternal(node, replica);
+            return this;
+        }
+
+        public ConsistentHash<T> build() {
+            c.refreshTable();
+            return c;
+        }
+    }
+
 }