Sure, here is a simple Java program that simulates a countdown timer using multithreading.

```java
import java.util.concurrent.*;

public class CountdownTimer implements Runnable {
private final int timeToCount;

public CountdownTimer(int timeToCount) {
this.timeToCount = timeToCount;
}

@Override
public void run() {
try {
for (int i = timeToCount; i = 0; i--) {
System.out.println(Thread.currentThread().getName() + ": " + i);
TimeUnit.SECONDS.sleep(1);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}

public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();

executorService.execute(new CountdownTimer(10));
executorService.execute(new CountdownTimer(5));

executorService.shutdown();
}
}
```

In this program, we have a `CountdownTimer` class that implements `Runnable`. This class has a `timeToCount` field that represents the time to count down from. The `run` method counts down from `timeToCount` to 0, printing the current count every second.

In the `main` method, we create an `ExecutorService` to manage our threads. We then start two countdown timers, one that counts down from 10 and one that counts down from 5. These timers run concurrently, each in their own thread.

The `ExecutorService` is then shut down, which will cause the program to exit once all timers have finished.

The sample input would be the time to count down from, which is passed to the `CountdownTimer` constructor. The output would be the countdown printed to the console.

Question

Sure, here is a simple Java program that simulates a countdown timer using multithreading.

```java
import java.util.concurrent.*;

public class CountdownTimer implements Runnable {
    private final int timeToCount;

public CountdownTimer(int timeToCount) {
        this.timeToCount = timeToCount;
    }

@Override
    public void run() {
        try {
            for (int i = timeToCount; i >= 0; i--) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

executorService.execute(new CountdownTimer(10));
        executorService.execute(new CountdownTimer(5));

executorService.shutdown();
    }
}
```

In this program, we have a `CountdownTimer` class that implements `Runnable`. This class has a `timeToCount` field that represents the time to count down from. The `run` method counts down from `timeToCount` to 0, printing the current count every second.

In the `main` method, we create an `ExecutorService` to manage our threads. We then start two countdown timers, one that counts down from 10 and one that counts down from 5. These timers run concurrently, each in their own thread.

The `ExecutorService` is then shut down, which will cause the program to exit once all timers have finished.

The sample input would be the time to count down from, which is passed to the `CountdownTimer` constructor. The output would be the countdown printed to the console.

Knowee AI · Accepted Answer