package com.cwt.study.java中级.S_20240725;

public class Test {
   /* 英雄有可以放一个技能叫做: 波动拳-a du gen。
    每隔一秒钟，可以发一次，但是只能连续发3次。
    发完3次之后，需要充能5秒钟，充满，再继续发。
    借助本章节学习到的知识点，实现这个效果*/
    public static void main(String[] args) {

        Thread t1 = new Thread(){
            int i =0;
            public void run(){
                while (true){
                    if (i<3){
                        i++;
                        System.out.println("发射"+i+"次攻击!");
                        try {
                            Thread.sleep(1000);
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }else {
                        System.out.println("充能5秒");
                        try {
                            Thread.sleep(5000);
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                        i=0;
                    }

                }
            }
        };
        t1.start();
    }
}

public class TestThread {
	private static String code;
	public static void main(String[] args)
	{
		code = HelloWorld.getRandomStr(3);
		DecodeTest dt = new DecodeTest(code.length());
		new Thread(()->{
			while(!logincode(dt.getTempCode()))//尝试用临时解密码登录
			dt.deCode();
		}).start();
		Thread guardThread = new Thread(()->{
			while(dt.codeList.size()>0)
			{
				String first = dt.codeList.pollFirst();
				if(first==null)break;
				System.out.println("记录 Key = "+first);
				if(code.equals(dt.getTempCode()))
				{
					Thread.yield();
					break;
				}
			}
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		});
		//guardThread.setDaemon(true);
		guardThread.start();
	}
	//尝试登录
	public static boolean logincode(String userInput)
	{
		boolean res = code.equals(userInput);
		if(res)
System.out.println(String.format("登录成功！code：%s，userInput：%s", code,userInput));
		return res;
	}
}

---------------------下面为解密方法类------------------------

package testThread;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

import j2se.MyStack;

public class DecodeTest{
	public LinkedList<String> codeList;
	private int bit;// 密码位数
	private int[]tempCodeID;//临时记位
	private String tempCode;
	public DecodeTest(int codeLength) {
		codeList = new LinkedList<String>();
		bit = codeLength;
		reset();
	}
	public void reset()
	{
		tempCodeID = new int[bit];
		Arrays.fill(tempCodeID, '0');
	}
	public String getTempCode()
	{
		return tempCode;
	}
	// 解密，提供正确答案，程序穷举所有可能的字母组合，直到与答案吻合为止。
	public void deCode() {
		// System.out.println("is decoding " + step);
		addCode(tempCodeID, bit - 1);
		String res = "";
		for (int i : tempCodeID) {
			res += (char) i;
		}
		tempCode = res;
		codeList.add(res);
		//res = String.format("解出的答案为：%s，原密码为%s%n共进行了%d步", res, code, step);
		//System.out.println(res);
	}

	// 检查解密的结果每一位的ASCII值是否与答案相同
	public boolean checkCorrect(String code) {
		char[] cs = code.toCharArray();
		for (int i = 0; i < bit; i++) {
			if ((int) cs[i] != tempCodeID[i])
				return false;
		}
		return true;
	}

	// 采用ASCII码进位的方式，'Z'跳跃'a'，'z'进位的原理来实现穷举所有字母组合的过程。
	// 'A'的ASCII值最小为65，'Z'的值为90，'a'的值为97，'z'的值最大为122；
	// 其中'Z'到'a'之间的ASCII值不是字母，也就是90-122之间的数无效;因此进位时，当前位数值为'Z'时，增加数值时需要跳转到'a'
	// 当当前位数值为最大值，也就是'z' = 90 时，需要进一位，也就是前一位需要增一；当前位“归零”，也就是归为最小值'A'。
	public void addCode(int[] id, int addIndex) {
		if (addIndex < 0)
			return; // 当进位到最高位时结束递归
		if (addIndex > id.length - 1)
			return; // 当进位索引溢出时结束递归

		int last = id[addIndex]; // 取进位数（递归前为个位数，递归为上一次递归进位索引的前一位）
		if(last=='9')
		{
			id[addIndex] = 'A';
			//addCode(id, addIndex - 1);
		}
		else if (last < 'z')
			id[addIndex] = last + 1; // 当进位数小于最大值'z'时，当前位数的值加一

		if (last == 'Z') { // 当进位数为'Z'，该位跳跃到'a'；a的ASCII值大于Z
			id[addIndex] = 'a';
		} else if (last == 'z') // 当进位数到达最大值
		{
			id[addIndex] = '0';
			addCode(id, addIndex - 1);
		}

	}

}

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

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class practiceThread2 {

    public static void main(String[] args) {
//        1.生成一个长度是3的随机字符串，把这个字符串当作 密码
        Random random = new Random();
        String randomString;
        List<String> passwd = new ArrayList<>();
        passwdGenerate pwd=new passwdGenerate();
        randomString= pwd.Generate();

        System.out.println("生成的密码是："+randomString);
//        2. 创建一个破解线程，使用穷举法，生成密码
        Thread crackThread = new Thread(){
            public void run() {

                boolean isSuccess=false;
                String str;
                while (!isSuccess) {

                    str=pwd.Generate();
                    if(!randomString.equals(str)){
                        System.out.println("使用了密码:"+str+"进行匹配");
                        passwd.add(str);

                    }else{
                        System.out.println("破解成功，密码是："+str);
                        isSuccess=true;
                    }
                }
                }
        };
   //      3. 创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程

        String finalRandomString1 = randomString;
        Thread logThread = new Thread(){
            public void run() {
                boolean isSuccess=false;
                while (!isSuccess) {
                    if(passwd.isEmpty()){
                        try {
//                            如果发现容器是空的，就休息1秒
                            Thread.sleep(1000);
                            System.out.println("休息1秒");
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    while (true){
                        System.out.println("使用了密码:"+passwd.get(0)+"进行匹配");
                        passwd.remove(0);
                    }

                    }
            }
        };
        crackThread.setPriority(Thread.MAX_PRIORITY);
        logThread.setPriority(Thread.MIN_PRIORITY);
        crackThread.start();
        logThread.setDaemon(true);
        logThread.start();

    }
    }

public class ThreadDemo2 {
	public static void main(String[] args) {
		new Thread(() -> {
			Hero h = new Hero("盖伦", 490, 500) ;
			int num = 1 ;
			while(true) {
				h.bodong(num);
				num ++ ;
				if(num > 3) {
					num = 1 ;
				}
			}
		}).start() ;
	}
}