Server Side Core Java Training Topics

Two day course examining advanced Java topics in depth

Java Performance profiling and Tuning

Oct 13-14


Reactive programming using Chronicle

Oct 15


Java Memory Management

Oct 16-17


Java Multi-threading and Concurrency

Oct 27-28


Reactive programming using Chronicle

Oct 29


How the JVM works & low level coding

Oct 30-31


*free : free for attendees
The training will be held in London.  The venue will be announced closer to the date.

Java Performance profiling and Tuning (2 days)

This course will look at Java applications from a high level.  This will examine how to understand an applications requirements and bottlenecks.  This will help you determine what needs to be changed to improve the performance of a system. Day One – Morning

  • How to hide problems, how to find problems with performance profiling.
  • Using JMH for benchmarks.
  • Writing custom benchmarks, common pitfalls and how to avoid them.

Day One – Afternoon

  • Measuring latency and throughput, end to end.
  • How to find the biggest opportunities to improve to target your changes (and keep them to a minimum)
  • Profiling an application through analysis.

Day Two – Morning

  • Targeting changes to improve CPU usage.
  • Targeting changes to improve memory usage.
  • Targeting changes to improve multi-threading scalability.

Day Two – Afternoon

  • Targeting changes to improve disk IO.
  • Targeting changes to improve data base access.
  • Targeting changes to improve network IO

Java Memory Management (2 days)

This course focuses and how to reduce the impact of GC pauses, make your system more stable, and improve performance just by producing less garbage. Day One – Morning

  • Java garbage collectors, Parallel, Concurrent and G1.  What are their strengths and weaknesses.  When would you use each one.
  • Common GC tuning parameters, what difference do they make.
  • Measuring memory usage. How to but know how much memory an Object is using?
  • Working with primitives to save memory and reduce garbage.

Day One – Afternoon

  • How to measure your GC behavior and identify what you should change.
  • Command line took to monitor GC activity in production
  • How to estimate what you should change and see that it has improved.

Day Two – Morning

  • How to memory profile your application and identify quick wins in terms of reducing memory consumption.
  • How to profile Java 8 lambdas
  • How to identify memory leaks
  • Investigate changes we can make to reduce memory consumption and allocation rate.

Day Two – Afternoon

  • How to reduce the memory used by String, in a light weight way.
  • How to use double and long safely instead of BigDecimal.
  • How to reduce memory usage generally to improve throughput and latency.
  • Using off heap memory, why and how?

Java Multi-threading and Concurrency (2 days)

This course examines how to engineer a multi-threaded application.  This will help you avoid the pitfalls of over use of multi-threaded and make your systems more deterministic. Day One – Morning

  • How to base line the speed of one thread.
  • How to identify when using multi-threading makes sense.
  • What multi-threading model is appropriate for your use case.
  • How to use thread pools and fork join.

Day One – Afternoon

  • Isolating data to a single thread in a multi-threaded environment.
  • Sharing data between threads.
  • Asynchronous processing and exception handling.
  • Recording work passed between threads.

Day Two – Morning

  • Performance tuning multi-threaded applications
  • Creating multi-threaded performance tests in junit.
  • Lock free algorithms in Java.

Day Two – Afternoon

  • How to use Lambdas in Java 8 for lazy evaluation and parallel coding, with Lists, Sets and Maps.
  • Using concurrent Collectors.
  • Using lambdas with off heap maps

How the JVM really works and low level coding (2 days)

This course examines how to change the way the JVM behaves, how to produce optimal and debug-able dynamic code. Day One – Morning

  • What is byte code and how to read it.
  • Using ASM’s ASMifier.
  • Writing byte code on the fly

Day One Afternoon

  • Custom class loaders
  • Instrumentation via java agents.
  • Adding classes and changing byte code at runtime.

Day Two – Morning

  • Using off heap memory
  • Persisting and sharing memory between processes.
  • Custom serialization.

Day Two – Afternoon

  • How is lambdas implemented in Java 8 at the byte code level.
  • How do CPU caches work, and how to make the most of them.
  • Debugging byte code

Reactive programming using Chronicle (1 day)

This course examine how you can add reactive programming to your system to improve the quality of your systems behavior and performance. Day One – Morning

  • Using Chronicle Logger to improve the performance of your logging.
  • Using Chronicle Queue to record, and replay the inputs and outputs are a deterministic systems
  • Replicating chronicle queues for high availability.
  • Introduction to custom off heap serialization with Chronicle.

Day Two – Afternoon

  • Using Chronicle Map as a high performance persisted map.
  • Sharing data between process with micro-second latencies.
  • Replicating chronicle map for high availability.


Each day has is broken into four 90 minute sessions with lunch in the middle of the day and break out sessions in between. Each day is between 8 and 9 hours long. In the interests of enhancing our course, changes might be made without notice.

£995 or

£795 early bird

per person per day
+ VAT ( Value Added Tax )
Peter Lawrey

for more information