Java Threads – an Introduction for all Skill Levels

Today we are talking about threads in Java. Threads are an essential means to implement concurrent algorithms and are therefore a key part of efficient everyday data processing. Imagine having a webserver without threads serving only one customer at a time: Every customer would need to pull a number for every single web request they make and our online shop would have a bad time.

So let’s head into it!

In modern days – Java threads with Lambda expressions

Since Java 8 we have been blessed with Lambda expression. Basically Lambda expressions serve the purpose of unnamed functions and are written as shown here:

(param1, param2, [...], paramN) -> {
    statement1; 
    statement2;
    [...]
    statementN;
}

If you just need one statement, it looks even better:

(param1, [...], paramN) -> statement

By harnessing their power we are able to write beautiful first level function style concurrent algorithms.

Let’s assume we want to sort a list with an even number of integers. We know that all ints in the second half of the list are greater than the greates number in the first half. Then we can do this:

import java.util.*;

public class ThreadExampleMain {

    public static void main(String[] args) throws InterruptedException {
        /* Elements of the 2nd half are larger than in the 1st half, otherwise unsorted. */
        List<Integer> test = Arrays.asList(3, 1, 5, 6, 21, 12, 18, 16);
        List<Integer> sortedFirstHalf = test.subList(0, 4);
        List<Integer> sortedSecondHalf = test.subList(4, 8);

        Thread t1 = new Thread(() -> {
            Collections.sort(sortedFirstHalf); // or any other more elaborate sorting algorithm
            System.out.println("First half sorted: " + sortedFirstHalf);
        });

        Thread t2 = new Thread(() -> {
            Collections.sort(sortedSecondHalf);
            System.out.println("Second half sorted: " + sortedSecondHalf);
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // Merge the sorted list parts together from left to right...
        List<Integer> result = new ArrayList<>();
        result.addAll(sortedFirstHalf);
        result.addAll(sortedSecondHalf);

        // ...and show the result.
        System.out.println("Result: " + result);
    }

}

Try it out!

Notice that we feed the threads in our Java code with Lambdas to tell them what to do. Neat, isn’t it?

Legacy Java Threads with Runnable instances

And how has it been done in the past? When I started programming with Java around 5 and 6 we had to declare a full-blown Runnable-instance that we subsequently fed to the thread. Runnable is an interface type which means that during declaration we also had to implement it’s signature method run(). This method finally contains the functionality that the thread is supposed to run. Let me show what I mean:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ThreadExampleLegacyMain {

    public static void main(String[] args) throws InterruptedException {
        /* Elements of the 2nd half are larger than in the 1st half, otherwise unsorted. */
        List<Integer> test = Arrays.asList(3, 1, 5, 6, 21, 12, 18, 16);
        List<Integer> sortedFirstHalf = test.subList(0, 4);
        List<Integer> sortedSecondHalf = test.subList(4, 8);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Collections.sort(sortedFirstHalf); // or any other more elaborate sorting algorithm
                System.out.println("First half sorted: " + sortedFirstHalf);
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Collections.sort(sortedSecondHalf);
                System.out.println("Second half sorted: " + sortedSecondHalf);
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // Merge the sorted list parts together from left to right...
        List<Integer> result = new ArrayList<>();
        result.addAll(sortedFirstHalf);
        result.addAll(sortedSecondHalf);

        // ...and show the result.
        System.out.println("Result: " + result);
    }

}

Try it out!

It was a bloated mess, but since it’s likely in use in modern day code, we got to list it here.

Conclusion

So long. I hope I could help you effectively processing data by leveraging the power of Java threads. Please note that the examples shown above are optimized for illustration of the topic only. Your way to sort a list of integers is certainly much better. If you’d like to read more about me doing Java, I have a post for you, where I talk about web test automation with Java. If you are already familiar with that and want to try something new, I recommend trying fuzz testing in Java. You will gain a fresh view on test automation and honestly it’s a blast to bomb an application with just random stuff.

Last but not least, if you want to dive in really deep into the world of Java threads, check out this article about Thread Pooling. It is quite advanced, but intuitive and powerful once you get the hang of it.

You have more questions regarding Java, me or anything else? As usual, feel free to drop me a line down below. I read every single one of your comments. Have a great day!

Home » coding
Share it with:

Character array is missing „e“ notation exponential mark

I observed that many people out there visiting my blog have great interest in a particular NumberFormatException. It goes by the message Character array is missing „e“ notation exponential mark and was mentioned in my post about fuzzing in Java.

Today we will take a more in depth look at it.

How does that NumberFormatException look like?

To visualize the error effectively, let’s look at the following extreme example drawn from my fuzzing post mentioned above.

Consider the following (sub-par implemented) function dollar2euro that takes any input (hopefully it’s a number though!) and tries to convert it from USD to EUR:

public String dollar2euro(Object input){
    BigDecimal inputParsed = new BigDecimal(input.toString());
    BigDecimal dollars = inputParsed.setScale(2, BigDecimal.ROUND_HALF_EVEN);

    BigDecimal multiply = dollars.multiply(BigDecimal.valueOf(0.92));
    BigDecimal euros = multiply.setScale(2, BigDecimal.ROUND_HALF_EVEN);
    return String.valueOf(euros);
}

Now what happens, if we play along the method signature and put in the following characters: „뤇皽“? If you know what they mean, feel free to drop me a comment down below. Please note that this is exactly what my fuzztest tried to do. And of course it drops a heavy NumberFormatException upon us:

Input: 뤇皽
java.lang.NumberFormatException: Character 뤇 is neither a decimal digit number, decimal point, nor "e" notation exponential mark.

And what does it mean?

The problem here is that „뤇皽“ is not a number. The first and second part Character 뤇 is neither a decimal digit number, decimal point are straight forward. But what does the third part nor „e“ notation exponential mark mean?

In maths, we have the option of expressing numbers in power form with base 10. This comes in handy when we want to express Googol (the number that inspired Google’s name) – a 1 with 100 zeroes. Accordingly we would write 10100 instead. In Java you can do something very similar, but there are better sources to check how to properly use the e-format. For our context let’s acknowledge that it is a different way of displaying numbers. Which likewise could not be found in our input.

But how do we fix that?

We have to make sure that we provide a String to the BigDecimal Constructor that looks like a valid number – if we want to provide a String at all. An actual number like a double or int would be even better. That would cost us no more than a change in the method’s signature and a small adaption to line 2. If we really want to provide a String, we still can do that, but then we have to make sure that it is properly formatted. A valid input example would be: „1337.012342„.

If you apply this simple rule, you should be spared from ‚Character array is missing „e“ notation exponential mark‘ errors in the future.

Conclusion

So long! I hope this little post gave you an idea about what the error message ‚Character array is missing „e“ notation exponential mark‘ means. Of course this case was kinda constructed and you probably have a less explicit case. If so, feel free to post it in the comments down below and we see what we can do. But for demonstration purposes it should have provided a clear image of what is going on in your program.

As my linked post about fuzzing in Java implies, I’m an avid test automation person. If you want more about automating tests with Java, check out my introduction tutorial about Selenium in Java. If you are more of the Python person, no problem. Here’s the same Selenium tutorial in Python. And if Python and Java are both too mainstream for you, I recommend my tutorial about Cucumber in Rust .

Happy test automating & have a nice day!

Home » coding
Share it with: