umi | All the world's oceans

tip is just a function that you are calling. You should call it outside of the return JSX section of your code. I think it makes the most sense to call it inside of a useEffect hook with dependencies on status and submitting. The effect runs each time that status or submitting changes. If status is 1 and submitting is falsy, then we call tip.

Yes, it is allowed.

Mainly exposed on the already quoted sections of the JMM:

Assuming the object is constructed "correctly", once an object is constructed, the values assigned to the final fields in the constructor will be visible to all other threads without synchronization.

What does it mean for an object to be properly constructed? It simply means that no reference to the object being constructed is allowed to "escape" during construction.

In other words, do not place a reference to the object being constructed anywhere where another thread might be able to see it; do not assign it to a static field, do not register it as a listener with any other object, and so on. These tasks should be done after the constructor completes, not in the constructor** *

So yes, it's possible, as far as is allowed. Last paragraph is full of suggestions of how-not-to-do things; Whenever someone says avoid doing X, then is implicit that X can be done.

The other answers correctly point out the requirements for the final fields to be correctly seen by other threads, such as the freeze at the end of the constructor, the chain, and so on. These answers offer a deeper understanding of the main issue and should be read first. This one focuses on a possible exception to these rules.

The most repeated rule/phrase may be this one here, copied from Eugene's answer (which shouldn't have any negative vote btw):

An object is considered to be completely initialized when its constructor finishes. A thread that can only see a reference to an object after that object has been completely initialized is guaranteed to see the correctly [assigned/loaded/set] values for that object's final fields.

Note that I changed the term "initialized" with the equivalent terms assigned, loaded, or set. This is in purpose, as the terminology may mislead my point here.

Another proper statement is the one from chrylis -cautiouslyoptimistic-:

The "final freeze" happens at the end of the constructor, and from that point on all reads are guaranteed to be accurate.

JLS 17.5 final Field Semantics state that:

A thread that can only see a reference to an object after that object has been completely initialized is guaranteed to see the correctly initialized values for that object's final fields.

But, do you think reflection gives a f*** about this? No, of course not. It didn't even read that paragraph.

Subsequent Modification of final Fields

These statements are not only correct, but also backed by the JLS. I don't intend to refute them, but just add some little extra information regarding an exception to this law: reflection. That mechanism that, among other things, can change a final field's value after being initialized.

Freeze of a final field occurs at the end of the constructor in which the final field is set, that's completely true. But there's another trigger for the freeze operation that hasn't been taken into account: Freeze of a final field also occurs initializing/modifying a field via reflection (JLS 17.5.3):

Freezes of a final field occur both at the end of the constructor in which the final field is set, and immediately after each modification of a final field via reflection.

Reflective operations on final fields "break" the rule: after the constructor being properly finished, all reads of the final fields are still NOT guaranteed to be accurate. I'd try to explain.

Let's imagine all the proper flow has been honored, the constructor's been initialized and all final fields from an instance are correctly seen by a thread. Now it's time to make some changes on those fields via reflection (just imagine this is needed, even if unusual, I know..).

The previous rules are followed and all threads wait until all fields have been updated: just as with the usual constructor scenario, the fields are only accessed after being freezed and the reflective operation been correctly finished. This is where the law is broken:

If a final field is initialized to a constant expression (§15.28) in the field declaration, changes to the final field may not be observed, since uses of that final field are replaced at compile time with the value of the constant expression.

This is telling: even if all rules were followed, your code won't correctly read the final field's assigned value, if that variable is a primitive or String and you initialized it as a constant expression in the fields declaration. Why? Because that variable is just a hardcoded value for your compiler, which won't ever check again that field nor its changes, even if your code properly updated the value in runtime execution.

So, let's test it:

You can try UMI_UI=none npm start

Q: How to access DVA Store in UMI application, outside the component or without connect?

A: https://v2.umijs.org/guide/with-dva.html#how-to-access-store-or-dispatch

It says use:

Return value should be a component. Either function or class component.

This would work:

I found out that there is an already opened github issue. The problem is basically with the umi library. I used connect method of react-redux and it worked fine but at the same time, it's not appropriate to have one more library just to use the connect method. I am using it till it get's fixed in umi.

https://github.com/umijs/umi/issues/5138 and https://github.com/ant-design/ant-design-pro/issues/6401

Actually, this issue comes from performance of browserify process, the CRA is fast for this test-code, because the configuration of Webpack on CRA used the new version of browserify process and it comes from /node_modules/process/browser.js but the umijs used the older version, the node-libs-browser that is DEPRECATED now and it comes from /node_modules/node-libs-browser/process.js.

I found it be adding break-points and track line after line and see when interpreter fall into /node_modules/node-libs-browser/process.js, it stocks for a long time which is not like it on /node_modules/process/browser.js and passes it as fast as can.

The node-libs-browser had a bad performance and the umijs should update its Webpack configuration to the latest versions. They still uses webpack-dev-middleware version 3.5.1, it is now on vesion 4.x.x.

The umijs has a great ability to get new configuration from developer by modifying /config/config.ts but its config docs is in Chinese language and still didn't have translated.

By these description I prefer to remove umijs from project. that is not a good solution but I think it is a wise decision.

The main problem with performance in your code is the multiple loops. You can delegate all that looping to C implementations of numpy by using pandas built-in methods.

For example, use df_main.groupby with sum, reshape, and flatten index... then merge with df1.

try this: