如何从嵌套在 while 循环中的 if 语句定期打印到终端（Java）

Question

I am writing a java application that will hash a series of input values repeatedly until a condition is met. I have accomplished this by nesting a series of if/else statements inside a while loop. I want to be able to print the hash rate to the terminal every 3 seconds while the application is actively hashing, and not repeatedly until the condition is met. I have tried using ExecutorService and scheduling a TimerTask but neither worked the way I wanted them to as they both kept on executing after the condition that should have stopped them was met. I know I am missing something but I don't know what ):

I've included a small snippet, feel free to ask for any information you may think is relevant.

Any help would be greatly appreciated!

I tried using a TimerTask like this:

while(iterator) {
    if (difficulty == 1) {
        if (!hash.startsWith("0")) {
            long updatedTime = System.nanoTime();
            Nonce++;
            long deltaN = updatedTime - startTime;
            long deltaS = (deltaN / 1000000000);
            long hashRate = (Nonce / deltaS);
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("Current hash rate: " + hashRate + " " + "hash/s");
                }
            }, 0, 3000);
        } else {
              System.out.println("Valid hash found! " + hash);
              iterator = false;
        }
    }
}  

EDIT: What this will be when finished is essentially a cheesy 'block chain' I will be using for illustrative purposes as a teaching tool, with that in mind I have included the rest of the 'miner' method below:

