Interview Questions and Answers

In Java, unnamed modules and packages are a familiar concept. When we do not create a module-info.java class then the module is automatically assumed by the compiler. Similarly, if we do not add the package statement in the class in the root directory, the class just compiles and runs fine.

Same way, we can now create unnamed classes. Quite obviously, an unnamed class is a class without a name.

Example:

// Prior to Java 21

public class TestAConcept {

  public static void main(String[] args) {

    System.out.println(method());

  }

  static String method() {

    //...

  }

}

From Java 21, we can write the above class without the class declaration as follows. It removes the class declaration, public and static access modifiers etc. to have a cleaner class.

// In Java 21

void main(String[] args) {

  System.out.println(method());

}

String method() {

  //...

}

If you are familiar with ThreadLocal variables, the scoped values are a modern way of sharing data within and across threads. Scoped values allow a value (object) to be stored for a limited time in such a way that only the thread that wrote the value can read it.

Scoped values are usually created as public static fields so we can access them directly without passing them as a parameter to any method. However, it is important to understand that if the value is checked in multiple methods, the current value will depend on the execution time and state of the thread. The value may change over time when accessed over time in different methods.

To create scoped values, use the ScopedValue.newInstance() factory method.

public final static ScopedValue<USER> LOGGED_IN_USER = ScopedValue.newInstance();

To create scoped values, use the ScopedValue.newInstance() factory method.

public final static ScopedValue<USER> LOGGED_USER = ScopedValue.newInstance();

With ScopedValue.where(), we bind the scoped value to the object instance; and then we run a method, for whose call duration the scoped value should be valid. Note that a scoped value is written once and is then immutable, thus nobody can change the loggedInUser in the invoked method.

class LoginUtil {

 

public final static ScopedValue<USER> LOGGED_USER = ScopedValue.newInstance();

 

  //Inside some method

  User loggedInUser = authenticateUser(request);

  ScopedValue.where(LOGGED_USER, loggedInUser).run(() -> service.getData());

}

Inside the invoked thread, we can directly access the scoped value:

public void getData() {

 

  User loggedInUser = LoginUtil.LOGGED_USER.get();

  //use loggedUser

}

The structured concurrency feature aims to simplify Java concurrent programs by treating multiple tasks running in different threads (forked from the same parent thread) as a single unit of work. Treating all such child threads as a single unit will help in managing all threads as a unit; thus, canceling and error handling can be done more reliably.

In structured multi-threaded code, if a task splits into concurrent subtasks, they all return to the same place i.e., the task’s code block. This way, the lifetime of a concurrent subtask is confined to that syntactic block.

In this approach, subtasks work on behalf of a task that awaits their results and monitors them for failures. At run time, structured concurrency builds a tree-shaped hierarchy of tasks, with sibling subtasks being owned by the same parent task. This tree can be viewed as the concurrent counterpart to the call stack of a single thread with multiple method calls.

In this approach, subtasks work on behalf of a task that awaits their results and monitors them for failures. At run time, structured concurrency builds a tree-shaped hierarchy of tasks, with sibling subtasks being owned by the same parent task. This tree can be viewed as the concurrent counterpart to the call stack of a single thread with multiple method calls.

try (var scope = new StructuredTaskScope.ShutdownOnFailure()()) {

 

    Future<AccountDetails> accountDetailsFuture = scope.fork(() -> getAccountDetails(id));

    Future<LinkedAccounts> linkedAccountsFuture = scope.fork(() -> fetchLinkedAccounts(id));

    Future<DemographicData> userDetailsFuture = scope.fork(() -> fetchUserDetails(id));

 

    scope.join(); // Join all subtasks created

    scope.throwIfFailed(e -> new WebApplicationException(e));

 

    //The subtasks have completed by now so process the result

    return new Response(accountDetailsFuture.resultNow(), 

    linkedAccountsFuture.resultNow(),

    userDetailsFuture.resultNow());

}

GraalVM for JDK 21 binaries are free to use in production and free to redistribute, at no cost, under the GraalVM Free Terms and Conditions (GFTC).

GraalVM for JDK 21 will receive updates under the GFTC, until September 2026, a year after the release of the next LTS. Subsequent updates of GraalVM for JDK 21 will be licensed under the GraalVM OTN License Including License for Early Adopter Versions (GOTN) and production use beyond the limited free grants of the GraalVM OTN license will require a fee.

Oracle GraalVM uses the Graal just-in-time compiler and includes the Native Image feature as optional early adopter technology.

You can download GraalVM for JDK 21 from Oracle website: Download GraalVM for JDK 21

Please check the details here on GraalVM for Java 21:

GraalVM for Java 21