Asynchronous programming using CompletableFutures in Java

Aug 3, 2017Download as pptx, pdf

1 like552 views

This document discusses asynchronous programming using CompletableFuture in Java. It begins by explaining what asynchronous programming is and why it is important to use non-blocking I/O. It then provides examples of how to use CompletableFuture to make asynchronous method calls and combine results. Some pros and cons of using CompletableFuture are discussed, along with design considerations for asynchronous programming.

Asynchronous programming
using CompletableFutures

Agenda
• What is asynchronous programming?
• Why should I care?
• How to use CompletableFuture for asynchronous calls?
• Does it worth it?

Latency Numbers
0.5
25
100
0 20 40 60 80 100 120
ns
Main memory reference
Mutex lock/unlock
L1 Cache Reference

Latency Numbers
100
10,000
150,000
0 20000 40000 60000 80000 100000 120000 140000 160000
ns
Read 4K randomly from SSD
Send 1K over 1 Gbps
Main memory reference

Latency Numbers
150,000
250,000
500,000
10,000,0
00
0 2,000,000 4,000,000 6,000,000 8,000,000 10,000,000 12,000,000
ns
Disk seek
Round trip within same
datacenter
Read 1 MB sequentially from
memory
Read 4K randomly from SSD

The Hollywood Principle
Don’t call us,
we’ll call you

Why should I care?
• Process scheduling in modern kernels is pretty mature
• Re-implementing it in user-space is an anti-pattern
• Java relies on kernel process scheduling

It’s about
• Controlling thread lifecycle
• The Nr. of threads and context switches
• I/O operation optimization

Non blocking I/O
Why should I map number of threads to number of connections?
It doesn’t make sense.

The Selector
Client 1
Client 2
Selector
Handler
Handler

Anatomy of a typical Java application
? ?
Your code goes
here

How to use CompletableFuture
for asynchronous calls?

Asynchronous programming using CompletableFutures in Java

Tomcat 8
HelloService
Small I/O
Scenario 1

Tomcat 8
HelloService
125ms
Scenario 2
In-memory

Tomcat 8
HelloService
Small I/O
Scenario 4
4 threads

Pros & Cons
Pros
• Combinable executors
• Exception handling
• Fast enough execution
• Java language support
• Easy
Cons
• You have to know what you’re
doing
• Can be blocking
• Can be slower if Executor
scheduling is a bottleneck

Design Considerations
• Blocking 1000 threads because of service failure? Not a smart decision
• Queueing 1000 request-timeouts because of same reasons? Bad idea.
• Bit better choice: less pressure on downstream services
• Choose threading and scheduling mechanism wisely
• ForkJoinPool is most of the time a bad choice
• Monitor and purge request queues in case of a specific failure rate
• Hystrix offers similar mechanism

References
GitHub examples
https://github.com/gitaroktato/completablefuture-examples
CPU Scheduling
https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/5_CPU_Scheduling.html
CompletableFuture & Spring Example
https://spring.io/guides/gs/async-method/
Non-blocking IO in Java
https://dnhome.wordpress.com/2012/06/28/java-non-block-io-new-io/

References
CompletableFuture API Examples
https://www.slideshare.net/jpaumard/asynchronous-api-in-java8-how-to-use-completablefuture
Grizzly NIO framework
https://grizzly.java.net/documentation.html
Scalable IO in Java
https://www.slideshare.net/giridhar510/scalable-io-in-java
Non-blocking IO in Java
https://dnhome.wordpress.com/2012/06/28/java-non-block-io-new-io/
RxJava – Multithreading
https://praveer09.github.io/technology/2016/02/29/rxjava-part-3-multithreading/

This document discusses techniques for achieving low latency in Java applications. It begins by defining latency as the time interval between stimulation and response. For applications, total response time equals service time plus waiting time for service. Latency requirements of less than 100ms are given as an example of low latency. The document then explores specific techniques for reducing latency, such as avoiding context switching through thread pooling, optimizing logging through asynchronous approaches, addressing DNS lookup delays, and monitoring and tuning garbage collection. Overall it provides guidance on analyzing and improving various aspects of application performance to meet strict low latency goals.

20140228 fp and_performanceshinolajla

This document discusses performance considerations for functional programming and reactive applications. It notes that while functional programming has benefits, the JVM is optimized for imperative programming so functional abstractions can carry performance penalties. It recommends focusing on reducing allocations, bytecode execution, and regaining runtime control. The document also provides tips on tools and techniques for performance analysis and optimization like avoiding parallel collections, pinning to cores, and judicious use of memory barriers and JVM flags.

Self-Aware Applications: Automatic Production Monitoring (TechDays NL 2017)Dina Goldshtein

The road to zen winds through self-monitoring applications, which can reduce the time and effort in diagnosing and correcting production issues. In this talk, we will see how modern Windows applications can self-monitor, self-diagnose, and potentially self-recover without needing an external monitoring agent or a brute-force restarting watchdog. By harnessing the power of ETW for low-level accurate monitoring, Windows performance counters for zero-overhead statistics, and the CLRMD library for inspecting your own threads, heap objects, and locks, you can take your applications one step closer to self-awareness. This will be illustrated through a series of demos: automatic CPU profiling and pinpointing the busy threads and stacks; automatic GC monitoring, including object allocations; automatic heap analysis to reveal unraveling memory leaks; and more. At the end of the talk, you will be equipped with tools and techniques for implementing self-monitoring in your own applications.

Training Slides: 103 - Basics - Simple Tungsten Clustering InstallationContinuent

This 52min training session summarises what you need to know with regards to Tungsten Clustering architecture and topologies; and then dives into its installation process. TOPICS COVERED - Re-cap of the Architecture And Topology - Plan The Installation - Documentation - Software - Environmental Decisions - Review Pre-Requisites - Review Installation Types And Methods - Walk Through: Simple 3 Node Cluster Installation

Concurrent Programming in PythonAdam Englander

This document discusses concurrent programming in Python. It covers threading, processes, subprocesses, and concurrent frameworks. Threading uses thread-local data, locks, and events to coordinate between threads. Processes allow spawning child processes and interprocess communication. Subprocesses run other scripts. Concurrent frameworks like Curio use futures to allow asynchronous function programming. The document provides examples of using processes and subprocesses in Python and recommends concurrent frameworks for all but simple applications.

BDM37 - Simon Grondin - Scaling an API proxy in OCamlBig Data Montreal

1. Scaling up a system by reducing complexity and eliminating unnecessary work is often cheaper than scaling out by adding more servers and hardware. Approaching problems with a scaling up mindset from the start can avoid dead-end solutions. 2. Key steps to scaling up include picking tools that encourage good design, eliminating work by making systems do less, and eliminating synchronization between components to reduce overhead. This allows bulk operations and pipelining of work. 3. Using immutable and idempotent data structures where each operation acts on a message and nodes process messages independently without help from others can help scaling up systems.

Scala e xchange 2013 haoyi li on metascala a tiny diy jvmSkills Matter

Metascala is a tiny metacircular Java Virtual Machine (JVM) written in the Scala programming language. Metascala is barely 3000 lines of Scala, and is complete enough that it is able to interpret itself metacircularly. Being written in Scala and compiled to Java bytecode, the Metascala JVM requires a host JVM in order to run. The goal of Metascala is to create a platform to experiment with the JVM: a 3000 line JVM written in Scala is probably much more approachable than the 1,000,000 lines of C/C++ which make up HotSpot, the standard implementation, and more amenable to implementing fun features like continuations, isolates or value classes. The 3000 lines of code gives you: The bytecode interpreter, together with all the run-time data structures A stack-machine to SSA register-machine bytecode translator A custom heap, complete with a stop-the-world, copying garbage collector Implementations of parts of the JVM's native interface Although it is far from a complete implementation, Metascala already provides the ability to run untrusted bytecode securely (albeit slowly), since every operation which could potentially cause harm (including memory allocations and CPU usage) is virtualized and can be controlled. Ongoing work includes tightening of the security guarantees, improving compatibility and increasing performance. ENJOYIN

How netty works internallyAmirHossain94

Netty is an event-driven networking framework that provides high performance and low latency for handling concurrent requests. It uses a non-blocking I/O model with an event loop and a selector thread to improve throughput and avoid OutOfMemoryErrors. Netty implements TCP/IP sockets using asynchronous socket channels to prevent issues from slow, fast, or overloaded connections. Netty is useful for handling concurrent requests but may not be needed for all applications.

Scaling tappsiÓscar Andrés López

Rails on JRubyRob C

Topaz for Java Performance WebcastCompuware

Java presents a critical opportunity for companies to quickly innovate on the mainframe platform to meet the relentless demands of the digital economy. But how do you develop game-changing solutions on the mainframe while making sure the operational demands of the rest of your enterprise aren’t compromised? Newly unveiled Topaz for Java Performance aims to help you realize the benefits of Java on z while maintaining the high performance expectations of your mainframe environment. Compuware Product Managers Steve Kansa and Spencer Hallman join Technical Consultant Glenn Everitt to demo Topaz for Java Performance’s “under the hood” visibility into the behavior of Java on the mainframe including: - measuring Java Classes CPU performance - identifying areas for code optimization - spotting Garbage Collection issues such as memory leaks - identifying blocked Threads - seamlessly integrating with Compuware Strobe for full mainframe performance analysis

EDB Failover Manager for Seamless Failover & SwitchoverAshnikbiz

How to build a highly available PostgreSQL Cluster using EDB Failover Manager? Database downtime can cost your business significant revenue. And while PostgreSQL is incredibly stable, it does not identify a database failure or automatically switches traffic to a standby database. In such a scenario, EDB Failover Manager (EFM) can be at the forefront of automatically detecting master database failures and promoting the most up-to-date standby database to take over. Register for this free webinar and learn how EDB Failover Manager helps you build a highly available PostgreSQL Cluster for overall business continuity.

CPAN Gems From The Far Eastlestrrat

Kolon and TTerse are pluggable template syntax options for XSLATE, a full-featured and fast templating system that is 158 times faster than TT2. XSLATE's website is at http://xslate.org. HTTP::Async is a HTTP client that is 7 times faster than LWP and 4 times faster than HTTP::Lite, making it good for REST APIs but not user agent tasks. Server::Starter is a wrapper that allows hot reloading of network servers by listening on a port and restarting on HUP. DBIx::Class provides a cleaner SQL::Abstract clone that is easier to extend. Test::mysqld and Test::postgresql allow easily bringing up database instances for

High performance in react nativeViet Tran

This document discusses techniques for improving React Native performance. It notes that React Native is not truly native but provides native capabilities. The main thread can lag if loops take longer than 16.67ms each frame. Common mistakes include creating massive components, not removing listeners on unmount, double rendering, and heavy computation on the main thread. Ways to improve performance include using native animation, caching resources, dividing components, and using high performance libraries. The document is a presentation on optimizing React Native applications for high performance.

Productivity and scalability with Play and ScalaChristophe Marchal

UEMB260: Provisioning: Under the HoodIvanti

This document summarizes provisioning methods and best practices in Ivanti. It discusses: 1. PXE and vBoot provisioning methods for remote, on-site, and lab environments. 2. Common problems like incorrect preferred server credentials, broken core communication, or outdated PXE repositories. Logs and troubleshooting steps are also provided. 3. Template settings like "Stop processing template if action fails" and how they affect PXE vs vBoot workflows. 4. Enhancements in Ivanti 2016.3 like PXE client self-election, real-time variable lookup, and identifying machine attributes.

Episode 2 conditional flows & loopsJitendra Zaa

Manage your environment with DSCGian Maria Ricci

The document discusses using PowerShell Desired State Configuration (DSC) to automate the deployment and management of environments. It describes how DSC can be used to specify the desired state of an environment and have PowerShell work to ensure the actual state matches that desired configuration. This involves authoring DSC configurations that define resources and their desired properties, then applying those configurations to automatically install software, configure systems, and ensure services are running as specified. The document provides examples of using DSC to deploy a website along with its database components in a multi-step process.

Zero mq logsTomas Doran

This document discusses using ZeroMQ and Elasticsearch for log aggregation. It proposes using ZeroMQ to transmit structured log data from application servers to a central Logstash server, which would then insert the logs into Elasticsearch for querying and analysis. This approach aims to provide a lightweight logging solution that doesn't block application servers like traditional logging to databases can. The document also provides background on tools like Logstash, Elasticsearch, and Splunk.

Multiply like rabbits with rabbit mqColdFusionConference

This document discusses using RabbitMQ for messaging between applications. It begins with an introduction to the presenter and agenda. It then contrasts traditional RPC-style calls with messaging and covers some benefits of messaging like decoupling and flexibility. Common messaging patterns like publish/subscribe, topics, and work queues are introduced. The AMQP protocol and RabbitMQ implementation are explained. Finally, a demo of RabbitMQ is promised and questions are solicited.

Enterprise messagingColdFusionConference

This document discusses decoupling applications and scaling with enterprise messaging. It introduces messaging concepts like producers, consumers, and message brokers. It focuses on the AMQP protocol and RabbitMQ as a messaging implementation. Key points covered include RPC vs messaging styles, decoupling applications, cross-platform communication, and load balancing. The presenter demonstrates a messaging example using Java, CFML, Node.js, and JavaScript producers and consumers communicating via a RabbitMQ broker.

Being Agile with Scrum - koders.coEnder Aydin Orak

This document provides an overview of scrum and agile principles and practices. It discusses lean principles, the history and evolution of scrum, core scrum concepts like the product backlog, sprints, sprint planning, daily standups, reviews and retrospectives. It also covers scrum roles like the product owner and scrum master. Finally, it discusses topics like estimating, managing technical debt, requirements and user stories. The document serves as a comprehensive guide to scrum and agile concepts.

Erlang at Nu EchoNu Echo Inc.

This document summarizes Nu Echo's experience using Erlang to build their hosted grammar server. It describes how they used Erlang and OTP principles to build a high-performance, fault-tolerant, and distributed system with components like Yaws HTTP server, Mnesia database, and Jinterface for Java integration. It also discusses lessons learned around Erlang's strengths in gluing systems together and handling protocols, and weaknesses in string manipulation. The document emphasizes learning and using OTP patterns from the start.

Transactional Streaming: If you can compute it, you can probably stream it.jhugg

This document discusses transactional stream processing and operational state. It argues that integrating state management and stream processing within the same transactional system avoids issues caused by independent failures of separate systems and reduces the need for "glue code". It provides examples of how transactional stream processing can enable features like correlation, deduplication, and aggregation in a reliable way. Key aspects that are important for operational workloads like counting, accounting, and statistics are ensuring idempotence and implementing operations atomically within transactions.

