memo from the small room

發表文章

目前顯示的是有「java」標籤的文章

Class Loading

Class life cycle Class loader reference: https://www.amazon.com/depth-understanding-Java-Virtual-Machine/dp/7111641248

Table of contents [ hide ] Java has many useful tools for debugging at runtime or analyzing an application after it has crashed. Commands jps - JVM process Status Tool Same as the Linux command ps, only to find the process under the JVM. jinfo - Configuration Info for Java Show and adjust the JVM arguments. jmap - Memory Map for Java Getting a memory error dump is the most common technique used at runtime. The dump file can be used to analyze the cause of the failure. jstack - Stack trace for Java Check the thread runtime status. GUI VisualVM VisualVM is a tool that provides a visual interface for viewing detailed information about Java applications while they are running on a Java Virtual Machine (JVM). Memory Analyzer (MAT) The Eclipse Memory Analyzer is a fast and feature-rich Java heap analyzer that helps you find memory leaks and reduce memory consumption. reference: https://www.amazon.com/depth-understanding-Java-Virtual-Machine/dp/7111641248 https://en.wikipedia.org/wiki/

閱讀完整內容

Garbage Collectors

Table of contents [ hide ] The JVM ships with various options for garbage collection to support a variety of deployment options. With this, we get flexibility in choosing which garbage collector to use for our application. Serial GC The Serial collector uses a single thread for garbage collection. The serial collector is not even that powerful compared to other GCs but is useful in a uniprocessor or hardware-constrained environments. ParNew GC The parallel version of the Serial collector, before the emergence of G1 GC, the combination of ParNew and CMS worked together, and ParNew was responsible for the garbage collection of the new generation. Parallel Scavenge GC Aa a young generation GC, compare to other GCs, focuses on the throughput, and another important feature is the auto adjustment strategy to find the best throughput and pause time. Serial Old GC Serial Old GC is for the old-generation version of Serial GC. It has two purposes, one is to work with Parallel Scavenge

閱讀完整內容

GC Basic Algorithm

Theory Most GCs follow the theory of generational collection, which is based on the following two: Week generational hypothesis: Most of the objects are short-living. Strong generational hypothesis: The more times an object survives GC, the harder it is to die. Mark-Sweep After the marking phase has been completed all space occupied by unvisited objects is considered free and can thus be reused to allocate new objects. There may exist plenty of free regions but if no single region is large enough to accommodate the allocation, the allocation is still going to fail. Mark-Copy To avoid excessive fragmentation, it splits the space into two parts and copies the surviving objects into empty parts. The disadvantage is the need for one more memory region, which should be large enough to accommodate survived objects. Mark-Compact Like mark-copy, it doesn't require another space to copy but a more complex operation to move the object. Reachability analysis First, GC defines some specific

閱讀完整內容

Java memeory model

The java memory model has multiple areas to do different jobs, this model is in user space because it has no I/O control. There are these parts: Program counter register: For java multi-thread switching different threads, and same functionality as OS counters. (PC) Registers are created every time a new thread is created. The PC holds a pointer to the current statement being executed in its thread. If the currently executing method is 'native', then the value of the program counter register will be undefined. Stack: Private for each thread. It contains method-specific primitive values and references to objects referenced from methods in the heap. Whenever we call a new method, a new block is created on top of the stack which contains values specific to that method Native Method stacks: JVM that supports native methods will have native method stacks. It is used for native methods, and created per thread. Heap: Heap data area is used to store objects of classes and arrays. Heap

閱讀完整內容

Thread Status

Table of contents [ hide ] The java thread state is similar to the operating system process state, but the java state is in the JVM. Operating system process state New: The process is being created. Ready: The process is waiting to be assigned to a processor. Running: Instructions are being executed. Waiting: The process is waiting for some event to occur(such as an I/O completion or reception of a signal). Terminated: The process has finished execution. Java thread state New: It represents the first state of a thread that is the NEW state. Runnable: It represents the runnable state. It means a thread is waiting in the queue to run. Blocked: It represents the blocked state. In this state, the thread is waiting to acquire a lock. Waiting: It represents the waiting state. A thread will go to this state when it invokes the Object. wait() method, or Thread.join() method with no timeout. A thread in the waiting state is waiting for another thread to complete its task. Timed wai

閱讀完整內容

Concurrency

Table of contents [ hide ] Glossary Synchronous: When you start a program, you must wait until it finishes before moving on to the next step. Asynchronous: When you start a program, it returns immediately and runs the program in the background, and you can move on to the next step. Concurrency: Concurrency is the ability of different parts or units of a program, algorithm, or problem to be executed out-of-order or in the partial order, without affecting the final outcome Parallelism: Parallel computing is a type of computation in which many calculations or processes are carried out simultaneously. Blocking: A process that is blocked is one that is waiting for some event, such as a resource becoming available or the completion of an I/O operation Non-blocking: An algorithm is called non-blocking if the failure or suspension of any thread cannot cause the failure or suspension of another thread Concurrency level Blocking: A thread is blocked and it cannot execute until other threa

閱讀完整內容

Annotation

