Central Processing Unit (CPU) is an integral part of the computer system. The core responsibility of a CPU is to handle all the instructions from hardware as well as software. It is beyond the scope of this book to explore the CPU in detail; however, we will study the basic architecture and underline functioning of a CPU in very high level. This will help us to understand the areas where we need to focus on utilizing a CPU optimally. Not every part of your code will be CPU-dependent, so it is important to find these areas and use a proper coding strategy to make sure we use CPU time more efficiently.

Let's first look at the high-level architecture of CPU. If you dissect the processing of a CPU, you will notice there are two main components, one is Arithmetic Logic Unit (ALU), which is responsible for performing logical, mathematical, and comparison operations...

In this section, we will explore another area which is susceptible to performance problems. More or less, each line of code is dependent on some data in the form of object, variable, and so on. Hence, JVM needs to have some type of provision to store this information so that it will be available to your code. This storage is mainly provided by the underline Operating System (OS), which is based on physical memory such as Random Access Memory (RAM) and JVM is allocated to use a portion of it. This memory space is then available to your application running inside the JVM.

There are mainly two areas which you need to focus on:

• Heap
• Stack

Don’t worry, we will take a closer look at these two areas, but before we jump into that, let's quickly review CPU memory that we briefly talked about in the previous section. Every time CPU executes the given instructions...

So far we have seen various code-level optimizations related to CPU and memory that we can perform to improve an application’s performance. However, the overall performance of the application is dependent on various factors such as database, IO, and network.

In the SaaS world, almost every application out there is database dependent. This means, we need to focus on various aspects related to database optimization. Several performance issues are the result of poor architectural decisions, the wrong use of design patterns, improper database configurations, and sometimes incorrect database type selection. In this section, we will focus on identifying various database-related bottlenecks and briefly discuss the areas of improvements. Database optimization itself is a vast topic and out of the scope of this section. In order to optimize the database you need...

This is another area that is important from the performance optimization point of view. If you need to read or write files to your server, you need to rely on Java’s I/O APIs. The I/O operations are resource intensive and may consume a large amount of processing time. This can turn into a big performance bottleneck, and hence, it is important to tune this area to improve the overall application performance.

Most Java developers still rely on the basic I/O APIs, which are more than adequate to perform any file related operations. However, they do have some performance issues, for example, InputStream.read() performs character-by-character reading or the method Reader.read() reads one character at a time. Then there are stream-related APIs. Most of them read or write one byte at a time, which contributes to performance problems as it takes a long time to go...

As the world is progressing toward the SaaS application's paradigm, it is imperative to pay close attention to network utilization of your program. In this typical client-server architecture, in many cases, every event is processed on the server side and the data constantly flows over the wire, across the oceans, miles away from its origin. On top of this, the world is becoming impatient regarding speed and performance. With the advent of social media and the love of video and photo sharing, data usage has sky rocketed and is using up almost all the bandwidth a user can get. Hence, it is extremely important to use network resources as efficiently as possible.

In order to squeeze every possible performance gain from the available network resources, we need to implement various strategies and design patterns. This section will highlight some of the new additions...

In this chapter, we learned about various bottlenecks which can cause performance issues. In particular, you need to focus on various areas such as CPU infrastructure, I/O operations, database operations, network utilization, and memory utilization. It is important to understand the type of operation your algorithm is performing. Based on that you need to optimize your code, so it wont take much of the resources.

In the next chapter, we will learn about the various troubleshooting and error handling techniques, logging, and then about thread dump and how to analyze it.