Scribd
Upload
88 views21 pages

Playing With Threads: Tausief Shaikh

The document discusses best practices for developing software using threads. It notes that while coding applications is easy, developing high-quality software requires optimizing resource usage. It recommends using a thread pool to process requests rather than creating a new thread for each, to avoid memory issues. The document also discusses using Eclipse and Java VisualVM to debug threads, see thread states, and analyze performance bottlenecks.

Uploaded by

Prabhakar Prabhu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
88 views21 pages

Playing With Threads: Tausief Shaikh

The document discusses best practices for developing software using threads. It notes that while coding applications is easy, developing high-quality software requires optimizing resource usage. It recommends using a thread pool to process requests rather than creating a new thread for each, to avoid memory issues. The document also discusses using Eclipse and Java VisualVM to debug threads, see thread states, and analyze performance bottlenecks.

Uploaded by

Prabhakar Prabhu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 21

Playing With

Threads

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
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
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: [email protected]
Fb: https://www.facebook.com/tausiefs
Contact:

You might also like