Java garbage collection, jvm, visual vmBrad Schoening, MSCS

This document discusses the Java heap and stack memory areas, garbage collection (GC) in the Java Virtual Machine (JVM), and tools for monitoring JVM memory usage and GC. It describes the heap, stack, and how objects are allocated in each. It outlines the different GC generations (Eden, Survivor, Tenured) and collectors (default, parallel, CMS, G1GC). It also defines a Java memory leak and provides symptoms. Finally, it lists several tools for monitoring JVM memory and GC, including Visual VM, JConsole, and jcmd.

From silex to symfony and viceversaRonny López

- Ports and Adapters is an architecture pattern that decouples an application's domain model from its technical infrastructure and external interfaces to make it more testable. It defines relationships with the outside world through "ports" and isolates the domain model. - The presentation discusses how to apply this pattern to avoid business logic infiltration over time by clearly separating layers and modules with single responsibilities. It emphasizes building testable code and detecting violations of architectural promises. - Examples of Silex and Symfony implementations are provided, along with tips on using controllers to convert requests and dispatch commands without direct module coupling.

Squeeze Maximum Performance from your Hosting PlatformSiteGround.com

The presentation covers useful insights and benchmark tests on how the performance (and security) of PHP/MySQL based applications can be significantly improved through different tweaks done at server administration level (Linux/Apache). It also examines several different types of hosting platforms: dedicated, virtual/cloud and shared, and how they can influence the CMS application speed and security. A presentation delivered by SiteGround CEO at CMS Expo - Chicago, May 8-10 2012.

Need for Async: Hot pursuit for scalable applicationsKonrad Malawski

This document discusses asynchronous processing and how it relates to scalability and performance. It begins with an introduction on why asynchronous processing is important for highly parallel systems. It then covers topics like asynchronous I/O, scheduling, latency measurement, concurrent data structures, and techniques for distributed systems like backup requests and combined requests. The overall message is that asynchronous programming allows more efficient use of resources through approaches like non-blocking I/O, and that understanding these principles is key to building scalable applications.

The Future of Futures - A Talk About Java 8 CompletableFuturesHaim Yadid

Completable futureSrinivasan Raghvan

The document discusses CompletableFuture in Java. It begins with an introduction to java.util.Future and its limitations. It then discusses how CompletableFuture allows asynchronous and parallel operations through callbacks and chaining of tasks. This improves performance over serial execution. It provides examples of CompletableFuture methods like supplyAsync, thenApply, thenCombine, and allOf. Finally, it discusses how CompletableFuture can be used to build powerful and scalable libraries.

More Related Content

What's hot (19)

Scaling tappsiÓscar Andrés López

Rails on JRubyRob C

Topaz for Java Performance WebcastCompuware

EDB Failover Manager for Seamless Failover & SwitchoverAshnikbiz

CPAN Gems From The Far Eastlestrrat

High performance in react nativeViet Tran

Productivity and scalability with Play and ScalaChristophe Marchal

UEMB260: Provisioning: Under the HoodIvanti

Episode 2 conditional flows & loopsJitendra Zaa

Manage your environment with DSCGian Maria Ricci

Zero mq logsTomas Doran

Multiply like rabbits with rabbit mqColdFusionConference

Enterprise messagingColdFusionConference

Being Agile with Scrum - koders.coEnder Aydin Orak

Erlang at Nu EchoNu Echo Inc.

Transactional Streaming: If you can compute it, you can probably stream it.jhugg

Java garbage collection, jvm, visual vmBrad Schoening, MSCS

From silex to symfony and viceversaRonny López

Squeeze Maximum Performance from your Hosting PlatformSiteGround.com

Scaling tappsiÓscar Andrés López

Rails on JRubyRob C

Topaz for Java Performance WebcastCompuware

EDB Failover Manager for Seamless Failover & SwitchoverAshnikbiz

CPAN Gems From The Far Eastlestrrat

High performance in react nativeViet Tran

Productivity and scalability with Play and ScalaChristophe Marchal

UEMB260: Provisioning: Under the HoodIvanti

Episode 2 conditional flows & loopsJitendra Zaa

Manage your environment with DSCGian Maria Ricci

Zero mq logsTomas Doran

Multiply like rabbits with rabbit mqColdFusionConference

Enterprise messagingColdFusionConference

Being Agile with Scrum - koders.coEnder Aydin Orak

Erlang at Nu EchoNu Echo Inc.

Transactional Streaming: If you can compute it, you can probably stream it.jhugg

Java garbage collection, jvm, visual vmBrad Schoening, MSCS

From silex to symfony and viceversaRonny López

Squeeze Maximum Performance from your Hosting PlatformSiteGround.com

Similar to Asynchronous programming using CompletableFutures in Java (20)

Need for Async: Hot pursuit for scalable applicationsKonrad Malawski

