用java实现分成6个线程，计算m到n的值(以1到100000000为例)的总和。要求每个线程计算的数字量之差不超过1。

好的，这个问题可以用Java的多线程技术来解决。以下是一个可能的实现：

import java.util.concurrent.*;

public class SumCalculator {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int m = 1;
        int n = 100000000;
        int numThreads = 6;

        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
        int chunkSize = (n - m + 1) / numThreads;
        int remainder = (n - m + 1) % numThreads;

        Future<Integer>[] futures = new Future[numThreads];
        int start = m;
        for (int i = 0; i < numThreads; i++) {
            int end = start + chunkSize - 1;
            if (i < remainder) {
                end++;
            }
            futures[i] = executor.submit(new SumTask(start, end));
            start = end + 1;
        }

        int sum = 0;
        for (int i = 0; i < numThreads; i++) {
            sum += futures[i].get();
        }

        System.out.println("Sum: " + sum);
        executor.shutdown();
    }

    private static class SumTask implements Callable<Integer> {
        private final int start;
        private final int end;

        public SumTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public Integer call() {
            int sum = 0;
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }
    }
}

这个程序会将计算任务分成6个线程，每个线程计算一部分数字的总和。为了保证每个线程计算的数字量之差不超过1，我们需要先计算出每个线程应该计算的数字范围。如果总数字量不能被线程数整除，我们需要将余数分配给前几个线程。然后，我们使用Java的Executor框架来创建线程池，并提交计算任务。每个任务会计算自己负责的数字范围的总和，并返回结果。最后，我们将所有线程的结果加起来，得到最终的总和。

关于lua closure factory的完整代码，我不是很清楚你具体想要什么样的实现，可以提供更多的信息吗？

至于中文加密，这个问题比较广泛，可以有很多种实现方式。你具体想要哪种加密方式呢？