How do I use the when expression as a switch alternative in Kotlin?

By I Wayan Saryada in Kotlin 0 Comment

In Kotlin, the when expression can be used as an alternative to the traditional switch statement found in languages like Java. The when expression is versatile, concise, and supports a wide range of matching conditions. Here’s how you can use it:

Examples of Using the when Expression

  1. Using when as a simple switch: 
    fun getResponse(code: Int): String {
   return when (code) {
       200 -> "OK"
       404 -> "Not Found"
       500 -> "Internal Server Error"
       else -> "Unknown Code"
   }
}
  2. Multiple matches for a single branch:
    You can check multiple values by separating them with a comma.

    fun isWeekend(day: String): Boolean {
   return when (day) {
       "Saturday", "Sunday" -> true
       else -> false
   }
}
  3. Range checking:
    You can check if a value falls within a certain range.

    fun categorizeAge(age: Int): String {
   return when (age) {
       in 0..12 -> "Child"
       in 13..19 -> "Teenager"
       in 20..59 -> "Adult"
       else -> "Senior"
   }
}
  4. Type checking:
    The is keyword can be used to check the type of a variable.

    fun describe(obj: Any): String {
   return when (obj) {
       is String -> "It's a string of length ${obj.length}"
       is Int -> "It's an integer"
       else -> "Unknown type"
   }
}
  5. Checking conditions (arbitrary boolean expressions):
    You can use boolean expressions inside the when expression.

    fun checkNumber(num: Int): String {
   return when {
       num < 0 -> "Negative Number"
       num == 0 -> "Zero"
       num > 0 -> "Positive Number"
       else -> "Unknown"
   }
}
  6. when without an argument:
    You can omit the argument from when if you just want to match conditions.

    fun getResult(value: Int): String {
   return when {
       value % 2 == 0 -> "Even"
       value % 2 != 0 -> "Odd"
       else -> "Unknown"
   }
}

when as an Expression vs Statement

In Kotlin, when is an expression, which means it can return a value:

val message = when (val age = 25) {
    in 0..12 -> "You're a child"
    in 13..19 -> "You're a teenager"
    else -> "You're an adult"
}
println(message)

But you can also use it as a statement if you don’t need the result:

fun printMessage(code: Int) {
    when (code) {
        200 -> println("Request was successful")
        404 -> println("Resource not found")
        else -> println("Unexpected response code")
    }
}

Summary

The when expression in Kotlin allows for cleaner and more expressive code compared to a traditional switch statement. It supports:

  • Multiple case matching.
  • Type checking.
  • Arbitrary conditions.
  • Use as a statement or an expression.

This flexibility makes it a powerful tool for decision-making in Kotlin!

How do I throttle concurrent threads using ThreadPoolExecutor settings?

By I Wayan Saryada in Concurrency 0 Comment

To throttle concurrent threads using ThreadPoolExecutor settings in Java, you can configure its key parameters: core pool size, maximum pool size, and queue capacity. These settings control how ThreadPoolExecutor manages the number of concurrently running threads and queued tasks.

Explanation of Key ThreadPoolExecutor Settings:

  1. Core Pool Size:
    • This defines the number of threads that are kept in the pool even when they are idle.
    • If the number of actively running threads is less than the core pool size, a new thread is created to handle a task, even if there are idle threads.
  2. Maximum Pool Size:
    • This is the maximum number of threads that can exist in the pool.
    • If the pool reaches this limit, tasks are queued instead of creating new threads.
  3. Queue Capacity:
    • A BlockingQueue is used to hold tasks that are waiting to execute.
    • If the queue is full and the number of active threads is already at the maximum pool size, new tasks will be rejected according to the specified RejectedExecutionHandler.

By adjusting these parameters, you can throttle the number of active threads, controlling concurrency.

Steps to Throttle Threads:

  1. Use a Fixed Maximum Pool Size:
    Set a value for corePoolSize and maximumPoolSize, controlling the maximum number of threads allowed to execute concurrently.

  2. Configure the Queue Size:
    Use a bounded queue (e.g., ArrayBlockingQueue) with a fixed size to limit the number of pending tasks. Once the queue is full, no additional tasks will be accepted unless threads become available.

  3. Avoid Overloading the System:
    Ensure that the total number of threads and tasks in the queue doesn’t overwhelm system resources like CPU or memory.

Example Solution:

package org.kodejava.util.concurrent;

import java.util.concurrent.*;

public class ThreadPoolThrottle {
   public static void main(String[] args) {
      // Define Executor settings
      int corePoolSize = 5;  // Minimum threads
      int maxPoolSize = 10;  // Maximum threads
      int queueCapacity = 20; // Queue size
      long keepAliveTime = 1; // Threads idle time in seconds

      // Create a ThreadPoolExecutor
      ThreadPoolExecutor executor = new ThreadPoolExecutor(
              corePoolSize,
              maxPoolSize,
              keepAliveTime,
              TimeUnit.SECONDS,
              new ArrayBlockingQueue<>(queueCapacity),
              new ThreadPoolExecutor.CallerRunsPolicy() // Rejected tasks run in the caller thread
      );

      // Submit tasks to throttle
      for (int i = 0; i < 50; i++) {
         final int taskID = i;
         executor.execute(() -> {
            try {
               System.out.println("Task " + taskID + " is running");
               Thread.sleep(1000); // Simulate work
            } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
            }
         });
      }

      // Shut down the executor
      executor.shutdown();
   }
}

Key Points in the Example:

  1. The corePoolSize is 5, meaning at least 5 threads are always active.
  2. The maximum number of threads is limited to maxPoolSize, which is 10 threads.
  3. ArrayBlockingQueue with a size of 20 prevents too many pending tasks from being enqueued at once.
  4. RejectedExecutionHandler.CallerRunsPolicy ensures that tasks are executed in the caller thread when the queue is full, preventing silent task rejection.

Resulting Throttling Behavior:

  1. No more than 10 threads will run concurrently.
  2. A maximum of 20 tasks will be queued at any time.
  3. Tasks beyond the queue/throttle limit are forced to run in the caller thread or handled by a custom rejection policy.

By tweaking these settings, you can fine-tune thread throttling behavior for specific performance and resource requirements.

How do I process tasks as they complete using CompletionService?

By I Wayan Saryada in Concurrency 0 Comment

To process tasks as they complete using a CompletionService in Java, you can take advantage of the ExecutorCompletionService. This class provides a mechanism to submit tasks for execution and retrieve their results in the order of completion, rather than the order of submission.

Key Steps for Using CompletionService:

  1. Create an ExecutorService: This handles the thread pooling for concurrent task execution.
  2. Create an ExecutorCompletionService: Wrap the ExecutorService in an ExecutorCompletionService.
  3. Submit Tasks: Use the submit method to submit tasks to the CompletionService.
  4. Process Results as They Complete: Retrieve the results using the poll or take methods of CompletionService.

Example Code:

package org.kodejava.util.concurrent;

import java.util.concurrent.*;

public class CompletionServiceExample {

   public static void main(String[] args) throws InterruptedException {
      int numTasks = 5;

      // Step 1: Create an ExecutorService with fixed thread pool
      ExecutorService executorService = Executors.newFixedThreadPool(3);

      // Step 2: Create an ExecutorCompletionService
      CompletionService<String> completionService = new ExecutorCompletionService<>(executorService);

      // Step 3: Submit tasks to the CompletionService
      for (int i = 0; i < numTasks; i++) {
         int taskId = i;
         completionService.submit(() -> {
            Thread.sleep((long) (Math.random() * 2000)); // Simulate work
            return "Result from Task " + taskId;
         });
      }

      // Step 4: Process tasks as they complete
      for (int i = 0; i < numTasks; i++) {
         try {
            Future<String> resultFuture = completionService.take(); // Retrieves the next completed task
            String result = resultFuture.get(); // Blocks until the result is available
            System.out.println(result);
         } catch (ExecutionException e) {
            System.err.println("Task execution failed: " + e.getMessage());
         }
      }

      // Shutdown the ExecutorService
      executorService.shutdown();
   }
}

Explanation of the Code:

  1. ExecutorService: A thread pool of 3 worker threads is created using Executors.newFixedThreadPool(3).
  2. ExecutorCompletionService: Wraps the ExecutorService to handle submission and retrieval of tasks.
  3. Submitting Tasks: Each task is computed in the background and asynchronously submitted to the completionService.
  4. Result Retrieval:
    • The completionService.take() method blocks until the next completed task result is available.
    • completionService.poll() could also be used if you want non-blocking retrieval (e.g., you check if a result is ready).

  5. Task Results in Completion Order: Results are processed as tasks complete, regardless of their submission order.

When to Use CompletionService

  • When you want to process tasks as they finish, rather than waiting for all tasks to complete.
  • In scenarios where tasks may have uneven execution times, and you want to immediately handle the results of the fastest tasks.

How do I cancel long-running tasks in ExecutorService?

By I Wayan Saryada in Concurrency 0 Comment

To cancel long-running tasks in an ExecutorService, you can use the Future object returned when you submit a task and invoke its cancel method. Below are the steps and some important considerations for canceling tasks:

1. Submit Tasks to the ExecutorService

When you submit a task to an ExecutorService, it returns a Future object that can be used to monitor the task’s progress and cancel it if needed.

ExecutorService executor = Executors.newFixedThreadPool(2);

Future<?> future = executor.submit(() -> {
    // Simulate a long-running task
    try {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Running...");
            Thread.sleep(1000);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // Restore the interrupted status
        System.out.println("Task interrupted.");
    }
});

