DEV Community: Niclas Gleesborg

Navigating CDI Scope in Quarkus: A Concurrency perspective

Niclas Gleesborg — Mon, 02 Jun 2025 06:46:34 +0000

TL;DR
In Quarkus (a tool for building backend services), there are two ways of managing how objects (called beans) are created and used:

Application Scoped (@ApplicationScoped):
Only one object is created and shared by everyone who uses the service.
Good because it saves memory and is fast.
But you must be careful since many people might use it at the same time, which can cause problems.
Request Scoped (@RequestScoped):
A new object is made for each person or request.
Good because it's safe and easy—each user gets their own separate object.
But it uses more memory since many objects are made and then thrown away quickly.
Choosing which one to use depends on balancing how fast your service needs to run versus keeping things safe and simple.

Introduction
Managing the lifecycle and concurrency of service objects is essential in developing performant, robust microservices. Quarkus, a modern Java framework designed for container-native and cloud-native applications, relies heavily on Contexts and Dependency Injection (CDI) to control object lifecycles through annotations known as scopes. Among these, the @ApplicationScoped and @RequestScoped annotations are commonly employed to manage the lifecycle of service objects, directly influencing performance characteristics, memory usage, and concurrency behavior.

The @ApplicationScoped annotation instructs the CDI container to create a single instance of a bean that is shared throughout the application's entire lifecycle. This reuse offers substantial advantages in terms of reduced memory footprint and minimal object instantiation overhead, thereby enhancing runtime efficiency. However, its shared nature inherently introduces concurrency risks, as the single instance is accessible by multiple threads simultaneously. Consequently, improper handling or misunderstanding of thread-safety principles within these beans can lead to race conditions, inconsistent states, or application-wide errors.

In contrast, @RequestScoped beans provide a fresh instance for every individual HTTP request, naturally isolating each request's state. This isolation mitigates thread-safety concerns significantly, simplifying the development model and reducing concurrency-related risks. However, such per-request instantiation comes at the cost of increased object creation and destruction overhead, potentially affecting performance and memory consumption under high load scenarios.

@ApplicationScoped
Definition
@ApplicationScoped is a normal scope in Quarkus, meaning the CDI container creates a single shared instance of the bean for the entire application. This one instance is reused for all injection points and throughout the app’s lifetime. By default, Quarkus instantiates an @ApplicationScoped bean lazily – a client proxy is injected, and the actual bean instance is created only when you first invoke a method on that proxy

In other words, merely injecting an @ApplicationScoped bean doesn’t construct it; the first method call triggers its creation. Once created, all injections refer to the same instance, so any state within an @ApplicationScoped bean is global (application-wide) state

This scope remains active for the entire runtime of the application, making the bean effectively a singleton (in terms of one instance) managed by CDI.

Concurrency
Because there is only one instance of an @ApplicationScoped bean shared across the whole application, concurrency is an important concern. The CDI container does not automatically synchronize access to @ApplicationScoped beans. If multiple threads call methods on the bean at the same time (for example, multiple HTTP requests or background jobs using the same service), those calls happen concurrently on the single instance. By default, nothing in Quarkus makes an @ApplicationScoped bean thread-safe – it’s up to your bean’s implementation to handle concurrent access. If the bean is stateless (no mutable shared fields), it is naturally thread-safe. However, if it maintains any state or mutable data (caches, counters, accumulators, etc.), you must ensure thread-safety. Techniques for ensuring thread-safety is beyond the scope of this article. Treat @ApplicationScoped beans as global singletons that need explicit thread-safety measures when accessed by multiple threads. If a bean’s purpose is purely to provide stateless services (e.g. computations, database access using local variables), you don’t need additional locking. If it does maintain state (in-memory caches, etc.), use thread-safe structures or synchronization. If an @ApplicationScoped bean injects a @RequestScoped bean the @ApplicationScoped bean will be instanced for the specific request using a client proxy thus making it safe to use for the request.

Performance
The @ApplicationScoped scope can be very performance-friendly due to its reuse of a single instance. Memory footprint is minimal for the bean itself (only one instance lives in memory, aside from a small proxy). Creation cost is paid only once, when the bean is first needed, rather than per injection or per call. Lazy instantiation means your application startup isn’t burdened by constructing every single @ApplicationScoped bean up front – they initialize on demand. This can improve startup time if some application-scoped beans are never actually used. However, the first invocation on an @ApplicationScoped bean will incur the cost of creation and any initialization (@PostConstruct logic) – so the very first request or usage might be slightly slower for that bean. After that, all calls are to an already-instantiated object. Just be mindful that if an @ApplicationScoped bean is injected but never used (no method called), it will never be instantiated under Quarkus’s lazy approach – which is efficient (zero cost) but means any initialization code in it won’t run unless triggered. If you require an application bean to initialize at startup (e.g. to pre-load caches), you can force instantiation using mechanisms like the Quarkus @startup annotation or an observer for the startup event, which will call a method and thus initialize the bean eagerly.

Overall, use @ApplicationScoped when you want one instance for the entire app and either no state or shared state. It’s the most common scope for core services that aren’t tied to a specific user or request.

@RequestScoped
Definition
@RequestScoped is a CDI normal scope in Quarkus that ties a bean’s lifespan to an HTTP request. When a request comes into your application (e.g. a REST call), the CDI container will provide a fresh instance of each @RequestScoped bean needed for that request. The bean is created lazily – similarly to application scope – when a method on the bean is first invoked during the request.

It then remains available throughout that single request processing pipeline (potentially across multiple components that all inject the bean). Once the request is complete (response sent), the request context is destroyed and the bean instance is disposed. In short, each HTTP request gets its own instance of the bean, and it exists only for the duration of that request

This scope is automatically active in Quarkus whenever you have the RESTEasy (JAX-RS) or Servlet environment in use. The request context typically covers servlets, filters, JAX-RS resource methods, and any beans used within them.

Concurrency
Under normal conditions, a single HTTP request is handled by one thread at a time, so a @RequestScoped bean instance will not be accessed concurrently by multiple threads (during that request). Each thread/request has its own separate instance, so thread safety is usually not a concern for the bean’s internal state – there’s no shared state across requests by definition. This means you can freely use non-thread-safe structures inside a request bean as long as you don’t leak it out of that request. The isolation provided by the scope prevents concurrency issues between different requests (one request cannot directly access another’s bean instance).

However, there are some caveats. If your application uses asynchronous request handling or reactive processing, you must ensure the request context remains active on threads that continue processing the request. In Quarkus, if you switch threads during a request (for example, using a reactive stream), the request scope might not automatically propagate. Misusing a request-scoped bean outside of its context can lead to unpredictable behavior. Never share a @RequestScoped instance between threads or requests – it should only ever be used within the single request it was created for. Also, if you manually spawn threads inside a request and try to use the request bean there, those threads won’t have the request context unless explicitly carried over. This is a pitfall to avoid (the simpler rule: keep request-scoped usage on the request thread).

Because each request gets a new instance, any state in a @RequestScoped bean is inherently not visible to other requests (no data races across requests). There’s typically no need for synchronization inside such beans unless you perform some concurrent operation within the request itself.

In summary, @RequestScoped beans can be treated as thread-confined to the request. Just be careful not to pass references to them to other threads or cache them beyond the request.

Performance
The overhead of using @RequestScoped beans is generally low and proportional to your request load. For each request, new instances are created as needed and then garbage-collected (or destroyed) afterward. This means there is a bit of churn: if your application handles thousands of requests per second and each request needs a particular request-scoped bean, you will be creating and destroying many instances rapidly. Fortunately, object creation in Java is usually cheap, and Quarkus’s CDI container is optimized for this lifecycle. The container also reuses the context for each request in a streamlined way. One performance benefit of request scope is that it naturally limits scope of data – reducing memory bloat. Also, because Quarkus uses lazy instantiation for normal scopes, a request bean is only allocated if actually used in a given request path. If a particular request doesn’t touch a certain bean, it won’t be created. This avoids unnecessary work.

In summary, @RequestScoped beans have a small per-request cost (construction, injection, destruction) and no cross-request memory usage, which typically leads to a good balance for handling user-specific or request-specific logic. The impact is linear with request volume. As best practice, keep the state in request beans lean (only what’s needed for that request) to minimize overhead.

Getting started with ngrx

Niclas Gleesborg — Fri, 13 Jan 2023 09:55:54 +0000

Getting Started With NGRX in Angular

Getting started with ngrx in angular can be a fairly straightforward process. It is important to understand the basics of the library before diving in too deep. This article will cover some of the basics of ngrx, including what is and why it is useful, discussing some of the data flow concepts involved, and also providing an example of how to get started with it.

What is NGRX?

NGRX is a library that helps manage state in angular applications. It is based on the concept of a redux store, which is a centralized data store where all of an application's state is stored in one location, rather than scattered throughout the application and possibly stored in different services or components. NGRX helps to make sure that state is maintained across multiple components and services, which helps to keep the application more manageable.

Why Use NGRX?

NGRX helps applications remain scalable and maintainable by keeping state centralized and allowing components to communicate with each other without directly altering each other's state. This communication is achieved through ngrx's "action-reducer" pattern, which allows components to emit "actions" and have a "reducer" to handle the action and update the state accordingly.

This pattern helps to ensure that components are not directly manipulating each other's state, which allows for better debugging and maintainability. It also allows for better separation of concerns and a single source of truth when working with data.

Data Flow Concepts

The action-reducer pattern is the cornerstone of ngrx. It is based on the idea that each component or service can emit an action, which is captured by a reducer. This reducer can then be responsible for updating the state of the application. This data flow works by allowing components to emit actions, which are then captured by the reducer and used to update the state of the application.

Getting Started with NGRX

Before diving in to using ngrx, it is important to make sure that you understand the basics of redux, which ngrx is based on.

Once a basic understanding of redux has been achieved, the next step is getting ngrx set up in your angular application. This can be done using the ngrx/store package. This package provides many of the necessary functions to manage an application

Redux

Redux is a library used in JavaScript apps that helps make managing data simple and consistent. It does this by providing an efficient way to store and access data, as well as dispatch actions to change data.

Key Concepts

The core concepts of Redux are actions, reducers, and store.

Actions

Actions are plain objects that are used to send data from your app to your store. They typically include a type field, which is a string that describes the action being performed. Actions are dispatched by a function called an action creator.

Reducers

Reducers are responsible for taking in an action and the current state of the store, and returning a new state. Reducers must be pure functions, meaning that they should always return the same output for a given set of inputs.

Store

The store houses all the data pertaining to your application, and is the only source of truth. The store is composed of the root reducer, state, and any middleware. Middleware give you an opportunity to intercept dispatched actions and do something with them before they reach the reducers.

Benefits of Using Redux

Predicable State Management: Redux ensures that the state of your application is predictable, allowing for easier and faster debugging.
Efficient Data Access: Redux allows for easier and faster access to data, since everything is managed in the same place.
Separation of Concerns: Redux allows for separation of concerns between UI and data logic, making for more efficient and resilient applications.
Cleaner Code: Using Redux leads to cleaner code as it removes the need for complicated logic for data management.

Using Redux in your application can help make it more efficient and easier to manage data.

Setup ngrx in an angular application

Setting up ngrx in an Angular application can be done by following these steps:
(note that code snippets are only meant for demonstration)

Install the ngrx packages by running

npm install @ngrx/store @ngrx/effects @ngrx/entity

in the command line.

In the app.module.ts file, import the StoreModule and EffectsModule and add them to the imports array. Also, add the reducers to the StoreModule's forRoot method.

import { StoreModule } from '@ngrx/store';
import { EffectsModule } from '@ngrx/effects';
import { reducers } from './store/reducers';

@NgModule({
  imports: [
    StoreModule.forRoot(reducers),
    EffectsModule.forRoot([])
  ],
  ...

Create a new folder called store in the src folder. Inside the store folder, create a new file called app.state.ts and define the initial state of the application.

export interface AppState {
  // define the properties of your state here
}

Create new files inside the store folder for actions, effects, and reducers, and define the actions, effects and reducers accordingly.

// actions.ts
import { createAction, props } from '@ngrx/store';

export const loadData = createAction(
  '[App] Load Data',
  props<{ data: any }>()
);

// effects.ts
import { Injectable } from '@angular/core';
import { Actions, createEffect, ofType } from '@ngrx/effects';
import { loadData } from './actions';
import { map, mergeMap } from 'rxjs/operators';

@Injectable()
export class AppEffects {
  loadData$ = createEffect(() =>
    this.actions$.pipe(
      ofType(loadData),
      mergeMap(action => 
        // make an HTTP call to load data
        this.http.get('/api/data').pipe(
          map(data => ({ type: '[App] Data Loaded', payload: data }))
        )
      )
    )
  );

  constructor(private actions$: Actions, private http: HttpClient) {}
}

// reducers.ts
import { createReducer, on } from '@ngrx/store';
import { loadData } from './actions';

export const initialState = {
  data: []
};

export const appReducer = createReducer(initialState,
  on(loadData, (state, { data }) => {
    return { ...state, data };
  })
);

Additionally create a selectors.ts file for the selectors

import { createFeatureSelector, createSelector } from '@ngrx/store';
import { AppState} from './app.state';

const getState = createFeatureSelector<AppState>('featureName');

export const getItems = createSelector(
  getState,
  state => state.items
);

export const getSelectedItem = createSelector(
  getState,
  state => state.selectedItem
);

In your component, import the Store and select from @ngrx/store and use it to subscribe to the state and dispatch actions.

import { Component } from '@angular/core';
import { Store } from '@ngrx/store';
import { loadData } from './store/actions';
import { getItems } from './store/selectors';

@Component({
  selector: 'app-root',
  template: `
    <div *ngFor="let item of data | async">
      {{ item }}
    </div>
    <button (click)="loadData()">Load Data</button>
  `
})
export class AppComponent {
  data = this.store.pipe(select(getItems));

  constructor(private store: Store) {}

  loadData() {
    this.store.dispatch(loadData());
  }
}

Finally, add the effects to the providers array in the app.module.ts file

import { AppEffects } from './store/effects';

@NgModule({
  ...
  providers: [AppEffects],
  ...
})
export class AppModule { }

That's it! You have successfully set up ngrx in your Angular application. You can now use the store to manage the state of your application, handle actions, and perform side-effects using effects.

Getting started with ngrx/store

Niclas Gleesborg — Tue, 10 Jan 2023 12:57:18 +0000

Introduction

NGRX Store is a library for managing state in Angular applications. It is built on top of RxJS, which is a library for reactive programming using Observables. NGRX Store provides a way to organize your application's state into a single, immutable data store, and allows you to manage and update the state using a set of powerful tools and concepts.

NGRX Store uses a centralized store to hold the state of your application, which makes it easy to share the state between different components and services. The state is represented as an Observable, which makes it easy to subscribe to changes and react to them.

NGRX Store also provides a set of powerful tools for managing the state, such as Actions, Reducers, and Effects. Actions are used to represent events that occur in the application, such as a user clicking a button. Reducers are used to update the state based on the actions that occur. And Effects are used to handle side effects, such as making an HTTP request.

By using NGRX Store, you can write more predictable, testable, and maintainable code. It also gives you a consistent way to handle state management across your application, which makes it easier to reason about the behavior of your application.

NGRX also have other packages such as NGRX Effects, NGRX Entity, NGRX Router-Store, etc. which work as extensions to the base NGRX/store and provide more specific functionality.

Benefits of using ngrx/store

There are several benefits to using NGRX Store in your Angular applications:

Centralized state management: By using a centralized store to hold the state of your application, it becomes much easier to share the state between different components and services, and to reason about the behavior of your application.
Immutable state: NGRX Store uses a strict set of rules for managing the state, which ensures that the state is always immutable. This makes it easy to track changes to the state and to undo or revert to previous states if necessary.
Predictable behavior: NGRX Store uses a strict set of rules for managing the state, which makes it easy to predict how the state will change in response to different actions. This helps to make your application more testable and maintainable.
Powerful tools: NGRX Store provides a set of powerful tools for managing the state, such as Actions, Reducers, and Effects. These tools make it easy to handle different types of state changes, and to handle side effects such as making an HTTP request.
Reactive programming: NGRX Store is built on top of RxJS, which provides a powerful set of tools for reactive programming. This makes it easy to subscribe to changes in the state and to react to them in a consistent way.
Scalable: NGRX's architecture is scalable for large and complex application with multiple modules and features. It also handle well in application with high data loads, with good performance.
Testable: NGRX's architecture is testable, due to the separation of state and logic, making it easy to test the different part of your application, such as actions, reducers and effects.
Well established: NGRX is one of the well-established and most popular state management library for Angular application, which is backed by a large and supportive community, with plenty of tutorials and resources available.

Installation

Installing NGRX Store in an Angular application is a two-step process:

Install the NGRX packages: You will need to install the @ngrx/store package, as well as any other packages you want to use, such as @ngrx/effects or @ngrx/entity. You can install them using npm or yarn.

npm install @ngrx/store @ngrx/effects @ngrx/entity

yarn add @ngrx/store @ngrx/effects @ngrx/entity

Import the StoreModule in your app module: After installing the NGRX packages, you will need to import the StoreModule in your app's root module and configure it to use the reducer function that you will create.

import { StoreModule } from '@ngrx/store';
import { reducer } from './reducers';

@NgModule({
  imports: [
    StoreModule.forRoot({ state: reducer })
  ]
})
export class AppModule {}

Note that in the above example I'm importing reducer function from a reducers.ts file. This is where you will define all the logic of your state management using Actions, Reducers, Effects.

You also need to import the store in your component where you want to use it.

import { Store } from '@ngrx/store';

constructor(private store: Store) {}

It is also a good practice to organize the state and actions in a specific way, like creating a folder for each feature and a file for each action, reducer and effect.

You may also consider adding the ngrx dev tools to your browser to have a better developer experience

npm install @ngrx/store-devtools

import { StoreDevtoolsModule } from '@ngrx/store-devtools';

and then import it on your app.module.ts

imports: [
    StoreModule.forRoot({ state: reducer }),
    StoreDevtoolsModule.instrument()
  ]

It is also good to read the official documentation and the guidelines to have a deeper understanding of how to structure your state management and have a better organization and performance.

Example

Here is a simple example of how you might use NGRX Store in an Angular application. Let's say we have a simple application that allows the user to increment or decrement a counter. Here's how we might set up the store to manage the state of the counter:

Define the state: The first step is to define the state that the store will manage. In this case, we only have a single piece of state: the counter. We will create a file counter.state.ts to define the state like this:

export interface CounterState {
  count: number;
}

export const initialState: CounterState = {
  count: 0
};

Create the actions: Next, we will create a file counter.actions.ts to define the actions that the store can handle. In this case, we have two actions: one to increment the counter and one to decrement it.

import { createAction, props } from '@ngrx/store';

export const increment = createAction('[Counter] Increment');
export const decrement = createAction('[Counter] Decrement');

Create the Reducers: Now we need to create a file counter.reducer.ts to handle the actions and update the state.

import { createReducer, on } from '@ngrx/store';
import { increment, decrement } from './counter.actions';
import { CounterState, initialState } from './counter.state';

export const counterReducer = createReducer(initialState,
  on(increment, state => ({ count: state.count + 1 })),
  on(decrement, state => ({ count: state.count - 1 })),
);

Import the StoreModule in your app module: After installing the NGRX packages, you will need to import the StoreModule in your app's root module and configure it to use the counterReducer function that you created.

import { StoreModule } from '@ngrx/store';
import { counterReducer } from './counter.reducer';

@NgModule({
  imports: [
    StoreModule.forRoot({ count: counterReducer })
  ]
})
export class AppModule {}

Use the store in your component: Now you can use the store in your component by injecting it and subscribing to the state.

import { Component } from '@angular/core';
import { Store } from '@ngrx/store';
import { increment, decrement } from './counter.actions';

@Component({
  selector: 'app-root',
  template: `
    <button (click)="decrement()">-</button>
    <span>{{ count }}</span>
    <button (click)="increment()">+</button>
  `
})
export class AppComponent {
  count: number;

  constructor(private store: Store) {
    store.select('count').subscribe(count => this.count = count);
  }

  increment() {
    this.store.dispatch(increment());
  }

  decrement() {
    this.store.dispatch(decrement());
  }
}

Scenarios where ngrx/store can be useful

NGRX Store is particularly useful in Angular applications that have a complex state or that need to handle a large amount of data. Here are a few scenarios in which NGRX Store can be useful:

Large or complex state: NGRX Store provides a way to organize your application's state into a single, immutable data store, which makes it easy to share the state between different components and services. This can be particularly useful in applications with large or complex state that is difficult to manage using a traditional approach.
Data-heavy applications: NGRX Store provides a way to manage large amounts of data in an efficient and performant way, which can be particularly useful in applications that need to handle a lot of data, such as large lists or tables of data.
Real-time applications: NGRX Store's use of RxJS makes it easy to handle real-time data and updates, which can be particularly useful in applications that need to handle data in real-time, such as chat or monitoring applications.
Applications that need undo/redo functionality: NGRX Store's immutability of state makes it easy to revert the state of the application to previous state, which can be useful in applications where undo/redo functionality is needed.
Multi-module application : NGRX Store's ability to manage state at a global level in a centralized way and it’s powerful tools are also ideal for large-scale, multi-module applications where different sections of an application could have different ownership, but they still need to share the same data and state.
Applications that need to handle complex state transitions: In some scenarios, an application might need to handle complex state transitions that depend on the current state, or that depend on the order in which actions are performed. NGRX's architecture allows you to handle these transitions in a clean and organized way.

Overall, NGRX store is useful in applications that need a powerful and predictable way to manage state, and that benefit from its separation of concerns, immutability and powerful tools.

Downsides

NGRX Store is a powerful tool for managing state in Angular applications, but it also has some downsides:

Learning curve: NGRX Store uses a set of concepts and tools that may be unfamiliar to some developers, such as Actions, Reducers, and Effects. It also makes use of RxJS, which may be unfamiliar to developers who haven't worked with reactive programming before. This learning curve can be steep, and it may take some time for developers to fully understand how to use NGRX Store effectively.
Boilerplate: In order to set up NGRX Store, you will need to write a fair amount of boilerplate code, such as actions, reducers, and effects. This can add extra development time and make your codebase more complex.
Performance: While NGRX Store can be performant, it does have some overhead, particularly when working with large amounts of data. It may also have performance issues with high-frequency updates. This can be mitigated by proper configuration and implementation of the NGRX store
Over-engineering: NGRX Store is a powerful tool, but it may not be necessary in all cases. It's important to consider whether it's the right tool for the job before incorporating it into your application, as the added complexity and boilerplate may be unnecessary if the state is not complex or you don't need the features provided by NGRX.
Steep developer requirement: As the technology is complex, the development team must have a good knowledge of RxJs, and the NGRX Store architecture, as well as the Angular platform, in order to use it efficiently, and to maintain the application with good performance and scalability.

It's important to consider these downsides when deciding whether to use NGRX Store in your application, and to weigh the benefits against the potential costs. In many cases, NGRX Store can be a powerful tool for managing state in Angular applications, but it may not be the best choice for every situation.

How can I learn more?

There are many resources available to help you learn more about NGRX Store, here are a few places to start:

Official documentation: The official NGRX Store documentation is a great resource to start learning about NGRX Store. It provides detailed explanations of all the concepts and tools, as well as examples of how to use them.
Online tutorials: There are many online tutorials and courses available that can help you learn NGRX Store. Some popular platforms include YouTube, Udemy, and Pluralsight. These tutorials can help you learn the basics of NGRX Store and provide you with a solid foundation to build upon.
Books: There are also some books that are available, such as "ngrx: in Action" which can help you dive deeper into the concepts of NGRX and how to use it in a real-world scenario.
Community and Blogs : You can also find a lot of information on blogs and discussion forums, from tutorials to best practices, from people who have experience with NGRX Store and are willing to share their knowledge with the community.
Try it out: The best way to learn is to try it out. Building a small scale application with NGRX Store will give you a much better understanding of how it works and how to use it effectively.
NGRX's community: The NGRX community is strong and active, you can join the community on platforms like slack, gitter or stack overflow and ask questions and get help with the issues you are facing.

In addition to these resources, it's also important to keep in mind that learning is an ongoing process, you will learn more as you work with NGRX store and encounter new challenges and edge cases.

Alternatives

There are several other libraries and tools available for managing state in Angular applications, here are a few alternatives to NGRX Store:

Angular's built-in services: Angular provides several built-in services for managing state, such as ChangeDetectorRef, EventEmitter, and Subject. These services can be used to share data between components and services, but they lack some of the advanced features provided by NGRX Store, such as immutability, undo/redo functionality and centralized state management.
Akita: It is a lightweight state management library, similar to NGRX store that is built on top of RxJS and it is designed to be simple and easy to use, it also provides powerful tools for managing the state, such as Actions, Reducers, and Effects.
MobX : It is another popular state management library, which is not specific to Angular, but it can be integrated with Angular. It provides a simple and intuitive way to manage the state and it has a simple and easy to understand API, that make it easy to start with, but it lack immutability and undo/redo functionality by default.
Apollo Client: It is mainly a GraphQL client, but it has a built-in state management solution as well, it can be a good choice for managing the state of data retrieved from a GraphQL server, it has a lot of features, but it's mainly optimized for GraphQL.
Vanilla Redux: The original Redux is a library for managing state in JavaScript applications, it's not specific to Angular, but you can still use it in an Angular application. It provides a simple and predictable way to manage the state, but it requires more boilerplate to use it in Angular.

Ultimately, the best choice will depend on the needs of your specific application and the preferences of your development team. It's important to evaluate the features, performance and complexity of each library, as well as their adaptability to your use case, before making a final decision.

Conclusion

NGRX Store is a powerful tool for managing state in Angular applications, and it's a well-established and widely used library. It provides a centralized state management approach, using immutability and a set of powerful tools such as Actions, Reducers and Effects. These tools provide many benefits such as predictability, testability, scalability, and making the application more maintainable.

However, like any tool, NGRX Store isn't a silver bullet, and it may not be the best choice for every situation. There is a learning curve and some added complexity associated with using NGRX Store, and it may not be necessary for applications with simple state. It's important to weigh the benefits and downsides of NGRX Store before deciding to use it in your application, and to consider the requirements of your specific use case.

In conclusion, NGRX Store is a powerful library for managing state in Angular applications, and it's a great tool for large or complex state, real-time applications, undo/redo functionality and multi-module applications. But it's important to understand its complexity, performance and requirements before deciding to use it, and to consider the alternatives that might suit better the application needs.