Random vs ThreadLocalRandom vs SecureRandom vs RandomGenerator in Java (When to Use Each)
Which Java random class to use, tested on JDK 25: why two outputs of java.util.Random predict the third, the three range bugs (negative remainder, abs of MIN_VALUE, modulo bias measured at 60% vs 43%), ThreadLocalRandom vs a shared Random, SecureRandom algorithms and the setSeed trap, and the 13 RandomGenerator algorithms. Every output is quoted from a committed file.
You need a random number in Java. Your IDE offers Random, ThreadLocalRandom, SecureRandom and, since JDK 17, RandomGenerator. They all appear to do the same job, the tutorials contradict each other, and one of them is the difference between a safe password-reset link and a guessable one.
This page walks them in the order a newcomer needs them: what a random number from a computer actually is, the one mistake that makes Random dangerous, how to get a number in a range without the three classic bugs, why ThreadLocalRandom exists, what SecureRandom really gives you, and what the newer RandomGenerator adds. Every number below was printed by a program in the companion module, and every output block is quoted from a committed file you can open.
The short answer
Class
Use it for
Never use it for
Can you seed it?
Random
Games, simulations, test data you want to replay
Tokens, passwords, anything an attacker would guess
Yes, and the same seed repeats
ThreadLocalRandom
Many threads that each need numbers fast
Secrets; tests that must replay
No, it refuses
SecureRandom
Tokens, passwords, keys, salts, one-time codes
Hot loops where nanoseconds matter
Not in a way that repeats
RandomGenerator
Writing code that does not care which algorithm sits behind it; choosing a modern algorithm by name
Secrets (except through SecureRandom)
Yes, when you create one with a seed
Versions this was tested against. JDK 25.0.5.1 (Temurin, LTS, build date 2026-11-17), JUnit Jupiter 5.11.0, Maven 3.9.11. The RandomGenerator interface and the java.util.random package arrived in JDK 17 through JEP 356 (status Delivered, release 17, per the JEP page). Everything here was run on 25; I did not run the module on other JDKs, and every claim about older behaviour is marked as documentation, not execution.
Code lives in the random module of java-core-examples. There is nothing to read elsewhere: the explanations, including the deeper material, are in the expandable boxes on this page.
A random number from a computer is a recipe, and the seed is where the recipe starts
Computers do not roll dice. The numbers Random produces come from a recipe: take the generator’s current internal state, scramble it into an output, then move the state forward. The seed is just the starting state. Give the recipe the same start and it walks the same path.
The diagram shows a seed of 42 feeding a 48-bit state, which yields five numbers. Run it again with 42 and you get the same five. If you give no seed, the JDK picks one for you, so every run starts somewhere different.
Here is the smallest program that touches all four APIs. It is not in the repository; it is one file you can download and run with java QuickStart.java on any JDK 17 or newer: download QuickStart.java (save it under that name).
import java.security.SecureRandom;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.random.RandomGenerator;
/**
* The four ways to get a random number in Java, side by side.
* Run with: java QuickStart.java (JDK 17 or newer)
*/
public class QuickStart {
public static void main(String[] args) {
// 1. java.util.Random: fine for games and tests, repeatable when seeded. Never for secrets.
Random random = new Random(42);
System.out.println("Random(42) : " + random.nextInt(1, 7));
// 2. ThreadLocalRandom: the fast choice when many threads need numbers. Cannot be seeded.
System.out.println("ThreadLocalRandom : " + ThreadLocalRandom.current().nextInt(1, 7));
// 3. SecureRandom: unpredictable. Use it for tokens, passwords, keys, anything an attacker would want to guess.
System.out.println("SecureRandom : " + new SecureRandom().nextInt(1, 7));
// 4. RandomGenerator: the interface behind all of the above, plus a catalogue of modern algorithms.
RandomGenerator generator = RandomGenerator.getDefault();
System.out.println("RandomGenerator : " + generator.nextInt(1, 7));
}
}
Only the first line is repeatable, because only Random(42) has a fixed seed. The others pick their own starting point. Now the seed behaviour itself, in the SeedDemo.java demo:
Random a = new Random(42);
Random b = new Random(42);
System.out.println("Random(42) #1: " + a.nextInt(100) + " " + a.nextInt(100) + " " + a.nextInt(100) + " " + a.nextInt(100) + " " + a.nextInt(100));
System.out.println("Random(42) #2: " + b.nextInt(100) + " " + b.nextInt(100) + " " + b.nextInt(100) + " " + b.nextInt(100) + " " + b.nextInt(100));
== Same seed, same sequence ==
Random(42) #1: 30 63 48 84 70
Random(42) #2: 30 63 48 84 70
== No seed: every instance starts somewhere different ==
new Random() #1: 94 42 76
new Random() #2: 86 37 29
(these two lines differ on every run)
== setSeed rewinds an existing instance ==
first draw before setSeed(7): 236, first draw after: 236
Seeded output is a promise, not luck. The Random Javadoc says implementations must use the specified algorithm, precisely so that the same seed and calls give identical output. That is why RandomContractTest can pin 30 63 48 as the first three nextInt(100) values for seed 42. I ran that on 25.0.5.1 only, so treat the guarantee as the documentation’s, and the pinned numbers as one data point.
Go deeper: what is actually inside java.util.RandomRandom keeps a 48-bit seed and updates it with a linear congruential formula, which is the simplest family of generators there is: multiply, add, keep the low 48 bits. Its period is 248, so the sequence repeats after about 281 trillion values (Javadoc).
That simplicity is the whole story of its two faces. It is fast and tiny, and the same simplicity makes it predictable, which the next section demonstrates by actually predicting it.
setSeed rewinds an existing instance to a starting state, as the third block of output shows: the first draw after setSeed(7) equals the first draw before it. Random is also thread-safe, but one shared instance becomes a bottleneck under many threads, which is the reason ThreadLocalRandom exists (section 4).
Going deeper
Random is fine for dice and test data, and wrong for anything an attacker would like to guess
Predictable means that seeing a few outputs lets you compute the next ones. For a dice game that does not matter. For a password-reset link, a session id or a coupon code it is the whole game: if I can predict your next token, I do not need to guess it.
Random is predictable in a very concrete way. nextInt() returns 32 of the 48 bits of internal state, so each output hides only 16.
Two consecutive outputs therefore leave 65,536 possible hidden halves, and the second output eliminates all but one of them. After that the attacker holds the full state and can compute every later number. The loop below does exactly that.
Source: Predictor.java.
private static final long MULT = 0x5DEECE66DL;
private static final long ADD = 0xBL;
private static final long MASK = (1L << 48) - 1;
static int predictThird(int first, int second) {
for (long low = 0; low < (1L << 16); low++) {
long state1 = ((first & 0xFFFFFFFFL) << 16) | low;
long state2 = step(state1);
if ((int) (state2 >>> 16) == second) {
return (int) (step(state2) >>> 16);
}
}
throw new IllegalStateException("no matching state: not a java.util.Random sequence");
}
The demo observes two outputs of a fresh, unseeded Random and predicts the third. Output, from output/01:
== Two outputs of an unseeded Random predict the third ==
seen output 1 : 1471292627
seen output 2 : 160425440
predicted 3 : 239866061
actual 3 : 239866061
prediction correct: true
The fingerprint of this bug is a new Random() (or a Random field) sitting next to a name like token, password, otp, resetCode or sessionId. Nothing fails, nothing logs, and the code looks fine in review. The only symptom is that someone else can compute your secrets.
Go deeper: how the prediction works, step by step
Step one: nextInt() returns the high 32 bits of the 48-bit state after it has been advanced. So from output 1 you know the top 32 bits of state 1 and are missing the bottom 16.
Step two: try all 65,536 values for the missing bits. For each candidate, advance the state once with the same multiply-and-add the JDK uses, take its top 32 bits, and compare with output 2. In the demo exactly one candidate matches. Advance once more and you have output 3.
Honest scope: the demo uses raw nextInt() outputs, the easiest case. Outputs squeezed down by nextInt(6) reveal fewer bits per call, so recovering the state would need more observations. That is my reasoning, not something this module runs. The test RandomContractTest also checks the other direction: the same predictor fails against 20 of 20 SecureRandom triples.
Going deeper
RandomContractTest.java: twoOutputsPredictTheThirdForJavaUtilRandom and predictorCannotPredictSecureRandom
Where to go instead: section 5 of this page
Getting a number in a range, and the three bugs everyone writes once
The right way is one call. Since JDK 17 every generator has nextInt(origin, bound), where the lower end is included and the upper end is excluded. A die is therefore nextInt(1, 7), not nextInt(1, 6).
From RangeDemo.java:
== The right calls (upper bound is always exclusive) ==
nextInt(10) 0..9 : 5
nextInt(1, 7) 1..6 : 5
nextInt(-5, 6) -5..5 : 3
nextDouble() [0,1) : 0.4074398012118764
nextDouble(2, 3) [2,3) : 2.036235382150368
ints(5, 1, 7) : [5, 5, 5, 2, 2]
== Bad arguments fail loudly ==
nextInt(0) -> bound must be positive
nextInt(5, 5) -> bound must be greater than origin
Output quoted from output/02-ranges-and-bias.txt. Bad bounds fail loudly with IllegalArgumentException, which is the behaviour you want.
Bugs one and two: a remainder that goes negative, and an abs that does not
The usual first attempt is random.nextInt() % 6. nextInt() returns any int, negatives included, and Java’s remainder keeps the sign of the dividend, so roughly two in five results come out negative. The usual second attempt wraps it in Math.abs, which has its own trap: Math.abs(Integer.MIN_VALUE) is still negative.
Both traps are in RangeDemo.java:
Random t = new Random(2);
int negatives = 0;
for (int i = 0; i < 1000; i++) {
if (t.nextInt() % 6 < 0) negatives++;
}
System.out.println("1000 draws of nextInt() % 6, negative results: " + negatives);
System.out.println("Math.abs(Integer.MIN_VALUE) = " + Math.abs(Integer.MIN_VALUE));
System.out.println("Math.abs(Integer.MIN_VALUE) % 10 = " + (Math.abs(Integer.MIN_VALUE) % 10));
== Trap 1: nextInt() % n can be negative ==
1000 draws of nextInt() % 6, negative results: 397
== Trap 2: Math.abs(Integer.MIN_VALUE) is still negative ==
Math.abs(Integer.MIN_VALUE) = -2147483648
Math.abs(Integer.MIN_VALUE) % 10 = -8
(nextInt() hits MIN_VALUE once in 2^32 calls, so tests never catch it)
This one hides.nextInt() returns exactly Integer.MIN_VALUE about once in 4.3 billion calls, so Math.abs(r.nextInt()) % n passes every test you will ever write and fails in production once in a long while with a negative array index.
Bug three: modulo bias
Suppose you take a random 3-bit value, 0 to 7, and want a result in 0 to 2. The natural move is x % 3. Eight values cannot divide evenly into three buckets.
The buckets get three, three and two inputs, so result 2 is less likely. With dice the effect is microscopic, but it grows with the bound. The code below uses a bound of 1,500,000,000 over the 231 non-negative ints and counts how often the low results appear, in RangeDemo.java (output in output/02).
int bound = 1_500_000_000;
int low = Integer.MAX_VALUE - bound + 1; // values below this are hit twice by (x % bound)
double uniformShare = (double) low / bound;
int draws = 2_000_000;
Random m = new Random(3);
int biasedLow = 0, fairLow = 0;
for (int i = 0; i < draws; i++) {
if ((m.nextInt() >>> 1) % bound < low) biasedLow++;
if (m.nextInt(bound) < low) fairLow++;
}
Uniform would put 43.17% of results below the cut-off. The remainder version puts 60.31% there; nextInt(bound) lands on 43.15%. Use the bounded call and the arithmetic is done correctly for you.
Go deeper: how big is modulo bias, and when does it matter?
Values below low = 231 − 1,500,000,000 + 1 = 647,483,648 are produced by two different inputs each, so their chance is about twice as large. Uniform gives 647,483,648 / 1,500,000,000 = 0.4317; the biased version gives roughly 2 × 647,483,648 / 231 = 0.6030, which the run measured as 0.6031. That arithmetic is exact; the measurement only confirms it.
For small bounds the damage shrinks fast. 232 = 6 × 715,827,882 + 4, so for a die rolled from a full 32-bit value four outcomes have one extra input out of about 715.8 million, a relative difference near 1.4 in a billion. That is invisible for games and unacceptable for cryptography, where a measurable bias in a key or a nonce is a vulnerability in its own right.
I did not read the JDK source to describe how nextInt(bound) avoids the problem; the measured share, 0.4315 against an expected 0.4317, is what I can stand behind. The test moduloIsBiasedAndNextIntBoundIsNot pins the comparison.
Going deeper
For passwords and codes built from an alphabet, use SecureRandom.nextInt(alphabet.length()), never a remainder: see TokenGenerator.java in section 5
ThreadLocalRandom: the same job without threads queueing for one state
Random is thread-safe, which means one instance can be shared by every thread. The catch is in the word one: every call updates the same state, so under heavy use the threads wait on each other. ThreadLocalRandom gives each thread its own state, so nobody waits.
The numbers in the picture come from output/06-timings.txt: four threads, five million calls each. The work per call is the same; what differs is whether the threads share one state. The code that produced them, from BenchmarkDemo.java:
shared("Random (shared)", new Random()::nextInt);
shared("SecureRandom (shared)", new SecureRandom()::nextInt);
shared("ThreadLocalRandom.current()", () -> ThreadLocalRandom.current().nextInt());
== 4 threads sharing ONE instance, 5000000 calls each (wall time, ms) ==
Random (shared) 987 ms
SecureRandom (shared) 7329 ms
ThreadLocalRandom.current() 37 ms
checksum (ignore): -28432667108051
The sandbox has two cores and this is a plain timing loop, not JMH, so read the ratio and not the milliseconds. The ratio is large on a machine this small, and that is the direction the Javadoc predicts: sharing one Random across threads causes contention, and ThreadLocalRandom is the recommended alternative.
How to call it, and what it will not do
The Javadoc asks for one form only: ThreadLocalRandom.current().nextX(...), called each time, never stored. It also cannot be seeded. From ThreadLocalDemo.java:
== The one correct way to call it ==
ThreadLocalRandom.current().nextInt(1, 7) -> in 1..6: true
== It cannot be seeded ==
setSeed(42) -> UnsupportedOperationException, message: null
== Each thread has its own state ==
4 threads, distinct first values: 4 of 4
== Works the same on virtual threads ==
virtual thread rolled a die: true
Do not use it where a test has to replay.setSeed throws UnsupportedOperationException (with a null message, as the output shows), so a failure involving ThreadLocalRandom cannot be reproduced from a seed. If the code under test needs randomness you want to replay, accept a RandomGenerator parameter and pass in a seeded one. The Instancio post, Instancio: Generate Realistic Test Data Automatically in Java, shows the replay-from-seed workflow for test data.
Go deeper: where ThreadLocalRandom is the natural pick
The Javadoc names parallel work, such as tasks in a fork/join pool, as the place where the lower overhead matters most. If you generate numbers inside parallel streams or other pooled tasks, ThreadLocalRandom.current() is the idiomatic call. How and when parallel streams pay off is a separate question: see Java Parallel Streams: When They’re Slower.
It also works unchanged on virtual threads: the last block of output rolls a die on one. I only demonstrate that it works; I did not measure virtual-thread throughput.
The shared SecureRandom row in the same table, 7329 ms for the same work, is a different story. It is slower per call even on one thread (section 5 has the numbers), and sharing one instance makes the threads queue as well.
Going deeper
SecureRandom: the one to use whenever a guess would hurt
The Random Javadoc points security-sensitive code to SecureRandom, because its output cannot be worked out from earlier outputs the way Random‘s can. It is the right tool for tokens, passwords, keys, salts and one-time codes. Here is what it is on a real machine.
From SecureRandomDemo.java:
SecureRandom sr = new SecureRandom();
System.out.println("algorithm : " + sr.getAlgorithm());
System.out.println("provider : " + sr.getProvider().getName());
Util.section("getInstanceStrong()");
SecureRandom strong = SecureRandom.getInstanceStrong();
...
byte[] bytes = new byte[32];
sr.nextBytes(bytes);
String token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
System.out.println("length in characters: " + token.length() + " (value differs on every run)");
== What new SecureRandom() gives you on this machine ==
algorithm : NativePRNG
provider : SUN
== getInstanceStrong() ==
algorithm : NativePRNGBlocking
securerandom.strongAlgorithms = NativePRNGBlocking:SUN,DRBG:SUN
== SecureRandom algorithms registered in this JDK ==
DRBG (SUN)
NativePRNG (SUN)
NativePRNGBlocking (SUN)
NativePRNGNonBlocking (SUN)
SHA1PRNG (SUN)
== A session token: 32 random bytes = 256 bits ==
length in characters: 43 (value differs on every run)
Quoted from output/04-securerandom.txt. On this Linux machine new SecureRandom() is NativePRNG from the SUN provider, and getInstanceStrong() picks NativePRNGBlocking from the securerandom.strongAlgorithms list. Your platform may select different ones.
The price is time. In the timing run one nextInt() costs 90.6 ns on SecureRandom against 2.1 ns on ThreadLocalRandom. That does not matter for a token you make once per login and matters a great deal in a Monte Carlo loop, which is why you do not use it there.
A complete, safe generator for tokens, passwords and one-time codes is below. It is not in the repository either; it is a single file: download TokenGenerator.java and run java TokenGenerator.java.
import java.security.SecureRandom;
import java.util.Base64;
/**
* Generates secrets the safe way: SecureRandom, no modulo bias.
* Run with: java TokenGenerator.java (JDK 17 or newer)
*/
public class TokenGenerator {
private static final SecureRandom RANDOM = new SecureRandom();
private static final String ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789";
/** URL-safe token carrying 'bytes' bytes of randomness (32 bytes = 256 bits = 43 characters). */
static String token(int bytes) {
byte[] buf = new byte[bytes];
RANDOM.nextBytes(buf);
return Base64.getUrlEncoder().withoutPadding().encodeToString(buf);
}
/** Password from a fixed alphabet. nextInt(bound) avoids the modulo bias of (x % bound). */
static String password(int length) {
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) {
sb.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
}
return sb.toString();
}
/** Six-digit one-time code, zero padded. */
static String otp() {
return String.format("%06d", RANDOM.nextInt(1_000_000));
}
public static void main(String[] args) {
System.out.println("token : " + token(32));
System.out.println("password : " + password(16));
System.out.println("otp : " + otp());
}
}
Notice that the password method uses RANDOM.nextInt(ALPHABET.length()) rather than a remainder, so the modulo bias from section 3 does not creep in, and the alphabet leaves out look-alikes such as 0, O, 1 and l. The output differs on every run by design, so there is no transcript to quote.
Do not “make it deterministic” with setSeed. People reach for setSeed to make a SecureRandom test repeatable. The output below shows the trap: with SHA1PRNG the same seed does repeat, while on the default NativePRNG it does not, because the Javadoc says setSeed supplements the existing seed rather than replacing it. (It adds that a PRNG instance seeded by setSeed before its first use does not seed itself, which is what makes the SHA1PRNG case repeat.) Code that works with one algorithm and silently differs on another is worse than code that fails.
== Seeding: SHA1PRNG is deterministic, the default is not ==
SHA1PRNG, same seed, same bytes: true
NativePRNG, same seed, same bytes: false (setSeed only adds entropy; it does not make the output repeatable)
Go deeper: default versus getInstanceStrong, and what the catalogue showsgetInstanceStrong() picks an implementation from the list in the securerandom.strongAlgorithms security property; the output shows the list NativePRNGBlocking:SUN,DRBG:SUN and that this machine chose NativePRNGBlocking. The Javadoc says it is meant for high-value, long-lived secrets such as RSA key pairs, and notes that nextBytes, reseed and generateSeed may block while entropy is gathered. I only record what this machine selected and did not measure a stall. For ordinary tokens the default instance is what most code uses; reserve the strong one for long-lived keys, where a pause at generation time is acceptable.
The list of registered algorithms in the output also shows DRBG, a deterministic random bit generator, and SHA1PRNG, the older seedable one from the callout above.
SecureRandom is a RandomGenerator too, so nextInt(1, 7) and the rest of the range API work on it. In the RandomGenerator catalogue in section 6 it appears with a state size of 2147483647 bits, which is Integer.MAX_VALUE; I read that as the catalogue saying it is not a fixed-size generator, which is my interpretation and not a documented statement.
Going deeper
RandomGenerator: one interface for all of them, and a default you did not pick
JEP 356 added java.util.random.RandomGenerator in JDK 17: one interface supplying a uniform API for all generators, new and old. The JEP says Random, ThreadLocalRandom and SplittableRandom inherit it; the run below shows SecureRandom works too. That means you can write a method once and hand it any of them.
From RandomGeneratorDemo.java:
/** Written against the interface, so it works with any generator. */
static int rollDie(RandomGenerator g) {
return g.nextInt(1, 7);
}
== The old classes already implement RandomGenerator ==
Random -> rollDie in 1..6: true
SecureRandom -> rollDie in 1..6: true
SplittableRandom -> rollDie in 1..6: true
ThreadLocalRandom -> rollDie in 1..6: true
The interface sits at the top of a small family, each member adding one ability for parallel work.
A splittable generator can hand out fresh independent children; a jumpable one can leap far ahead in its sequence so that threads get non-overlapping stretches; a leapable one can leap even farther. Which algorithms carry which ability is printed by the catalogue, and the diagram’s footer summarises it.
The default is not the documentation’s general-purpose pick.RandomGenerator.getDefault() returned L32X64MixRandom, which has 96 bits of state, the smallest of the LXM family here. The package documentation recommends L64X128MixRandom for applications with no special requirements, balancing speed, space and period. I state both and draw no verdict: the default is fine for dice and shuffles, and if you want the documented pick you ask for it by name, as below.
== Pick an algorithm by name, and seed it ==
Xoshiro256PlusPlus seed 42 #1: 600 767 404
Xoshiro256PlusPlus seed 42 #2: 600 767 404
RandomGenerator.of("L64X128MixRandom") -> L64X128MixRandom
Go deeper: split versus jump, and which to choose for parallel work
The package documentation gives practical advice. If you create all your threads in one batch at startup, a jumpable generator such as Xoshiro256PlusPlus or a splittable one such as L64X128MixRandom fits. If threads are created dynamically, a splittable generator is the recommended choice, and for very large numbers of generators it points to the L128X128MixRandom and L128X256MixRandom variants, which make clashes between generators less likely. That guidance is the documentation’s; my runs only show the mechanics.
The mechanics, from the output:
== Splittable: independent generators for parallel work ==
first draw of 4 split children: 952 921 97 912
== Jumpable: provably non-overlapping streams ==
jump distance : 3.402823669209385E38
leap distance : 6.277101735386681E57
original next: 600
after jump next: 545
split() gives each child its own generator state. jump() moves a copy of the generator forward by a fixed distance, which the output reports as about 3.4 × 1038, and the leap distance is about 6.3 × 1057. Those are 2128 and 2192; at a billion numbers a second, no thread will ever reach the start of the next one’s range. I did not test that two seeded splits reproduce across runs, so this module makes no claim about it.
Going deeper
One thread, twenty million nextInt() calls after a warm-up, from output/06-timings.txt:
Generator
Time per call
Random
8.5 ns
SplittableRandom
0.7 ns
ThreadLocalRandom
2.1 ns
L32X64MixRandom (the default)
2.9 ns
Xoshiro256PlusPlus
2.7 ns
SecureRandom
90.6 ns
These are indicative, not a benchmark. This is a plain timing loop on a two-core sandbox, not JMH, and the figures drift between runs; the module’s script says so too. Read the ordering: SecureRandom is more than an order of magnitude slower than everything else, and Random is slower than the modern generators even single-threaded. SplittableRandom‘s figure is low enough that the JIT compiler has probably folded part of the loop, so treat it as “very fast”, not as a measurement. For a decision that depends on these numbers, use the JMH post linked above.
Which one should you use?
Start from the cost of being guessed, not from speed.
The first question settles the most important case: if a guess would cause harm, nothing else on the page matters and the answer is SecureRandom. The remaining questions pick the fastest tool for the remaining jobs. In an older codebase where new Random(seed) already works, there is no urgency to change it.
Should you even think about this? Most of the time, no. For shuffling a playlist or rolling a die, any of the non-secure options is fine and the default is fine. The two decisions that actually matter are the one at the top of the diagram, whether the value is a secret, and the one in section 3, never using a remainder to shrink a range. Everything else is performance tuning you should measure before doing.
No Comments yet!