2. Cancel the Task

To cancel the task, invoke the cancel method on the Future object:

// Cancel the task after 5 seconds
Thread.sleep(5000); // Simulating some delay
boolean wasCancelled = future.cancel(true); // true means interrupt if running

System.out.println("Task cancelled: " + wasCancelled);
  • cancel(true) attempts to stop the execution of the task by interrupting the thread running it. For this to work, the task must regularly check its interrupted status (via Thread.interrupted() or Thread.currentThread().isInterrupted()) and gracefully terminate if interrupted.
  • cancel(false) does not interrupt the running task but prevents it from starting if it hasn’t already begun.

3. Handle Interruption Gracefully

For the cancellation to work, ensure that the task checks the interrupted status and responds accordingly. The task should periodically call Thread.interrupted() or Thread.currentThread().isInterrupted() to detect interruptions.

try {
    while (!Thread.currentThread().isInterrupted()) {
        // Simulate work
        System.out.println("Working...");
        Thread.sleep(1000); // This can throw InterruptedException
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // Re-set the interrupted status
    System.out.println("Task interrupted and exiting.");
}

4. Shutdown the ExecutorService

Once you’re done submitting tasks, shut down the ExecutorService to release resources:

executor.shutdown(); // Wait for running tasks to complete
try {
    if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
        executor.shutdownNow(); // Forcefully shut down if tasks don't finish in time
    }
} catch (InterruptedException e) {
    executor.shutdownNow(); // Force an immediate shutdown
    Thread.currentThread().interrupt(); // Reset the interrupted status
}

Keynotes

  • Interruptible Tasks: The tasks you submit must be designed to handle interruptions for cancellation to effectively work. For example, long-running loops or blocking calls should handle the interrupted status.
  • Blocking Methods: If the task is waiting on a blocking call (e.g., Thread.sleep(), Object.wait(), Future.get()), calling cancel(true) will usually interrupt these methods.
  • Non-Interruptible Work: If the task is not interruptible (e.g., performing intensive computations without checking the interrupted flag), cancel(true) will not have an immediate effect.
  • Future API: You can also check the status of a task using methods like isDone(), isCancelled() before or after attempting to cancel it.

This approach ensures your long-running task can be terminated gracefully and resourcefully.

How do I use default and named arguments in Kotlin functions?

By I Wayan Saryada in Kotlin 0 Comment

In Kotlin, you can use default arguments and named arguments to simplify function calls and make your code more readable and flexible. Here’s how each of them works:

Default Arguments

  • Default arguments allow you to set a default value for a function parameter. If you don’t pass a value for that parameter when calling the function, the default value will be used.
  • You define default values by assigning them directly in the function definition.

Example:

fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

// Usage:
// Default value for "greeting" is used => Output: "Hello, Alice!"
greet("Alice")
// Provided value overrides the default => Output: "Hi, Bob!"
greet("Bob", "Hi")

Named Arguments

  • Named arguments allow you to explicitly specify which parameter you’re setting a value for, by using the parameter name when calling the function.
  • This is particularly useful when a function has many parameters, especially if some of them have default values.

Example:

fun createAccount(username: String, email: String, isAdmin: Boolean = false) {
    println("Username: $username, Email: $email, Admin: $isAdmin")
}

// Usage:
// isAdmin takes the default value => 
// Output: Username: user1, Email: [email protected], Admin: false
createAccount("user1", "[email protected]")
// All arguments provided normally => 
// Output: Username: admin, Email: [email protected], Admin: true
createAccount("admin", "[email protected]", true)
// Named arguments make the order flexible => 
// Output: Username: user2, Email: [email protected], Admin: false
createAccount(email = "[email protected]", username = "user2")

Combining Default and Named Arguments

You can combine these features to make function calls more flexible:

Example:

fun printBookInfo(title: String, author: String = "Unknown", year: Int = 2023) {
    println("Title: $title, Author: $author, Year: $year")
}

// Usage:
// Only title is provided; others use defaults
printBookInfo("Kotlin for Beginners")                    
// Output: Title: Kotlin for Beginners, Author: Unknown, Year: 2023

// Override the default value of 'year'
printBookInfo("Advanced Kotlin", year = 2020)            
// Output: Title: Advanced Kotlin, Author: Unknown, Year: 2020

// Arguments in a different order with named arguments
printBookInfo(author = "John Doe", title = "My Journey") 
// Output: Title: My Journey, Author: John Doe, Year: 2023

Rules and Notes:

  • If a parameter has no default value, it must always be passed.
  • Once you start using named arguments in a function call, all subsequent arguments should be named as well.
  • Named arguments improve clarity in cases of multiple parameters with the same type or where parameter order can be confusing.

By combining default arguments and named arguments, you can create more flexible, readable, and maintainable functions in Kotlin.