Table of contents [ hide ] Design pattern Annotations are an implementation of the decorator design pattern. The decorator pattern is a design pattern that allows behavior to be added to an individual object, dynamically, without affecting the behavior of other objects from the same class. Annotations in Java Annotations, a form of metadata, provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate. Annotations have a number of uses: Information for the compiler: Annotations can be used by the compiler to detect errors or suppress warnings Compile-time and deployment-time processing: Software tools can process annotation information to generate code, XML files, and so forth. Runtime processing: Some annotations are available to be examined at runtime. Annotations in Spring Spring uses annotations extensively as a core feature, especially Spring AOP, and almost all the functions we use in S

閱讀完整內容

Reflection

Reflection is an API that is used to examine or modify the behavior of methods, classes, and interfaces at runtime. Reflection is the basis for many advanced features such as annotations, and dynamic proxies. Many frameworks use reflection to implement functions, such as Spring IOC and AOP, ORM mapping frameworks, etc. Pros: Inspection of interfaces, classes, methods, and fields during runtime is possible. Arbitrary calls to methods and properties of objects. Create an instance arbitrarily. Cons: Reflective code is less readable and maintainable. Performance overhead. Break the principle of encapsulation. Example: Abstract factories with reflection can reduce redundant code to keep clean code. see Proxy . reference: https://www.geeksforgeeks.org/reflection-in-java/ https://www.javatpoint.com/java-reflection https://github.com/hollischuang/toBeTopJavaer

閱讀完整內容

Proxy

Table of contents [ hide ] Proxy in design pattern The proxy pattern is a software design pattern, as a wrapper or agent object that is being called by the client to access the real serving object behind the scene. There are two advantages: Provides access control for real objects. Provides additional functionality when accessing real objects. And there are two types of proxy: Static proxy: proxies are created manually. Java example on GitHub . Dynamic proxy: proxies are created by JDK Proxy or CGLib Proxy with reflection. JDK proxy Before the proxy object is created, it must implement the invoke method of the InvocationHandler, which is invasive to the target object. JDK Dynamic proxy can only proxy by the interface (so your target class needs to implement an interface, which is then also implemented by the proxy class) CGLib proxy The proxy object is created by implementing the intercept method of MethodInterceptor, and the target object does not need to implement this metho

閱讀完整內容

IOC and AOP

Table of contents [ hide ] The famous two features of Spring are IOC and AOP. Inversion of Control It uses the Spring's container to help us get objects, and the Spring manages these objects. There are two main types: Dependency Lookup: The Inversion of Control is limited to the container invoking callback methods that the application code can use to obtain resources. Dependency Injection: The container is wholly responsible for wiring up components, and passing resolved objects into JavaBean properties or constructors for application. Aspect-Oriented Programming It helps to add new business logic across different modules without modifying the current code. reference: https://zhuanlan.zhihu.com/p/136474190 https://www.jianshu.com/p/7a1c0bad2708

閱讀完整內容

Composition and Inheritance

Composition vs Inheritance In "Effective JAVA" or if you search the Internet, you will find that everyone says that composition is better than inheritance. We know the composition has the advantages of the following: Composition is loosely coupled. The composition has better access control. Composition is more flexible. Unit test easier. Is this really true? usually yes, but let's back to thinking about it, what are we programmed for, methods are just tools, and people are the core. Let's see what the advantage is of inheritance before we choose the methods. here . Choosing the best fit method for the program is the most important thing, not just avoiding inheritance. reference: https://www.digitalocean.com/community/tutorials/composition-vs-inheritance https://github.com/hollischuang/toBeTopJavaer

閱讀完整內容

SOLID

SOLID is the fundamental and core principle of OOP. Single-Responsibility Principle High cohesion: A module preferably has only one business logic. Low coupling: The different modules work independently and are connected by simple protocols to minimize side effects. Open-Closed Principle Open for extension: It is easy to extend new functions with existing code. Close for modification: Do not modify existing classes to ensure stable functions. Liskov-Substitution Principle A superclass should be replaceable with objects of its subclasses without breaking the application. Interface-Segregation Principle Clients only depend on the interfaces they need, don't use the "big" interface to contain everything. Dependence-Inversion Principle The program should depend upon abstractions, not concretions. reference: https://en.wikipedia.org/wiki/SOLID https://blog.knoldus.com/what-is-liskov-substitution-principle-lsp-with-real-world-examples/ https://github.com/hollischuang/toBeTo

閱讀完整內容

Three major features of object-oriented

Table of contents [ hide ] Encapsulation Encapsulation is the process of enclosing all critical information inside, the public method is the only way for other objects to access the data. The advantages are as follows: It protects data and implementation details through access restrictions, and users can only get results without modifying the objects inside. It is easy to change the implementation according to requirements because it does not expose the implementation details to the users. Inheritance It uses all the features of the parent class and extends the new features itself. The advantages are as follows: It reuses the same code. It restricts all child objects to the same business logic as the parent object, but they do not affect each other. Polymorphism It executes methods differently by overriding the parent method, especially when the same business logic runs different methods at runtime. There are two types of Polymorphism: Method override. Method overloading. referen

閱讀完整內容

memo from the small room

搜尋此網誌

發表文章

Distributed transactions

Class Loading

JVM Tools

Garbage Collectors

GC Basic Algorithm

Java memeory model

Thread Status

Concurrency

Annotation

Reflection

Proxy

IOC and AOP

Composition and Inheritance

SOLID

Three major features of object-oriented