here

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Objects;
import java.util.Queue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
* reference: org.apache.tomcat.util.security.*
*
* A thread safe wrapper around {@link MessageDigest} that does not make use
* of ThreadLocal and - broadly - only creates enough MessageDigest objects
* to satisfy the concurrency requirements.
*/
public class Encrypt {

public static final String MD5 = "MD5";
public static final String SHA1 = "SHA-1";

private final String algorithm;
private final Queue<MessageDigest> queue;

/**
* init algorithm and queue
* @param algorithm name of algorithm, like "MD5", "SHA-1"...
* @param queue save MessageDigest instance, recommend {@link java.util.concurrent.BlockingQueue}, {@link java.util.concurrent.ConcurrentLinkedQueue}
* @throws NoSuchAlgorithmException if no such algorithm
*/
public Encrypt(String algorithm, Queue<MessageDigest> queue) throws NoSuchAlgorithmException {
Objects.requireNonNull(queue, "messageDigest queue can't be null!");

if (!BlockingQueue.class.isAssignableFrom(queue.getClass()) && !ConcurrentLinkedQueue.class.isAssignableFrom(queue.getClass())) {
throw new IllegalArgumentException("queue must be BlockingQueue or ConcurrentLinkedQueue");
}

MessageDigest md = MessageDigest.getInstance(algorithm);

this.algorithm = algorithm;
this.queue = queue;

queue.add(md);

}

public byte[] digest(byte[] input) {

/**
* Retrieves and removes the head of this queue,
* or returns {@code null} if this queue is empty.
*/
MessageDigest md = queue.poll();
if (md == null) {
try {
md = MessageDigest.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
//we call the constructor firstly, so it is impossible that exception happens here. do nothing
;
}
}

md.update(input);
byte[] output = md.digest();//cache it to promise thread-safe
//if exception happens, we don't need to add md to queue.

/**
* Inserts the specified element into this queue if it is possible to do so
* immediately without violating capacity restrictions, returning
* {@code true} upon success and throwing an {@code IllegalStateException}
* if no space is currently available.
*/
queue.add(md);
return output;
}

/**
* Encode an MD5 digest into a String.
* <p>
* The 128 bit MD5 hash is converted into a 32 character long String.
* Each character of the String is the hexadecimal representation of 4 bits
* of the digest.
*
* @author Remy Maucherat
*/
public static final class MD5Encoder {

private MD5Encoder() {
// Hide default constructor for utility class
}

private static final char[] hexadecimal = {'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

/**
* Encodes the 128 bit (16 bytes) MD5 into a 32 character String.
*
* @param binaryData Array containing the digest
*
* @return Encoded MD5, or null if encoding failed
*/
public static String encode(byte[] binaryData) {

if (binaryData.length != 16)
return null;

char[] buffer = new char[32];

for (int i=0; i<16; i++) {
int low = binaryData[i] & 0x0f;
int high = (binaryData[i] & 0xf0) >> 4;
buffer[i*2] = hexadecimal[high];
buffer[i*2 + 1] = hexadecimal[low];
}

return new String(buffer);
}
}

}