Example (lots of things going on in this algorithm. I simplified to just the key pieces for clarity.)
tuples are resources [memory] or [memory,cpu]
Queue Capacity is 
2 active users, both request  at a time
User1 is at 
User2 is at 
Limit is calculated to be 100/2=50, both users can allocate
User2 goes to  - now used Capacity is 45+50=95
Limit is still 50
User1 goes to  - used Capacity now 50+55=105
Limit is now 105/2
User2 goes to  - used Capacity is now 60+55=115
Limit is now 115/2
So on and so forth until maxCapacity is hit.
Notice how the users essentially leap frog one another, allowing the Limit to continually move higher.
memory and cpu
Queue Capacity is [100,100]
2 active users, User1 asks for [10,20], User2 asks for [20,10]
User1 is at [35,45]
User2 is at [45,35]
Limit is calculated to be [100/2=50,100/2=50], both users can allocate
User2 goes to [65,45] - used Capacity is now [65+35=100,45+45=90]
Limit is still [50,50]
User1 goes to [45,65] - used Capacity is now [65+45=110,45+65=110]
Limit is now [110/2=55, 110/2=55]
User1 and User2 are now both considered over limit and neither can allocate. User1 is over on cpu, User2 is over on memory.
Open to suggestions on simple ways to fix this. I'm currently thinking a reasonable (simple, effective, computationally cheap, mostly fair) approach might be to give some small percentage of additional leeway for userLimit.