Thread-Safe Counter

/*
 * Problem : Count with many threads.
 * Input   : Threads t and increments c.
 * Output  : The final counter.
 * Approach: Make each increment atomic.
 * Time    : O(t * c)
 * Space   : O(t)
 * Java    : 8 or newer.
 */
import java.util.Scanner;

public class Main {
    // This method solves the task. It receives the input and returns the answer.
    static long solve(long a, long b) {
        // Step 1: AtomicLong makes each increment one single step that other threads can not interrupt.
        // A normal long with counter++ is three steps (read, add, write), and threads can lose updates.
        java.util.concurrent.atomic.AtomicLong counter = new java.util.concurrent.atomic.AtomicLong();
        Thread[] workers = new Thread[(int) a];

        // Step 2: Start t threads. Each one increments the counter c times.
        for (int w = 0; w < workers.length; w++) {
            workers[w] = new Thread(() -> {
                for (long i = 0; i < b; i++) {
                    counter.incrementAndGet();
                }
            });
            workers[w].start();
        }

        // Step 3: Wait for all threads.
        for (Thread worker : workers) {
            try {
                worker.join();
            } catch (InterruptedException error) {
                Thread.currentThread().interrupt();
            }
        }
        return counter.get();
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long a = scanner.nextLong();
        long b = scanner.nextLong();
        System.out.println(solve(a, b));
    }
}