The Future of Futures - A Talk About Java 8 CompletableFuturesHaim Yadid

Completable futureSrinivasan Raghvan

Asynchronous API in Java8, how to use CompletableFutureJosé Paumard

Asynchronous programming with Functional Java and comparison with ScalaKnoldus Inc.

In recent times, programmers have started realizing the benefits of functional programming and are beginning to rediscover the powerful style of this programming paradigm. Java has also realized its advantages and is slowly inching towards it. Taking a simple scenario where a need arises of handling a task asynchronously, the role of asynchronous programming comes into the picture. In these slides, you will have its deep understanding with some examples along with the comparison with Scala.

The Need for Async @ ScalaWorldKonrad Malawski

The document provides an overview of asynchronous processing and how it relates to scalability and performance. It discusses key topics like sync vs async, scheduling, latency measurement, concurrent vs lock-free vs wait-free data structures, I/O models like IO, AIO, NIO, zero-copy, and sorting algorithms. It emphasizes picking the right tools for the job and properly benchmarking and measuring performance.

Leverage CompletableFutures to handle async queries. DevNexus 2022David Gómez García

Slides used at DevNexus 22 talk. Completable futures were introduced in Java 8, and they are a powerful mechanism to add concurrency (not parallelism) to your application logic, and it may be handy when dealing with multiple queries to different systems. If you are a developer, you may make your code more performant by using CompletableFutures where it makes sense. If you are a library developer, it may be a good thing to offer an API that returns CompletableFutures so that your users will be able to benefit from it.

Interactions complicate debuggingSyed Zaid Irshad

Asynchronous programming with Java & SpringRavindra Ranwala

Asynchronous programming allows starting a thread to assign a task without blocking the main thread. It uses resources optimally and avoids freezing user interfaces. Asynchronous programming evolved from threads to thread pools and futures. It differs from multithreading by staying mostly in a single thread without synchronization issues. Asynchronous tasks can be created using thread pools like fixed, cached, and scheduled pools. Completable futures improved on futures by making chaining of asynchronous tasks easier through completion stages that represent tasks and their states.

Java 8 concurrency abstractionsNawazish Mohammad Khan

This document discusses Java 8 concurrency abstractions including asynchronous result processing using CompletableFuture and optimistic locking using StampedLock. It provides an overview and comparison to previous concurrency APIs. The agenda includes exploring CompletableFuture features like asynchronous execution, chaining reactions, and exception handling. It also covers using StampedLock for optimistic reads, comparing it to the previous ReentrantReadWriteLock approach. Examples are shown for common use cases of these new concurrency APIs.

Programming Sideways: Asynchronous Techniques for AndroidEmanuele Di Saverio

parallel-asynchronous-programming-java.pptx2022ac05156

Asynchronous Programming.pptxAayush Chimaniya

This document discusses asynchronous programming in Spring Framework. It begins with an introduction to asynchronous programming and its benefits. It then explains the differences between synchronous, multithreading, and asynchronous programming. It provides examples of how asynchronous programming works in Spring using annotations like @Async and @EnableAsync. It also covers best practices for asynchronous programming in Spring including exception handling. The document concludes by noting some cons of asynchronous programming and reinforcing its key benefits.

Back to the [Completable] FutureSofiia Khomyn

A first look into the Project Loom in JavaLukas Steinbrecher

Project Loom aims to bring asynchronous programming to Java with virtual threads. Virtual threads allow blocking code to run asynchronously by scheduling continuations across lightweight threads. This avoids the "blue world" problem of rewriting synchronous code for asynchronous systems. It also enables scaling applications by utilizing non-blocking I/O without changing existing code or libraries. While virtual threads are not yet production-ready, Project Loom has the potential to improve scalability for Java applications without a major paradigm shift.

Concurrency, Parallelism And IOPiyush Katariya

Concurrency involves accomplishing multiple tasks with shared resources, giving the illusion of parallelism to users. Parallelism accomplishes tasks with dedicated resources, making it most efficient. I/O involves accessing network sockets, disks, files, and system calls. It can be blocking or non-blocking. Computational constructs like processes, threads, mutexes, coroutines, and green threads are used. Amdahl's law and latency vs throughput are discussed. Asynchronous processing uses buffers to separate producers and consumers. Event loops, actors, CSP, and observers are programming abstractions. Various runtimes like JVM, NodeJS, CPython, Go, BEAM, and GHC are compared for concurrency and parallel

Concurrent Programming in JavaRuben Inoto Soto

Concurrent Programming in Java discusses various approaches to concurrency in Java including threads, executors, fork/join, parallel streams, CompletableFuture, and RXJava. It explains challenges with threads like interference, deadlocks, and performance overhead. It then covers enhancements in Java 5+ including executors and concurrent collections. Later sections discuss functional-style concurrency with CompletableFuture and RXJava, which allow composing asynchronous operations without blocking.

4Developers 2015: Programowanie synchroniczne i asynchroniczne - dwa światy k...PROIDEA

This document discusses asynchronous and synchronous programming in Java. It covers several key aspects: 1. Java supports both multi-threading for synchronous programming as well as asynchronous programming using non-blocking I/O and libraries like RxJava. 2. Asynchronous programming can be difficult due to issues like complex error handling, lack of readability, and difficulty debugging. 3. Many open-source libraries have been created to help with asynchronous programming using approaches like futures, callbacks, and promises. 4. Reactive programming libraries like RxJava, Reactor, and Vert.x use approaches like asynchronous streams to simplify asynchronous code.

Leveraging Completable Futures to handle your query results AsynchrhonouslyDavid Gómez García

The document discusses leveraging CompletableFutures to handle asynchronous query results in Java. It begins with an overview of concurrency vs parallelism and tools in Java for concurrency. It then covers using ExecutorServices and Futures to run tasks asynchronously before introducing CompletableFutures, which allow fluent chaining and composition of dependent asynchronous tasks. Examples are provided of using CompletableFutures to run database queries asynchronously and maximize performance. Considerations for using CompletableFutures in APIs are also discussed.

Understanding concurrencyAnshul Sharma

This document discusses concurrency in Python. It defines concurrency as the simultaneous occurrence of events and describes different concurrency features in Python like threading and asyncio. It explains that threading uses preemptive multitasking while asyncio uses cooperative multitasking. The document also discusses when concurrency is useful for CPU-bound versus I/O-bound programs and provides examples of using threading, asyncio, and multiprocessing to speed up I/O-bound and CPU-bound programs. In the conclusion, it recommends determining if a program is CPU-bound or I/O-bound and then choosing the appropriate concurrency approach.

Need for Async: Hot pursuit for scalable applicationsKonrad Malawski

The Future of Futures - A Talk About Java 8 CompletableFuturesHaim Yadid

Completable futureSrinivasan Raghvan

Asynchronous API in Java8, how to use CompletableFutureJosé Paumard

Asynchronous programming with Functional Java and comparison with ScalaKnoldus Inc.

The Need for Async @ ScalaWorldKonrad Malawski

Leverage CompletableFutures to handle async queries. DevNexus 2022David Gómez García

Interactions complicate debuggingSyed Zaid Irshad

Asynchronous programming with Java & SpringRavindra Ranwala

Java 8 concurrency abstractionsNawazish Mohammad Khan

Programming Sideways: Asynchronous Techniques for AndroidEmanuele Di Saverio

parallel-asynchronous-programming-java.pptx2022ac05156

Asynchronous Programming.pptxAayush Chimaniya

Back to the [Completable] FutureSofiia Khomyn

A first look into the Project Loom in JavaLukas Steinbrecher

Concurrency, Parallelism And IOPiyush Katariya

Concurrent Programming in JavaRuben Inoto Soto

4Developers 2015: Programowanie synchroniczne i asynchroniczne - dwa światy k...PROIDEA

Leveraging Completable Futures to handle your query results AsynchrhonouslyDavid Gómez García

Understanding concurrencyAnshul Sharma

More from Oresztész Margaritisz (7)

Overview of health-check patternsOresztész Margaritisz

I guess every developer heard a few things about health checks. If you're lucky enough, you've also worked in a project where they were implemented and used. But why do we need health checks after all? How should I implement them properly to accomplish the desired goal? In this talk, I'm going to go through the various implementations and compare them to each other, so at the end, developers will be able to pick the most suitable one for their needs. After all, these are the things that make us sleep better during the night, while our services are doing their work in production.

Being agile with modern JavaOresztész Margaritisz

The document discusses principles and practices for being agile with modern Java development. It emphasizes taking small iterative steps, continuous optimization, continuous integration and testing, hotswapping code changes without restarts, treating infrastructure as code, and using Skaffold and Kubernetes for local development and deployment. It also discusses test automation strategies like unit, integration and end-to-end testing as well as code generation and documentation practices that support an agile approach.

How to make technical deicisons?Oresztész Margaritisz

The document discusses factors to consider when making technical decisions such as maturity, technical constraints, feature richness, stability, performance, and learning curve. It advocates using set-based design principles like parallel dependencies, interfaces, and feature toggles. It also emphasizes the importance of decision making processes being collaborative and focusing on how decisions will be made rather than just the technical outcomes.

Cassandra On EPAM Cloud - VDAY 2017Oresztész Margaritisz

Cassandra on EPAM CloudOresztész Margaritisz

ForkJoinPools and parallel streamsOresztész Margaritisz

This document discusses ForkJoinPools and parallel streams in Java and provides advice on their proper usage. It notes that all parallel streams use the common ForkJoinPool by default, which can cause performance issues if one operation blocks. The document recommends avoiding the common pool and using CompletableFuture with a custom executor instead. It also provides alternatives to ForkJoinPools like Reactor Core and Akka for asynchronous programming.

Introduction to DC/OSOresztész Margaritisz

DC/OS is an operating system for datacenters that provides distributed computing capabilities. It aims to make distributed computing easier to manage and less error-prone by allowing 10,000+ nodes to be orchestrated together. DC/OS offers features like networking, orchestration, monitoring, and service registry capabilities to help avoid vendor lock-in and make custom distributed solutions less expensive to build and maintain compared to individual approaches.

Overview of health-check patternsOresztész Margaritisz

Being agile with modern JavaOresztész Margaritisz

How to make technical deicisons?Oresztész Margaritisz

Cassandra On EPAM Cloud - VDAY 2017Oresztész Margaritisz

Cassandra on EPAM CloudOresztész Margaritisz

ForkJoinPools and parallel streamsOresztész Margaritisz

Introduction to DC/OSOresztész Margaritisz

Recently uploaded (20)

June Patch TuesdayIvanti

Ivanti’s Patch Tuesday breakdown goes beyond patching your applications and brings you the intelligence and guidance needed to prioritize where to focus your attention first. Catch early analysis on our Ivanti blog, then join industry expert Chris Goettl for the Patch Tuesday Webinar Event. There we’ll do a deep dive into each of the bulletins and give guidance on the risks associated with the newly-identified vulnerabilities.

cnc-drilling-dowel-inserting-machine-drillteq-d-510-english.pdfAmirStern2

Murdledescargadarkweb.pdfvolumen1 100 elementaryJorgeSemperteguiMont

Kubernetes Security Act Now Before It’s Too LateMichael Furman

In today's cloud-native landscape, Kubernetes has become the de facto standard for orchestrating containerized applications, but its inherent complexity introduces unique security challenges. Are you one YAML away from disaster? This presentation, "Kubernetes Security: Act Now Before It’s Too Late," is your essential guide to understanding and mitigating the critical security risks within your Kubernetes environments. This presentation dives deep into the OWASP Kubernetes Top Ten, providing actionable insights to harden your clusters. We will cover: The fundamental architecture of Kubernetes and why its security is paramount. In-depth strategies for protecting your Kubernetes Control Plane, including kube-apiserver and etcd. Crucial best practices for securing your workloads and nodes, covering topics like privileged containers, root filesystem security, and the essential role of Pod Security Admission. Don't wait for a breach. Learn how to identify, prevent, and respond to Kubernetes security threats effectively. It's time to act now before it's too late!

Introduction to Typescript - GDG On Campus EUEGoogle Developer Group On Campus European Universities in Egypt

Interested in leveling up your JavaScript skills? Join us for our Introduction to TypeScript workshop. Learn how TypeScript can improve your code with dynamic typing, better tooling, and cleaner architecture. Whether you're a beginner or have some experience with JavaScript, this session will give you a solid foundation in TypeScript and how to integrate it into your projects. Workshop content: - What is TypeScript? - What is the problem with JavaScript? - Why TypeScript is the solution - Coding demo

Integration of Utility Data into 3D BIM Models Using a 3D Solids Modeling Wor...Safe Software

Jacobs has developed a 3D utility solids modelling workflow to improve the integration of utility data into 3D Building Information Modeling (BIM) environments. This workflow, a collaborative effort between the New Zealand Geospatial Team and the Australian Data Capture Team, employs FME to convert 2D utility data into detailed 3D representations, supporting enhanced spatial analysis and clash detection. To enable the automation of this process, Jacobs has also developed a survey data standard that standardizes the capture of existing utilities. This standard ensures consistency in data collection, forming the foundation for the subsequent automated validation and modelling steps. The workflow begins with the acquisition of utility survey data, including attributes such as location, depth, diameter, and material of utility assets like pipes and manholes. This data is validated through a custom-built tool that ensures completeness and logical consistency, including checks for proper connectivity between network components. Following validation, the data is processed using an automated modelling tool to generate 3D solids from 2D geometric representations. These solids are then integrated into BIM models to facilitate compatibility with 3D workflows and enable detailed spatial analyses. The workflow contributes to improved spatial understanding by visualizing the relationships between utilities and other infrastructure elements. The automation of validation and modeling processes ensures consistent and accurate outputs, minimizing errors and increasing workflow efficiency. This methodology highlights the application of FME in addressing challenges associated with geospatial data transformation and demonstrates its utility in enhancing data integration within BIM frameworks. By enabling accurate 3D representation of utility networks, the workflow supports improved design collaboration and decision-making in complex infrastructure projects

“Why It’s Critical to Have an Integrated Development Methodology for Edge AI,...Edge AI and Vision Alliance

For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2025/06/why-its-critical-to-have-an-integrated-development-methodology-for-edge-ai-a-presentation-from-lattice-semiconductor/ Sreepada Hegade, Director of ML Systems and Software at Lattice Semiconductor, presents the “Why It’s Critical to Have an Integrated Development Methodology for Edge AI” tutorial at the May 2025 Embedded Vision Summit. The deployment of neural networks near sensors brings well-known advantages such as lower latency, privacy and reduced overall system cost—but also brings significant challenges that complicate development. These challenges can be addressed effectively by choosing the right solution and design methodology. The low-power FPGAs from Lattice are well poised to enable efficient edge implementation of models, while Lattice’s proven development methodology helps to mitigate the challenges and risks associated with edge model deployment. In this presentation, Hegade explains the importance of an integrated framework that tightly consolidates different aspects of edge AI development, including training, quantization of networks for edge deployment, integration with sensors and inferencing. He also illustrates how Lattice’s simplified tool flow helps to achieve the best trade-off between power, performance and efficiency using low-power FPGAs for edge deployment of various AI workloads.

FIDO Seminar: New Data: Passkey Adoption in the Workforce.pptxFIDO Alliance

No-Code Workflows for CAD & 3D Data: Scaling AI-Driven InfrastructureSafe Software

When projects depend on fast, reliable spatial data, every minute counts. AI Clearing needed a faster way to handle complex spatial data from drone surveys, CAD designs and 3D project models across construction sites. With FME Form, they built no-code workflows to clean, convert, integrate, and validate dozens of data formats – cutting analysis time from 5 hours to just 30 minutes. Join us, our partner Globema, and customer AI Clearing to see how they: -Automate processing of 2D, 3D, drone, spatial, and non-spatial data -Analyze construction progress 10x faster and with fewer errors -Handle diverse formats like DWG, KML, SHP, and PDF with ease -Scale their workflows for international projects in solar, roads, and pipelines If you work with complex data, join us to learn how to optimize your own processes and transform your results with FME.

Oracle Cloud and AI Specialization ProgramVICTOR MAESTRE RAMIREZ

Mastering AI Workflows with FME - Peak of Data & AI 2025Safe Software

Harness the full potential of AI with FME: From creating high-quality training data to optimizing models and utilizing results, FME supports every step of your AI workflow. Seamlessly integrate a wide range of models, including those for data enhancement, forecasting, image and object recognition, and large language models. Customize AI models to meet your exact needs with FME’s powerful tools for training, optimization, and seamless integration

Crypto Super 500 - 14th Report - June2025.pdfStephen Perrenod

This OrionX's 14th semi-annual report on the state of the cryptocurrency mining market. The report focuses on Proof-of-Work cryptocurrencies since those use substantial supercomputer power to mint new coins and encode transactions on their blockchains. Only two make the cut this time, Bitcoin with $18 billion of annual economic value produced and Dogecoin with $1 billion. Bitcoin has now reached the Zettascale with typical hash rates of 0.9 Zettahashes per second. Bitcoin is powered by the world's largest decentralized supercomputer in a continuous winner take all lottery incentive network.

Oracle Cloud Infrastructure Generative AI ProfessionalVICTOR MAESTRE RAMIREZ

National Fuels Treatments Initiative: Building a Seamless Map of Hazardous Fu...Safe Software

The National Fuels Treatments Initiative (NFT) is transforming wildfire mitigation by creating a standardized map of nationwide fuels treatment locations across all land ownerships in the United States. While existing state and federal systems capture this data in diverse formats, NFT bridges these gaps, delivering the first truly integrated national view. This dataset will be used to measure the implementation of the National Cohesive Wildland Strategy and demonstrate the positive impact of collective investments in hazardous fuels reduction nationwide. In Phase 1, we developed an ETL pipeline template in FME Form, leveraging a schema-agnostic workflow with dynamic feature handling intended for fast roll-out and light maintenance. This was key as the initiative scaled from a few to over fifty contributors nationwide. By directly pulling from agency data stores, oftentimes ArcGIS Feature Services, NFT preserves existing structures, minimizing preparation needs. External mapping tables ensure consistent attribute and domain alignment, while robust change detection processes keep data current and actionable. Now in Phase 2, we’re migrating pipelines to FME Flow to take advantage of advanced scheduling, monitoring dashboards, and automated notifications to streamline operations. Join us to explore how this initiative exemplifies the power of technology, blending FME, ArcGIS Online, and AWS to solve a national business problem with a scalable, automated solution.

AudGram Review: Build Visually Appealing, AI-Enhanced Audiograms to Engage Yo...SOFTTECHHUB

FIDO Seminar: Authentication for a Billion Consumers - Amazon.pptxFIDO Alliance

PyData - Graph Theory for Multi-Agent Integrationbarqawicloud

Graph theory is a well-known concept for algorithms and can be used to orchestrate the building of multi-model pipelines. By translating tasks and dependencies into a Directed Acyclic Graph, we can orchestrate diverse AI models, including NLP, vision, and recommendation capabilities. This tutorial provides a step-by-step approach to designing graph-based AI model pipelines, focusing on clinical use cases from the field.

Can We Use Rust to Develop Extensions for PostgreSQL? (POSETTE: An Event for ...NTT DATA Technology & Innovation

FIDO Alliance Seminar State of Passkeys.pptxFIDO Alliance

Data Validation and System InteroperabilitySafe Software