Question

我为我的11年级计算机科学项目创建了一个程序，在那里我制作了一个破解密码的java密码破解程序。但是，我想获得一些关于如何多线程我的java程序（下面提供的代码）来加速蛮力过程的建议。如果它有帮助我运行的是Intel的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.");
 }
 }

Answer 1

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

Answer 2

如果你想使用线程路由，那么我会将其设置为producer-consumer算法。在高杠杆，我们有生产者线程创建工作，我们有消费者线程完成工作，我们有一个共享队列对象，我们用它来将工作单位从生产者转移到消费者。

在你的情况下，由于你的样本空间相对较小（重复长度为5的排列），我会有一个生成器线程。如果您使用下面的建议，这也有助于简化操作。 This tutorial看起来很简单，作为你的起点。至于要使用的线程总数，从小处开始并使用不同数量的线程。

我看到你正在随机创建要检查的字符串。但是，由于这会产生大量重复和冗余的检查，我建议使用排列。也就是说，你需要长度为5的字母表字符的所有排列。我发现这个库有combinations and permutations。这样您就可以在不重复的情况下获得所有可能的安排。像这样：

// 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

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

编辑：在考虑这个问题时，我必须查看组合和排列之间的区别:)我发现此链接可用作简单的复习：http://www.mathsisfun.com/combinatorics/combinations-permutations.html

Answer 3

这不是并行处理解决方案，而是更优化的强力方法。您可以考虑将Iterator更改为Spliterator。如果时间允许，我可能会在后面的帖子中给出一个Spliterator方法。

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密码程序

3 个答案: