如何多线程执行暴力java密码程序

我为我的11年级计算机科学项目创建了一个程序，在这个项目中，我制作了一个java密码破解程序，可以强行破解密码。然而，我想得到一些关于如何多线程处理java程序（下面提供的代码）以加速暴力过程的建议。如果它有帮助的话，我运行的是英特尔的i7-3770处理器，它是四核的，但每个核有2个线程，所以一次可能有8个线程

代码如下：

import java.util.*;
import java.io.*;
class pwcracker
{
public static void main (String[] args)
{
Scanner scan = new Scanner( System.in );
Random rand = new Random();

Runtime.getRuntime().availableProcessors();

 String pw, choices, guess;
long tries;
int j, length;

System.out.println("Enter a password that is up to 5 chars and contains no numbers: ");
pw = "" + scan.nextLine();
length = pw.length();

choices = "abcdefghijklmnopqrstuvwxyz";
tries = 0;
guess = "";

System.out.println("Your pw is: " + pw);
System.out.println("The length of your pw is: " + length);

System.out.println("for TEST- Guess: " + guess + "pw :"+pw);


 if (guess !=  pw){

 while  (guess !=  pw) 
 { 
    j = 0;
    guess = "";

    while ( j < length )
    {
        guess = guess + choices.charAt( rand.nextInt ( choices.length() ) );
        j = j + 1;

    if (guess == pw)
 {
   System.out.println("Match found, ending loop..");
   break;
 }

    }
            System.out.println("2 Guess: " + guess + " pw :"+pw); 

    tries = tries + 1;                      
}
}
System.out.println("Here is your password: " + guess);
System.out.println("It took " + tries + " tries to guess it.");
 }
 }

import java.util.*；
导入java.io.*；
类压榨机
{
公共静态void main（字符串[]args）
{
扫描仪扫描=新扫描仪（System.in）；
Random rand=新的Random（）；
Runtime.getRuntime（）.availableProcessors（）；
字符串pw，选择，猜测；
漫长的尝试；
int j，长度；
System.out.println（“输入最多5个字符且不包含数字的密码：”）；
pw=”“+scan.nextLine（）；
长度=pw.length（）；
choices=“abcdefghijklmnopqrstuvxyz”；
尝试=0；
猜测=”；
System.out.println（“您的pw是：“+pw”）；
System.out.println（“pw的长度为：“+length”）；
System.out.println（“用于测试-猜测：+Guess+”pw:+pw）；
如果（猜测！=pw）{
while（猜！=pw）
{ 
j=0；
猜测=”；
while（j

首先，您希望尽可能减少循环中不必要的函数调用。例如，choices.length可以作为变量存储在内存中，比如int choice=choice.length。这将优化您的程序，因为每次计算机不必计算长度时，它已经存储在内存中供其使用

如果您想使用线程路由，那么我会将其设置为一个算法。在较高级别上，我们有生产者线程创建工作，消费者线程执行工作，我们有一个共享队列对象，用于将工作单元从生产者转移到消费者

在你的例子中，由于你的样本空间相对较小（重复长度为5的排列），我会有一个生产者线程。如果你使用我下面的建议，这也会使事情变得简单。对你来说，这看起来很简单。就要使用的线程总数而言，从少量开始，使用不同数量的线程

我看到您正在随机创建字符串以进行检查。然而，由于这会产生大量重复和冗余的检查，我建议使用排列。也就是说，您需要长度为5的字母表中字符的所有排列。我找到了这个图书馆。这将允许您不重复地获得所有可能的安排。大概是这样的：

// Create the initial vector of 26 elements (alphabet)
ICombinatoricsVector<char> originalVector = Factory.createVector(new char[] { 'a', 'b', 'c', ..., 'z' });

// Create the generator by calling the appropriate method in the Factory class. 
// Set the second parameter as 5, since we will generate 5-elemets permutations
Generator<char> gen = Factory.createPermutationWithRepetitionGenerator(originalVector, 5);

// Print the result
for (ICombinatoricsVector<char> perm : gen)
   System.out.println( perm ); //combine the elements of perm into a single string and add to your queue

//创建26个元素的初始向量（字母表）
ICombinatoricsVector originalVector=Factory.createVector（新字符[]{'a'，'b'，'c'，…，'z'}）；
//通过在Factory类中调用适当的方法来创建生成器。
//将第二个参数设置为5，因为我们将生成5元素置换
Generator gen=Factory.CreatePermutationWithRepetitiationGenerator（originalVector，5）；
//打印结果
对于（ICombinatoricsVector perm:gen）
系统输出打印项次（perm）//将perm的元素组合成一个字符串并添加到队列中

（警告：我没有测试上述内容）

---

编辑：我必须在思考这一点时查找组合和排列之间的差异：）我发现这个链接作为一个简单的复习工具很有用：

这不是一个并行处理解决方案，而是一个更优化的暴力方法。可以考虑将迭代器更改为拆分器。如果时间允许，我可能会在下面的帖子中给出一个拆分器方法

package pwcracker;

import java.util.Iterator;
import java.util.Scanner;

public class pwcracker {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String pw;
        int length;

        System.out.println("Enter a password that is up to 5 chars and contains no numbers: ");
        pw = "" + scan.nextLine();
        length = pw.length();

        SequentialPatternGenerator generator = new SequentialPatternGenerator(length);

        generator.forEachRemaining(test -> {if(pw.equals(test)) {
            System.out.println("Your password: " + test );
        }});

    }
}

class SequentialPatternGenerator implements Iterator<String> {

    private static final char[] CHOICES = new char[]{'a', 'b', 'c', 'd', 'e', 'f',
        'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};

    private static final int MAX_INDEX = CHOICES.length - 1;
    private boolean keepProducing = true;
    private final int[] indexes;

    public SequentialPatternGenerator(final int length) {
        indexes = new int[length];
        initIndexes();
    }

    private void initIndexes() {
        for (int i = 0; i < indexes.length; i++) {
            indexes[i] = 0;
        }
    }

    @Override
    public boolean hasNext() {
        if (!keepProducing) {
            return false;
        }

        for (int i = 0; i < indexes.length; i++) {
            if (indexes[i] < MAX_INDEX) {
                return true;
            }
        }

        return false;
    }

    @Override
    public String next() {
        if (!keepProducing || !hasNext()) {
            return null;
        }

        String next = produceString();
        adjustIndexes();

        return next;
    }

    public void stop() {
        keepProducing = false;
    }

    private String produceString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < indexes.length; i++) {
            sb.append(CHOICES[indexes[i]]);
        }

        return sb.toString();
    }

    private void adjustIndexes() {
        int i;
        for(i = 0 ; i < indexes.length ; i++) {
            if(indexes[i] < MAX_INDEX) {
                indexes[i] = indexes[i] + 1;
                break;
            }
        }

        for(int j=0; j < i; j++) {
            indexes[j] = 0;
        }
    }
}

包装机；
导入java.util.Iterator；
导入java.util.Scanner；
公共级破坏者{
公共静态void main（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
串pw；
整数长度；
System.out.println（“输入最多5个字符且不包含数字的密码：”）；
pw=”“+scan.nextLine（）；
长度=pw.length（）；
SequentialPatternGenerator=新的SequentialPatternGenerator（长度）；
生成器.forEachRemaining（测试->{if（pw.equals（测试））{
System.out.println（“您的密码：+test”）；
}});
}
}
类SequentialPatternGenerator实现迭代器{
私有静态最终字符[]选项=新字符[]{'a'，'b'，'c'，'d'，'e'，'f'，
‘g’、‘h’、‘i’、‘j’、‘k’、‘l’、‘m’、‘n’、‘o’、‘p’、‘q’、‘r’、‘s’、‘t’、‘u’、‘v’、‘w’、‘x’、‘y’、‘z’}；
私有静态最终int MAX_INDEX=CHOICES.length-1；
私有布尔keepProducing=true；
私有最终int[]索引；
公共顺序模式生成器（最终整数长度）{
索引=新的整数[长度]；
初始化索引（）；
}
私有void initindex（）{
for（int i=0；i