Contention RollingFileManager.checkRollover()

Contention at: org.apache.logging.log4j.core.appender.rolling.RollingFileManager.checkRollover()

This is a problem with high concurrency, and it works as designed. The file system (I/O) doesn't have  enough performance as required.

The synchronized makes BLOCKED some Java monitor when trying to acquire the resource.

/**
 * Determines if a rollover should occur.
 * @param event The LogEvent.
 */
public synchronized void checkRollover(final LogEvent event) {
    if (triggeringPolicy.isTriggeringEvent(event)) {
        rollover();
    }
}

The solution as mentioned above is to move to Async logging.
https://logging.apache.org/log4j/2.x/manual/async.html

JMC Events

From the Event Types tab, look at the color of each event.

Yellow represents Java Monitor Wait events.
The yellow part is when threads are waiting for an object. This often means that the thread is idle, perhaps waiting for a task.

Red represents the Java Monitor Blocked events or synchronization events. If your Java application's important threads spend a lot of time being blocked, then that means that a critical section of the application is single threaded, which is a bottleneck.

Blue represents the Socket Reads and Socket Writes events. Again, if the Java application spends a lot of time waiting for sockets, then the main bottleneck may be in the network or with the other machines that the application communicates.

https://docs.oracle.com/javase/10/troubleshoot/troubleshoot-performance-issues-using-jfr.htm

http://java-performance.info/oracle-java-mission-control-overview/#more-921

Foldable and Traversable

https://wiki.haskell.org/Foldable_and_Traversable

Money Java

Never use Double or Float, only BigDecimal !

http://www.javapractices.com/topic/TopicAction.do?Id=13

https://dzone.com/articles/never-use-float-and-double-for-monetary-calculatio

Fallacies of distributed computing

The fallacies are:^[1]

• The network is reliable
• Latency is zero
• Bandwidth is infinite
• The network is secure
• Topology doesn't change
• There is one administrator
• Transport cost is zero
• The network is homogeneous

Although, there are some writings about they are not fallacies anymore... 

iostat vmstat

- vmstat 30
  cpu intensive ?
  memory paging ?
  r, free, si, so

- iostat -x
  avgqr-z
  await
  %util (100%?!)

Run iostat with kilobytes unit, 2 seconds interval with 3 times reports
# iostat -k 2 3

1. https://devwebcl.blogspot.com/2014/05/distinctive-recipes-2nd-ed-1212-1211.html
2. https://www.geeksforgeeks.org/iostat-command-in-linux-with-examples/
3. https://www.techrepublic.com/article/how-to-use-the-linux-iostat-command-to-check-on-your-storage-subsystem/

HTTP 1.0 Performance

HTTP 1.0 had performance issues by slow-start of TCP. The 3-way handshaking was guilty.

https://devwebcl.blogspot.com/2018/09/tcpip-illustrated.html

This was fixed in HTTP 1.1 reusing the connections. Similar to a pool of TCP connections.

2.

• Under HTTP 1.0, connections are not considered persistent unless a keepalive header is included,^[1]
  
  
  ^{-Dhttp.keepAlive=false (it can be configured at java system property)}
  
  
•  In HTTP 1.1, all connections are considered persistent unless declared otherwise.^[2]

Resources:

- https://www.w3.org/Protocols/HTTP/1.0/HTTPPerformance.html
- https://hpbn.co/http1x/
- https://blog.insightdatascience.com/learning-about-the-http-connection-keep-alive-header-7ebe0efa209d
- https://en.wikipedia.org/wiki/HTTP_persistent_connection#HTTP_1.0
- https://en.wikipedia.org/wiki/TCP_congestion_control

HTTP client timeouts

https://docs.spring.io/autorepo/docs/spring-framework/4.1.7.RELEASE/javadoc-api/org/springframework/http/client/HttpComponentsClientHttpRequestFactory.html

        HttpComponentsClientHttpRequestFactory requestFactory =
                new HttpComponentsClientHttpRequestFactory();

        requestFactory.setConnectionRequestTimeout(connectRequestTimeout);
        requestFactory.setConnectTimeout(connectTimeout);
        requestFactory.setReadTimeout(readTimeout);
       


setConnectionRequestTimeout(int connectionRequestTimeout)
Set the timeout in milliseconds used when requesting a connection from the connection manager using the underlying HttpClient.
(del manager!, del http pool, si no tiene conexiones para ofrecer)


setConnectTimeout(int timeout)
Set the connection timeout for the underlying HttpClient.
(conexion con el server)


setReadTimeout(int timeout)
Set the socket read timeout for the underlying HttpClient.
(lectura del response).

Hipérbaton

Del lat. hyperbăton, y este del gr. ὑπερβατόν hyperbatón.

 

1. m. Ret. Alteración del orden que las palabras tienen habitualmente en el discurso, como en por mi mano plantado tengo un huerto.

https://dle.rae.es/?id=KQc0GSw

 

Knuth Quilt

A quick straightforward (and slow) ruby code to create Knuth quilt from Donald Knuth's TAoCP Pre-Fascicle 1a: Bitwise Tricks and Techniques


https://dzone.com/articles/patchwork-quilt-pattern-ruby