-Tausief Shaikh

(Senior Server developer)

Introduction
Covers sense of responsibility towards Project

development in IT
Focusing on memory and CPU utilizations
rather than just coding.
Thread and Thread Pool
Eclipse Debugging
Use of thread dumps and analysis using
JVisualVM

Developing a software is easy but

developing best software is indeed very
tough
If you know how to code, have some basic logic
thinking, and with proper assistance of NET you
can develop applications easily.
Eg: If you know Java core, like datatypes, OOPs
concepts, defining classes, interfaces, variables,
method, then you can code and go on to develop
big applications.
Knowing the write ways of coding (designing in
specific) however needs some experience, but
would definitely come after spending some time
in IT.

Developing a software is easy but

developing best software is indeed very
tough
Even tough we develop an application, functionally all
correct, that doesn't mean our work is done. As a
developer its our responsibility to make sure that the
application works superb under heavy load.
When many users access the application concurrently,
then this can add more load on the resources we use.
That means, more load on the memory, more CPU time
utilization, more disk space utilization, etc.
Our application would always be deployed and run in a
limited environment, where we have some max
memory size, max disk space, max capability of CPU
core. So there is always a challenge of how many
requests the application can process in parallel,
because beyond this the application would eventually
crash.

Developing a software is easy but

developing best software is indeed very
tough
If many objects are created on heap for processing a
single, then when huge load hit the app in parallel, lot of
heap size would be occupied, and app would crash, so
objects has to be wisely allocated and cleaned-up from
memory.
Like wise, when we create a thread, a new stack location
would be allocated. So if too many threads are created,
then eventually a time would come when we might run
out of memory crashing the application again.
Like wise, we can risk the harddisk spaces as well.
Thus we should be very particular while accessing these
resources, and should be a very valuable concern of
every Java developer.

Thread and Thread Pool

We all know that for every thread new stack memory is

allocated. Due to this, code runs in parallel.

If you think like a server application developer(suppose
tomcat developer), then for every incoming request, a
thread should be allocated, in order to process the
request.
We can simply create a new thread for every request.
Even tough this would functionally be fine, however would
just be a nightmare when practically deployed on server.
One of the disadvantages of the thread-per-request
approach is that the overhead of creating a new thread for
each request is significant; a server that created a new
thread for each request would spend more time and
consume more system resources creating and destroying
threads than it would processing actual user requests.

Thread and Thread Pool

In addition to the overhead of creating and

destroying threads, active threads consume

system resources. Creating too many threads in
one JVM can cause the system to run out of
memory or thrash due to excessive memory
consumption. To prevent resource thrashing,
server applications need some means of limiting
how many requests are being processed at any
given time.
To avoid this, the best solution is to introduce
and maintain a ThreadPool.

Advantages of Thread
Pool
By reusing threads for multiple tasks, the thread-

creation overhead is spread over many tasks. Eg:

when a request comes, server would create many
threads and keep it ready for execution.
As a bonus, because the thread already exists when
a request arrives, the delay introduced by thread
creation is eliminated. Thus, the request can be
serviced immediately, rendering the application more
responsive.
By properly tuning the number of threads in the
thread pool, you can prevent resource thrashing by
forcing any requests in excess of a certain threshold
to wait until a thread is available to process it.

Thread Pool your usage

If you get a opportunity to work on server

applications, then you can speed up your

response time and avoid memory crash issues.
At times, you can tune the thread pool size of the
server, for suiting your application requirement.
You can create your own thread pools for
performing any asynchronous task.
For specific projects you can design a framework
over core threads and mange it with pool in order
to control sync and async processing of tasks.

Eclipse (with Thread)

While a thread executes, it runs in Stack. Stack

consists of 3 parts: local variables, operand

stack, and frame data. The code instruction
executes one by one based on the logic
Eg:

In this execution flow: Line 1 -> 2 -> 3 -> 6 ->

Eclipse contains a feature by which we can track
the execution flow of a thread. And to add more
to it, we can also see the runtime values of
variables.

Importance of eclipse
debugging

This can be the ultimate tool which can help

you in debugging any major issues during
project dev.
When you catch a thread, then you can see
entire internal details about the thread as to
what is actually happening at runtime of
project.
This can help you in exploring runtime flow of
any use-case with 100% assurance.

Eclipse (with Thread) Debug

Standalone app
For debugging a standalone Java application in

eclipse, follow the below process:

Add breakpoint in java code where you want to stop
the thread execution. (double client on line numbers
mentioned in left)
Right click Java class(with main()), Debug As => Java
App
Executions stops at the line where breakpoint is

added
Using Eclipse debug perspective, walkthrough thread

Starting Tomcat in debug mode

Approach1
Directly configure tomcat in eclipse. Then Debug

On Server would directly start tomcat in debug

mode and help your breakpoints getting caught.
Advantage: This method is very useful when
tomcat is running in local machine, as it saves a
lot of manually efforts and Ecilipse does lot of
things for you.
Disadvantage: While working with shared
integrated environments, where tomcat is on
another linux machine, this process might not be
that handy

Starting Tomcat in debug mode

Approach2
This approach would also be handly while

working with integrated environment

Step 1: Start tomcat in debug mode
Step 2: Eclipse Configuration to connect to
remote tomcat process
Continue

Starting Tomcat in debug mode

Approach2
Start tomcat in debug mode
Goto DOS prompt: <JAVA_HOME> and run
below 2 commands
set JPDA_ADDRESS=8000
set JPDA_TRANSPORT=dt_socket
Run: <JAVA_HOME>/bin/catalina.bat jpda start
Eclipse configuration
Goto Debug configuration
In left pane, start the remote Java application
pointing to 8000 debug port started by tomcat
for accepting remote debug conections.

Thread Dump and usage

Lot of time during application testing, you might

end up in a awkward situation where all your app

threads might be stuck or waiting for something.
And your application would not have any thing
threads available to process your request.
In such cases, it really becomes tough to analyze
as to whats going with the threads. And this
problems grows with huge KLOC(kilo lines of
code). In entire code base, any wrongly
implemented use-case, might have consumed all
your threads.

Thread Dump and usage

Threads might be getting stuck/consuming more

processing time due to any of the below reasons:

Synchronized blocks/methods
Taking more time for DB calls
Dependencies on external resources, like HTTP calls or

remote webservices or remote ejbs

Nested iterations can also add delay.
Or threads might be in sleeping state.

We should write code in such a way so as to optimize

or avoid all of the above issues. But still, while doing

load testing, you might end up observing the above
issues.
Which risks thread utilizations.

Thread Dump and usage

Thread Dumps are used to monitor the state of

any of the application thread at a given point of

time.
Thread dump is a snapshot of all thread-state at
any give point of time.
At a given point of time you can say, which
threads are doing what in your application.
This can help you in identifying the bottleneck
in your application. Then you can visit the code
and work on the piece to make it perform better.

Thread States - JVisualVM

Threads can be in any of the below states
RUNNING: currently threads are performing some
tasks. You can see currently the thread is running
which line of which class.
SLEEPING: Indicates currently thread is in sleeping
state
WAITING: This doesnt specify problem situation, it
simply means that thread is available in pool and
can process any new task which is submitted to
pool.
MONITOR: Currently thread is blocked due to lock
acquired by other thread on a resource which this
thread is trying to active.

Java Visual VM
JVisualVM is a tool which comes along with java

installation under <JAVA_HOME>/bin folder

This can be used to indicate internal memory
details of an application. Like CPU utilizations,
Heap occupancy, classes and thread details in the
memory.
You can effectively check the thread state of the
system.
It provides with a Threads inspector window,
which helps you in identifying at which line
number the threads are currently.

Thank You.

Presenter details:
Name: Tausief Shaikh
EmailId: tausiefshaikh17@gmail.com
Fb:

https://www.facebook.com/tausiefs
Contact: