sympathy | A high performance dynamic web service platform

Ha Minh, I've taken a look at your project. Thanks for sharing it, that helped a lot!

To fix this issue you have to wrap the Work object into a Bundle and then pass the Bundle into the Intnet. Your code in CreateActivity#onOptionsItemSelected should look like this:

With this Line You Can Get The Current Directory of Your Application.

You are initializing an array, but then using string keys to set the data. So either use an actual object:

You have multiple issues with your data file. Among them are:

1. Your Cypher code expects personality_result to be a list of JSON objects. It is not.

   (a) It is a single string, not a list.

   (b) That string seems to consist of the truncated start of a stringified JSON object (that includes a lot of extra pretty-printing whitespace).

   So, everything in your Cypher query starting at the FOREACH will not work.

2. In your next-to-last MERGE, personality_result.personality should probably be just personality.

You may have other issues, but it is hard to tell until you fix your data file and code.

It seems from your setup that the host machine is running the database server, which you are unable to reach from your container's virtual network, what you need to do here is interface the host network and ports with container's virtual network so that your application is able to reach the database as it is able to when running on the same host according to your application config.

By default, a docker container starts in bridge mode nothing is explicitly specified about network modes when starting up the container, so either you can bind database server with the bridge IP or you can specify the network mode to host for your container.

To be clear, the StampedLock is much faster on reads when contention rises. Writers are a bit faster, but not as close to as fast as reads. I'll explain why.

Most of the time, with read-write-locks, writes are way fewer. However, even despite this, each time you acquire a readLock() on the ReentrantReadWriteLock you have to increment a reader count. This forces a cache invalidation on all cores using this lock.

Under heavy contention this can cause a significant slow down when doing reads. Reads should be fast, when doing a readLock() we shouldn't have to update a variable, it's counter intuitive.

What if, instead, we have a stamp or let's say, version? One that only updates once per read iteration.

What this does for us is, under contention, if only one thread updates a stamp value (let's say after a write) all reading threads will be executing cache hits when wanted to read on the lock. This prohibits cache invalidation and allows the lock to execute in a more appropriate fashion than a RRWL.

The pattern for using a StampedLock is similar to a lock-free algorithm when using tryOptimisticRead (like CAS)

1. Get a stamp
2. Read a value
3. Has the stamp changed?
   • Yes, try again or issue a blocking read
   • No, we are good, let's move on.

Taking your question literally, “…is my assumption correct in that JIT optimizations are to blame?”, the answer is yes, it’s very likely that the JIT optimizations are responsible for this behavior in this specific example.

But since changing static final fields is completely off specification, there are other things that can break it similarly. E.g. the JMM has no definition for the memory visibility of such changes, hence, it is completely unspecified whether or when other threads notice such changes. They are not even required to notice it consistently, i.e. they may use the new value, followed by using the old value again, even in the presence of synchronization primitives.

Though, the JMM and the optimizer are hard to separate anyway here.

Your question “…are those limited to static final fields only?” is much harder to answer, as optimizations are, of course, not limited to static final fields, but the behavior of, e.g. non-static final fields, is is not the same and has differences between theory and practice as well.

For non-static final fields, modifications via Reflection are allowed in certain circumstances. This is indicated by the fact that setAccessible(true) is enough to make such modification possible, without hacking into the Field instance to change the internal modifiers field.

The specification says:

17.5.3. Subsequent Modification of final Fields

In some cases, such as deserialization, the system will need to change the final fields of an object after construction. final fields can be changed via reflection and other implementation-dependent means. The only pattern in which this has reasonable semantics is one in which an object is constructed and then the final fields of the object are updated. The object should not be made visible to other threads, nor should the final fields be read, until all updates to the final fields of the object are complete. 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 or other special mechanism.

…

Another problem is that the specification allows aggressive optimization of final fields. Within a thread, it is permissible to reorder reads of a final field with those modifications of a final field that do not take place in the constructor.

Example 17.5.3-1. Aggressive Optimization of final Fields

Revised: Incorporating additional requirement

Well with the new information a small adjustment can be made. Since "No matter how many times you login within a month, we only count 1, based on the username". Rather than looking for equal dates we'll use the Posrgres date_trunc function to look at the 1st of the month whatever the actual login date happens to be. Also continuing to use WHERE EXISTS ensures that no matter how many logins a user has we only count 1. So the REVISED function:

Declare a List and add a Chip to the List as per your requirement.

Example Code: