1. 生成一个长度是3的随机字符串，把这个字符串当作 密码
  2. 创建一个破解线程，使用穷举法，匹配这个密码
  3. 创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程

提示： 破解线程把穷举法生成的可能密码放在一个容器中，日志线程不断的从这个容器中拿出可能密码，并打印出来。 如果发现容器是空的，就休息1秒，如果发现不是空的，就不停的取出，并打印。

解题代码：
穷举密码的线程

package multiplethread;
import java.util.List;
public class PasswordThread extends Thread{
    private boolean found = false;
    private String password;
    private List<String> passwords;
    public PasswordThread(String password, List<String> passwords) {
        this.password = password;
        this.passwords = passwords;
    }
    public void run(){
        char[] guessPassword = new char[password.length()];
        generatePassword(guessPassword, password);
    }
    public  void generatePassword(char[] guessPassword, String password) {
        generatePassword(guessPassword, 0, password);
    }
    public  void generatePassword(char[] guessPassword, int index, String password) {
        if (found)
            return;
        for (short i = '0'; i <= 'z'; i++) {
            char c = (char) i;
            if (!Character.isLetterOrDigit(c))
                continue;
            guessPassword[index] = c;
            if (index != guessPassword.length - 1) {
                generatePassword(guessPassword, index + 1, password);
            } else {
                String guess = new String(guessPassword);
                //穷举每次生成的密码，都放进集合中
                passwords.add(guess);
                if (guess.equals(password)) {
                    System.out.println("找到了，密码是" + guess);
                    found = true;
                    return;
                }
            }
        }
    }
}

记录日志的守护线程

package multiplethread;
import java.util.List;
public class LogThread extends Thread{
    private boolean found = false;
    private List<String> passwords;
    public LogThread(List<String> passwords) {
        this.passwords = passwords;  
        this.setDaemon(true);//把记日志的这个线程，设置为守护线程
    }
    public void run(){
        while(true){
            while(passwords.isEmpty()){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            String password = passwords.remove(0);
            System.out.println("穷举法本次生成的密码是：" +password);
        }
    }
}

测试类

package multiplethread;
import java.util.ArrayList;
import java.util.List;
public class TestThread {
    public static boolean found = false;
    public static void main(String[] args) {
        String password = randomString(3);
        System.out.println("密码是:" + password);
        List<String> passwords = new ArrayList<>();
        //启动猜测密码进程
        new PasswordThread(password,passwords).start();
        //启动输出密码日志进程
        new LogThread(passwords).start();
    }
  	//随机生成密码
    private static String randomString(int length) {
        String pool = "";
        for (short i = '0'; i <= '9'; i++) {
            pool += (char) i;
        }
        for (short i = 'a'; i <= 'z'; i++) {
            pool += (char) i;
        }
        for (short i = 'A'; i <= 'Z'; i++) {
            pool += (char) i;
        }
        char cs[] = new char[length];
        for (int i = 0; i < cs.length; i++) {
            int index = (int) (Math.random() * pool.length());
            cs[i] = pool.charAt(index);
        }
        String result = new String(cs);
        return result;
    }
}


总结：
通过这个小实验，使我深刻的体会到了守护进程的好处，其特点时当所有进程都为守护进程的时候，择关闭进程，这个小实验就是进行了同时进行密码猜测进程和日志输出进程，当猜测出密码后，虽然说日志还需要输出进几万条数据，但是犹豫守护进程的特性，直接停止了所有进程。节省了时间与空间的浪费。