Alter rate limiting approach to be better in multi-threaded contexts

src/main/java/is/swan/mcmarketapi/request/Client.java

@@ -1,14 +1,17 @@
 package is.swan.mcmarketapi.request;
 
 import is.swan.mcmarketapi.Token;
+import is.swan.mcmarketapi.request.Request.Method;
 import is.swan.mcmarketapi.utils.HTTPUtil;
 
 public class Client {
 
     private final Token token;
+    private final Throttler throttler;
 
     public Client(Token token) {
         this.token = token;
+        this.throttler = new Throttler();
     }
 
     public Response send(Request request) {
@@ -24,18 +27,33 @@ public Response send(Request request) {
     }
 
     public Response sendOrWait(Request request) {
-        Response response = getResponse(request);
-
-        while (response.isRatelimited()) {
+    	long stallFor;
+    	while ((stallFor = this.throttler.stallFor(request.getMethod())) > 0) {
             try {
-                Thread.sleep(response.getMillisecondsToWait());
+                Thread.sleep(stallFor);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
-
-            response = getResponse(request);
+    	}
+
+        Response response = getResponse(request);
+
+        if (response.isRatelimited()) {
+        	if (request.getMethod() == Method.GET) {
+        		throttler.setRead(response.getMillisecondsToWait());
+        	} else {
+        		throttler.setWrite(response.getMillisecondsToWait());	
+        	}
+
+        	return sendOrWait(request);
         }
 
+    	if (request.getMethod() == Method.GET) {
+    		throttler.resetRead();
+    	} else {
+    		throttler.resetWrite();
+    	}
+
         if (response.getError() != null) {
             return response;
         }

src/main/java/is/swan/mcmarketapi/request/Throttler.java

@@ -0,0 +1,54 @@
+package is.swan.mcmarketapi.request;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+import is.swan.mcmarketapi.request.Request.Method;
+
+public class Throttler {	
+	private final AtomicLong readLastRetry = new AtomicLong(0);
+	private final AtomicLong readLastRequest = new AtomicLong(System.currentTimeMillis());
+
+	private final AtomicLong writeLastRetry = new AtomicLong(0);
+	private final AtomicLong writeLastRequest = new AtomicLong(System.currentTimeMillis());
+
+	public long stallFor(Method method) {
+	    long time = System.currentTimeMillis();
+
+	    if (method == Method.GET) {
+    		return Throttler.stalForHelper(this.readLastRetry, this.readLastRequest, time);
+	    } else {
+    		return Throttler.stalForHelper(this.writeLastRetry, this.writeLastRequest, time);
+	    }
+	}
+
+	private static long stalForHelper(AtomicLong aLastRetry, AtomicLong aLastRequest, long time){
+	    long lastRetry = aLastRetry.getAcquire();
+	    long lastRequest = aLastRequest.getAcquire();
+
+	    if (lastRetry > 0 && (time - lastRequest) < lastRetry) {
+	        return lastRetry - (time - lastRequest);
+	    } else {
+	    	return 0;
+	    }
+	}
+
+	public void setRead(long value) {
+		readLastRetry.setRelease(value);
+		readLastRequest.setRelease(System.currentTimeMillis());
+	}
+
+	public void setWrite(long value) {
+		writeLastRetry.setRelease(value);
+		writeLastRequest.setRelease(System.currentTimeMillis());
+	}
+
+	public void resetRead() {
+		readLastRetry.setRelease(0);
+		readLastRequest.setRelease(System.currentTimeMillis());
+	}
+
+	public void resetWrite() {
+		writeLastRetry.setRelease(0);
+		writeLastRequest.setRelease(System.currentTimeMillis());
+	}
+}