java使用多线程读取大文件，按50M分割，动态的去创建线程，线程异步的去直接每段的加密工作，全部线程执行完毕后再合并

Java中可以使用多线程读取大文件，按照50M分割后，动态创建线程异步执行加密操作，并最终合并结果。下面是一个简单的实现示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class FileEncryptor {

    private static final int CHUNK_SIZE = 50 * 1024 * 1024; // 50MB
    private static final int THREAD_POOL_SIZE = 4;

    public static void encryptFile(String sourceFilePath, String targetFilePath, String algorithm) throws IOException, NoSuchAlgorithmException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
        List<ThreadEncryptor> threadEncryptors = new ArrayList<>();

        FileInputStream inputStream = new FileInputStream(sourceFilePath);
        byte[] buffer = new byte[CHUNK_SIZE];
        int bytesRead;
        int chunkNumber = 0;
        while ((bytesRead = inputStream.read(buffer)) > 0) {
            ThreadEncryptor threadEncryptor = new ThreadEncryptor(buffer, bytesRead, chunkNumber, algorithm);
            threadEncryptors.add(threadEncryptor);
            executorService.execute(threadEncryptor);
            chunkNumber++;
            buffer = new byte[CHUNK_SIZE];
        }
        inputStream.close();

        executorService.shutdown();
        executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);

        FileOutputStream outputStream = new FileOutputStream(targetFilePath);
        for (ThreadEncryptor threadEncryptor : threadEncryptors) {
            outputStream.write(threadEncryptor.getResult());
        }
        outputStream.close();

        System.out.println("Encryption completed.");
    }

    private static class ThreadEncryptor implements Runnable {

        private final byte[] data;
        private final int length;
        private final int chunkNumber;
        private final String algorithm;
        private byte[] result;

        public ThreadEncryptor(byte[] data, int length, int chunkNumber, String algorithm) {
            this.data = data;
            this.length = length;
            this.chunkNumber = chunkNumber;
            this.algorithm = algorithm;
        }

        public byte[] getResult() {
            return result;
        }

        @Override
        public void run() {
            try {
                MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
                byte[] digest = messageDigest.digest(data);
                this.result = digest;
                System.out.println("Chunk " + chunkNumber + " processed by thread " + Thread.currentThread().getName());
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
    }
}

这个程序首先创建了一个包含固定数量线程的线程池，并用它来异步执行加密操作。它通过读取输入文件并分割为固定大小的块，并创建一个新的ThreadEncryptor实例，然后将其添加到线程池中。

ThreadEncryptor类是一个简单的Runnable实现，它负责将其分配的块加密，使用指定的哈希算法计算哈希值，然后将结果存储在result数组中。

在主线程中，我们等待所有线程完成，然后将每个线程的结果写入目标文件。

注意：在这个示例程序中，我们只是使用了哈希算法来模拟加密操作，实际上应该使用一些更复杂的加密算法来保证数据的安全。