java实现Cipher线程安全

Java中的Cipher类本身不是线程安全的，如果要在多线程环境中使用，则需要采取相应的措施来确保线程安全。以下是几种实现线程安全的方法：

1. 使用ThreadLocal

可以使用ThreadLocal来确保每个线程都有自己的Cipher实例。在每个线程中，首先检查ThreadLocal中是否已经存在Cipher实例，如果存在则直接使用，否则创建一个新的实例并存储在ThreadLocal中。这样可以确保每个线程都有自己的Cipher实例，从而避免多个线程之间的竞争。

public class CipherThreadLocal {
    private static final ThreadLocal<Cipher> CIPHER_THREAD_LOCAL = new ThreadLocal<Cipher>() {
        @Override
        protected Cipher initialValue() {
            try {
                return Cipher.getInstance("AES/CBC/PKCS5Padding");
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    };
    
    public static Cipher getCipher() {
        return CIPHER_THREAD_LOCAL.get();
    }
}

在每个线程中，可以通过调用CipherThreadLocal.getCipher()方法来获取Cipher实例。

2. 使用synchronized关键字

可以使用synchronized关键字来确保多个线程之间的互斥访问。在每个方法中，使用synchronized关键字来修饰方法，从而确保同一时刻只有一个线程可以访问该方法。

public class CipherSynchronized {
    private final Cipher cipher;

    public CipherSynchronized() throws Exception {
        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    }

    public synchronized byte[] encrypt(byte[] input) throws Exception {
        cipher.init(Cipher.ENCRYPT_MODE, getKey());
        return cipher.doFinal(input);
    }

    public synchronized byte[] decrypt(byte[] input) throws Exception {
        cipher.init(Cipher.DECRYPT_MODE, getKey());
        return cipher.doFinal(input);
    }

    private SecretKeySpec getKey() {
        // ...
    }
}

在每个方法中，使用synchronized关键字来修饰方法，从而确保同一时刻只有一个线程可以访问该方法。

3. 使用Lock接口

可以使用Lock接口来实现多线程之间的互斥访问。在每个方法中，先获取Lock锁，然后执行操作，最后释放Lock锁。

public class CipherLock {
    private final Cipher cipher;
    private final Lock lock = new ReentrantLock();

    public CipherLock() throws Exception {
        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    }

    public byte[] encrypt(byte[] input) throws Exception {
        lock.lock();
        try {
            cipher.init(Cipher.ENCRYPT_MODE, getKey());
            return cipher.doFinal(input);
        } finally {
            lock.unlock();
        }
    }

    public byte[] decrypt(byte[] input) throws Exception {
        lock.lock();
        try {
            cipher.init(Cipher.DECRYPT_MODE, getKey());
            return cipher.doFinal(input);
        } finally {
            lock.unlock();
        }
    }

    private SecretKeySpec getKey() {
        // ...
    }
}

在每个方法中，先获取Lock锁，然后执行操作，最后释放Lock锁。这样可以确保同一时刻只有一个线程可以访问该方法。