Batched Updates

Batched Updates in React Js refers to a strategy in which multiple state changes are grouped together and then applied in a single render for optimized performance. React JS automatically batches updates that are inside event handlers and lifecycle methods. So, if you change the state multiple times in a React event handler, React will ensure that the DOM is updated efficiently and effectively.

However, if state changes are occurring outside of React's event handlers or lifecycle methods, they may happen synchronously. This could potentially hurt performance as it results in more re-rendering of user interface. While you don't often face such scenarios, in case you do, React provides an API 'unstable_batchUpdates()' to manually batch updates.

Here's a basic example showing how this works:

``` javascript
import { unstable_batchedUpdates } from 'react-dom';

// some code ....

fetchData().then((data1, data2) => {
unstable_batchedUpdates(() => {
// these state updates will be batched
this.setState({ data1: data1 });
this.setState({ data2: data2 });
});
});
```
In the above example, `unstable_batchedUpdates` function is used to batch multiple `setState` calls into a single update. This allows React to execute more efficiently and update the DOM only once rather than twice, improving performance.

It's worth noting that `unstable_batchedUpdates` is not part of the stable React API and therefore not recommended for common use. Its mention in code might raise questions about its stability and long-term support. Nevertheless, it can come in very handy and significantly boost performance for certain edge use cases.

Please also note that this functionality is built into React's newer `useState` and `useReducer` Hooks which automatically batch all updates within a single synchronous event handler.