public void miner(long index, long currentTimeMillis, long data, long Nonce, String previousBlockHash, int difficulty) throws InterruptedException {
        this.index = index;
        this.currentTimeMillis = currentTimeMillis;
        this.pszTimeStamp = pszTimeStamp;
        this.Nonce = Nonce;
        this.previousBlockHash = previousBlockHash;
        this.difficulty = difficulty;
        this.data = data;
        boolean iterator = true;
        String blockHeader = (index + currentTimeMillis + data + Nonce + previousBlockHash + difficulty);
        String hash = SHA256.generateHash(blockHeader);
        long startTime = System.nanoTime();
        TimeUnit.SECONDS.sleep(2);

        while (iterator) {
            blockHeader = (index + currentTimeMillis + data + Nonce + previousBlockHash + difficulty);
            hash = SHA256.generateHash(blockHeader);
            if (difficulty == 1) {
                if (!hash.startsWith("0")) {
                    long updatedTime = System.nanoTime();
                    Nonce++;
                    long deltaN = updatedTime - startTime;
                    long deltaS = (deltaN / 1000000000);
                    long hashRate = (Nonce / deltaS);
                    System.out.println("Current hash rate: " + hashRate
                } else {
                    System.out.println("\n");
                    System.out.println("Hash found! \n");
                    System.out.println("Mined block hash: \n" + hash);
                }
            } else if (difficulty == 2) {

            ...........

All of the parameters the 'miner' method takes are passed to it by a launching class which includes the main function. My goal is to be able to print the hash rate while it searches for a 'valid' hash every few seconds instead of it printing thousands of times per second.

Answer 1

I have a few suggestions:

• I personally would prefer using break inside a while(true) loop instead of of a loop variable. I feel that it makes the code more readable;

• You are re declaring the Timer inside the loop, which means that a new timer is created each iteration of the loop. You need to create the timer once, outside the loop.

The Timer variable needs to be final to allow you to call timer.cancel() inside the run function of the TimerTask. If you plan on terminating the timer outside the run function, then the Timer variable need not be final.

import java.util.*;

public class Test{
    static double Nonce;

    public static void main(String... args) throws Exception{
        final Timer timer = new Timer();
        timer.schedule(new TimerTask(){
            public void run(){
                //calcualte hashRate by any formula
                double hashRate = Nonce/100.0;

                //check if the timer needs to continue, else call timer.cancel()

                System.out.println(hashRate);
            }
        }, 0, 500);

        while(true){
            Thread.sleep(100);
            Nonce++;

            if(Nonce == 100){
                timer.cancel(); //or terminate the timer outside the loop
                break;
            }
        }  
    }
}

Please let me know if you need any help.

---

Edit:

A few things I have noticed:

• The class variable Nonce cannot be static, otherwise it will be shared amongst all instances of the class.

• The name of the variable cannot be Nonce in the function declaration, otherwise the local copy will be used whenever you use Nonce within the miner function.

• If you do not calculate the hashRate directly, then deltaS can be zero, which may lead to a divide by 0 error.

Please let me know if you need any clarification.

public class ChainBuilder extends MainChain {

    private long index;
    private long currentTimeMillis;
    private long data;
    private int difficulty;
    private String pszTimeStamp;
    private String previousBlockHash;
    private String currentHash;
    private String genesisHash;

    public long Nonce; //Nonce cannot be be static, otherwise it will cause issues if more than one object is created.
    public static long startTime;

.......
public void miner(long index, long currentTimeMillis, long data, long _Nonce /*You cannot use Nonce here*/, String previousBlockHash, int difficulty) throws InterruptedException {
        this.index = index;
        this.currentTimeMillis = currentTimeMillis;
        this.pszTimeStamp = pszTimeStamp;
        this.Nonce = _Nonce; /*In this scope, Nonce refers to the local variable, and this.Nonce refers to the class variable. 
                            If you use Nonce in this scope, then the class variable will not be changed.*/
        this.previousBlockHash = previousBlockHash;
        this.difficulty = difficulty;
        this.data = data;
        boolean iterator = true;
        String blockHeader = (index + currentTimeMillis + data + Nonce + previousBlockHash + difficulty);
        String hash = SHA256.generateHash(blockHeader);
        startTime = System.nanoTime();
        TimeUnit.SECONDS.sleep(2);

        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                long endTime = System.nanoTime();
                long deltaN = endTime - startTime;
                //long deltaS = (deltaN / 1_000_000_000);
                long hashRate = (1_000_000_000 * Nonce / deltaN); /*calculate the hashRate directly, because if deltaN < 1_000_000_000, 
                                                                then deltaS will be 0, giving a divide by zero error.*/
                System.out.println("Current hash rate: " + hashRate + " " + "hash/s");
            }
        }, 0, 3000);
        while (iterator) {
            blockHeader = (index + currentTimeMillis + data + Nonce + previousBlockHash + difficulty);
            hash = SHA256.generateHash(blockHeader);
            if (difficulty == 1) {

                if (!hash.startsWith("0")) {
                    Nonce++;
                } else {
                    System.out.println("Hash found!");
                    timer.cancel();
.......

Answer 2

Okay, so what worked for me was declaring the relevant variables static, putting the start of the timer before loop, and cancelling upon the discovery of a valid hash, like so:

public class ChainBuilder extends MainChain {

    private long index;
    private long currentTimeMillis;
    private long data;
    private int difficulty;
    private String pszTimeStamp;
    private String previousBlockHash;
    private String currentHash;
    private String genesisHash;
    public static long deltaS;
    public static long deltaN;
    public static long Nonce;
    public static long startTime;
    public static long endTime;
    public static long hashRate;
.......
public void miner(long index, long currentTimeMillis, long data, long Nonce, String previousBlockHash, int difficulty) throws InterruptedException {
        this.index = index;
        this.currentTimeMillis = currentTimeMillis;
        this.pszTimeStamp = pszTimeStamp;
        this.Nonce = Nonce;
        this.previousBlockHash = previousBlockHash;
        this.difficulty = difficulty;
        this.data = data;
        boolean iterator = true;
        String blockHeader = (index + currentTimeMillis + data + Nonce + previousBlockHash + difficulty);
        String hash = SHA256.generateHash(blockHeader);
        startTime = System.nanoTime();
        TimeUnit.SECONDS.sleep(2);

        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Current hash rate: " + hashRate + " " + "hash/s");
            }
        }, 0, 3000);
        while (iterator) {
            blockHeader = (index + currentTimeMillis + data + Nonce + previousBlockHash + difficulty);
            hash = SHA256.generateHash(blockHeader);
            if (difficulty == 1) {

                if (!hash.startsWith("0")) {
                    endTime = System.nanoTime();
                    Nonce++;
                    deltaN = endTime - startTime;
                    deltaS = (deltaN / 1000000000);
                    hashRate = (Nonce / deltaS);
                } else {
                    System.out.println("Hash found!");
                    timer.cancel();
.......