Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Java Concurrency in Practice

Java Concurrency in Practice

Build Java services that stay correct under load, without turning every shared value into a lock.
by Brian Goetz 2005 432 pages
4.48
2k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat concurrency as a problem of shared mutable state, not thread count

Follow the data. Threads are useful for handling independent requests, keeping a user interface responsive, and using multiple processors. But the hard part is not starting threads. It is coordinating access to data that multiple threads can change. A class is thread-safe when it continues to meet its specification regardless of how its operations interleave, without requiring callers to add their own synchronization.

Find every owner. A servlet may appear sequential inside its own method, yet a framework can call that method from several threads at once. Even applications that never create threads directly may receive them through GUI toolkits, timers, or server frameworks. The practical starting question is therefore not “Where are the threads?” but “Which mutable state can they reach?”

Analysis

The state-first view replaces an intimidating topic with a tractable audit: identify what is shared, what can change, and who can reach it. That resembles threat modeling in security, where the focus is on exposed assets and access paths rather than on whether a system looks complicated. The framework examples matter because they show that concurrency is often an inherited property of a component’s environment. A limitation is that state boundaries can be hard to see when references travel through callbacks or containers, making encapsulation and documentation essential parts of the technical design.

Protect whole invariants, not just individual reads and writes

Preserve valid states. A counter increment looks like one action, but it involves reading the old value, adding one, and writing the result. Two threads can both read the same value and lose one update. This is a race condition: correctness depends on favorable timing. A check-then-act sequence, such as testing whether a cache is empty before filling it, has the same vulnerability.

Keep related state together. Two individually atomic fields can still violate a shared rule. A cached input and its result must describe the same computation, so updating or reading them separately can expose a mismatched pair. Guard related variables with the same lock and keep each compound operation inside one protected section. For state-dependent waits, test the condition while holding its lock, then wait in a loop and check again after waking.

Analysis

An invariant is a compact statement of what must remain true, and it gives concurrency design a useful unit of analysis. The important shift is from asking whether each field is protected to asking whether every permitted transition preserves the object’s rules. That is close to transaction design: a sequence that must behave as one indivisible change needs an atomic boundary. The caution is that coarse locking can preserve correctness by serializing far more work than necessary. The right boundary is defined by the invariant first, then refined carefully for performance.

Choose confinement or immutability before reaching for another lock

Make sharing unnecessary. If an object is used by only one thread, it needs no synchronization, even if the object itself is mutable. Local variables are naturally confined to their thread’s stack, provided their references do not escape. Swing takes a similar approach at a larger scale: GUI components and models are accessed only by the event-dispatch thread, while lengthy work runs elsewhere.

Freeze what can be frozen. An immutable object cannot change after construction, so its invariants do not need protection from concurrent updates. A fleet tracker can store immutable coordinate objects and replace them when locations change. ThreadLocal offers each thread a separate value, but can hide dependencies and waste shared resources if used carelessly. Confinement and immutability reduce the number of states a programmer must reason about.

Analysis

This is a design strategy, not merely a coding trick: remove the conditions that make coordination necessary. Immutability shifts complexity to replacement and allocation, while confinement shifts it to ownership rules. Both can be easier to reason about than a lock protocol woven through many methods. The Swing example also illustrates a useful boundary between a responsive interface and background computation. ThreadLocal deserves restraint, however. Per-thread state can quietly turn one shared resource into many private copies, changing the program’s semantics as well as its memory use.

Publish objects through a memory-safe handoff, not just a visible reference

Visibility is part of safety. Synchronization does more than stop two threads from entering a critical section together. It also establishes when one thread’s writes become visible to another. Without that ordering, a reader may see an old flag, fail to see a write at all, or observe a reference to an object before its fields appear fully initialized.

Use defined handoffs. Safe publication can occur through a static initializer, a volatile field, a properly guarded field, or a thread-safe collection or queue. Immutable objects with final fields receive additional initialization guarantees when constructed correctly. A volatile flag can announce a lifecycle change, but it cannot make a multi-step increment atomic. The Java Memory Model describes these guarantees through happens-before relationships, which connect particular writes and reads across threads.

Analysis

The distinction between a reference becoming visible and the referenced object’s state becoming visible is one of the book’s most consequential warnings. It explains why a program can look correct in ordinary tests yet fail under a different compiler or processor schedule. The higher-level idea of a safe handoff is easier to apply than reasoning about every memory operation, and it aligns with ownership-transfer patterns in concurrent systems. Still, volatile is not a general-purpose shortcut: its simplicity is useful precisely when the state transition is simple enough to verify.

Delegate routine coordination to proven concurrent building blocks

Compose, do not improvise. Thread-safe components can often carry their own share of the safety burden. ConcurrentHashMap supports concurrent access without serializing every operation behind one map-wide lock. BlockingQueue coordinates producers and consumers, while semaphores, latches, and barriers manage access or timing between threads. These building blocks encode protocols that are easy to get wrong with raw locks and condition waits.

Check the composition. A cache that stores finished values in a concurrent map can still compute the same missing value twice. Storing a FutureTask for each input lets later callers wait for the existing computation instead. An atomic “insert if absent” operation closes the race in which two threads both start work. Delegation works only when components are independent or the whole compound operation is handled atomically.

Analysis

The book’s library-centered approach reflects a broader engineering principle: reusable abstractions can embody years of testing and design, while shrinking the amount of custom protocol each application must maintain. Its cache example is especially instructive because it distinguishes protecting a data structure from coordinating the work represented by that structure. Yet a safe component does not magically make every larger composition safe. The integration still needs an explicit account of shared invariants, return-value semantics, and failure behavior.

Turn work into bounded tasks, and make overload someone’s explicit problem

Separate work from workers. An Executor decouples task submission from the policy that runs tasks. Creating a new thread for every request may improve responsiveness at first, but unbounded thread creation consumes memory and can bring down a service. A thread pool reuses workers and controls how many tasks run at once; its queue and rejection policy determine what happens when demand exceeds capacity.

Let queues regulate flow. In a producer-consumer design, producers place work on a queue and consumers take it when ready. A bounded queue creates backpressure: when it fills, producers wait or the system applies a chosen overload policy. Independent tasks are easiest to schedule flexibly. Dependent tasks can deadlock if pool workers wait for work that is still queued, so execution policy must fit the tasks.

Analysis

The key insight is that capacity management is part of correctness and service quality, not a tuning detail. A queue does not eliminate overload; it decides where overload accumulates and who experiences it. Bounded queues make that choice visible, while caller-runs and rejection policies make it operational. This is closely related to flow control in communication systems, where a sender must slow down or excess work must be discarded. A thread pool can still fail if its queue is unbounded, so limiting workers alone is not a complete resource policy.

Design cancellation and shutdown as part of the service contract

Stop cooperatively. Java cannot safely force a running thread to stop midway through arbitrary work. Interruption is a request that a task can honor at a suitable stopping point, often by leaving a blocking operation early. Task code should either propagate InterruptedException or restore the interrupted status when it cannot propagate the exception. Silently swallowing an interrupt can prevent the owning service from shutting down correctly.

Define the ending. A service should specify whether shutdown accepts no new work, finishes queued tasks, cancels running tasks, or preserves unfinished work for restart. ExecutorService provides graceful and abrupt shutdown options. A logging service, for example, must account for messages still queued and producers blocked while submitting them. Uncaught task failures also need a visible handling path, such as logging or an exception handler.

Analysis

Lifecycle behavior is where concurrency design meets user expectations. A cancel button, a server stop request, and a process exit are all requests to change an activity’s future, but they need not imply identical cleanup or data guarantees. Cooperative interruption allows a task to preserve its own invariants while responding to its owner. The cost is that responsiveness cannot be assumed: code blocked in some I/O operations may need a separate cancellation mechanism, such as closing the underlying resource. Clear service contracts make these differences explicit.

Prevent deadlock with global lock order and calls outside locks

Break circular waits. Deadlock occurs when threads form a cycle of dependencies, each holding a resource another needs. If one method locks account A and then B while another locks B and then A, both can wait forever. Requiring every thread to acquire locks in one consistent global order prevents this form of deadlock, including when the order must be derived from account identifiers.

Keep calls open. Calling code that is outside a class’s control while holding its lock is dangerous: that code may acquire another lock or block unexpectedly. An open call is a method call made with no locks held. Narrowing the protected section before calling external code reduces both deadlock risk and contention. Thread pools can also deadlock when all workers wait for dependent tasks queued to the same pool.

Analysis

The dining-philosophers problem gives deadlock an intuitive shape: each participant has part of what another needs, and nobody releases what they hold. In software, the cycle may cross object boundaries or even thread-pool capacity, so a local method review can miss it. Global ordering is powerful because it rules out cycles structurally. Open calls complement it by reducing hidden dependencies. These techniques require coordination across components, which is why synchronization policies and execution constraints should be documented rather than left as tribal knowledge.

Optimize measured bottlenecks; serialization sets the speed limit

Find the limiting resource. Threads add scheduling, coordination, and memory-synchronization costs, so parallel code is not automatically faster. Amdahl’s law shows why: if 10 percent of a computation must remain serial, even unlimited processors can provide at most a tenfold speedup. Shared queues, logging, and global counters can become hidden serialized steps.

Reduce contention selectively. Keep locks away from long computations and blocking I/O. Split locks that guard independent state, or use striping to spread access across parts of a collection. Concurrent collections, read-write locks, and atomic variables can help when their semantics fit. Compare performance under realistic loads: high contention can make spinning atomic updates less attractive than blocking locks, and a benchmark from one JVM or machine may not transfer to another.

Analysis

Amdahl’s law is useful not because it predicts every benchmark but because it forces attention onto the irreducibly serial portions of a design. The accompanying performance advice resists a common trap: optimizing the visible operation while ignoring shared coordination around it. This perspective also explains why an implementation that performs more allocation can sometimes scale better if it reduces contention. The counterweight is complexity. Finer-grained locks and nonblocking algorithms can raise throughput, but their maintenance and liveness risks are real costs, not footnotes.

Test interleavings, performance, and assumptions with independent defenses

Stress the schedule. Concurrent failures may depend on rare timing, so a passing unit test is not proof of safety. Tests can run many producers and consumers, coordinate their start with a barrier, and compare checksums to detect lost or duplicated items without adding a heavily contended audit structure. Tests should include more active threads than processors and run across different systems when possible.

Trust no single test. Performance measurements can be distorted by garbage collection, dynamic compilation, unrealistic contention, or work the compiler removes as dead code. Combine stress and performance tests with code review and static analysis. Inspect thread dumps when diagnosing deadlock or contention. These methods catch different classes of errors, and each provides evidence rather than a mathematical guarantee that every failure has been found.

Analysis

Testing concurrent code is itself a concurrency problem: instrumentation can add synchronization, change timing, or hide the defect under investigation. Checksums and coordinated starts are clever because they increase useful interleavings while limiting disturbance to the workload. The larger lesson is epistemic: confidence comes from combining methods with different failure modes, not from treating one long test as definitive. Code review can identify a forbidden state transition before it happens; stress testing can reveal behavior that is difficult to anticipate from inspection alone.

Analysis

Java Concurrency in Practice is best understood as a design manual for controlling shared state, not as a catalogue of thread APIs. Its argument moves from the local problem of atomic updates to the wider architecture of task execution, resource limits, shutdown, and performance. That progression matters: a correct synchronized method can still produce a sluggish service, while a scalable executor can still host tasks that race, deadlock, or never terminate.

The book’s strongest contribution is its repeated insistence on making concurrency policies explicit. Which fields are guarded by which locks? Which tasks may depend on one another? Who owns a worker thread, and what does interruption mean to it? These questions transform vague caution into reviewable design constraints. Encapsulation, immutability, and safe publication are presented not as aesthetic preferences but as ways to shrink the system that must be reasoned about.

Its most useful tension is between safety and throughput. Coarse locks are easy to understand but can serialize unrelated work. Fine-grained locking, atomic updates, and nonblocking algorithms can improve scalability, yet their extra complexity creates new proof obligations. The book therefore treats measurement as a gate: optimize a demonstrated bottleneck, and judge the result under representative workloads rather than by intuition or a narrow benchmark.

The Java 5 and 6 APIs and performance observations are historically situated, so contemporary developers should not copy every tuning recommendation without checking current platform behavior. The durable ideas are more stable than any particular implementation detail: preserve invariants, make ownership and handoffs clear, bound resource use, design endings, and test with multiple forms of evidence. Concurrency becomes manageable not when every interleaving is mentally simulated, but when the design rules out whole classes of dangerous interleavings.

Summary in 30 Seconds
Concurrent correctness depends on protecting related state as a unit and making changes visible through safe handoffs. Reduce coordination by confining mutable objects or making them immutable, and use established concurrent collections and task utilities for routine work. Limit workers and queued tasks so overload has a defined response. Plan for interruption, shutdown, and deadlock prevention. Parallelism has limits: a 10 percent serial portion caps speedup at tenfold, so measure realistic workloads and combine stress tests with code review and analysis.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.48 out of 5
Average of 2k+ ratings from Goodreads and Amazon.

Java Concurrency in Practice is highly praised as an essential read for Java developers. Reviewers commend its comprehensive coverage of concurrency concepts, from basic to advanced topics. The book is lauded for its clear explanations, practical examples, and gradual buildup of knowledge. Many readers appreciate its insights into the Java memory model and concurrency-related APIs. While some note it's slightly dated, the core principles remain relevant. Readers emphasize its value in understanding and implementing safe, efficient concurrent code, with many considering it a must-read for Java programmers.

Your rating:
4.66
337 ratings
Want to read the full book?

Glossary

Java Memory Model

Rules for cross-thread visibility

The Java Memory Model specifies when one thread’s memory actions are guaranteed to be visible to another. It defines ordering rules for events such as lock release and acquisition, volatile writes and reads, and thread start and completion. Correct synchronization establishes the required relationships; without them, reads may see stale values or operations may appear reordered.

happens-before

A visibility and ordering guarantee

Happens-before is the Java Memory Model’s ordering relation between actions. If action A happens-before action B, B is guaranteed to observe the effects of A, subject to later writes. Program order, using the same monitor, volatile-field access, and certain thread and library operations establish these relationships. Without a relevant ordering, a program cannot assume one thread sees another’s writes.

race condition

Correctness depends on timing

A race condition occurs when a computation’s correctness depends on how the runtime interleaves operations from different threads. Examples include incrementing a shared counter through separate read and write steps, or checking that a cache is empty before filling it. Synchronization, confinement, or a suitable atomic operation removes the dependence on favorable timing.

thread confinement

Keep an object within one thread

Thread confinement is a design strategy in which an object is accessed by only one thread. Because its mutable state is not shared, the object does not need synchronization for those accesses. Confinement can arise from local variables, a single-threaded subsystem such as Swing’s event thread, or per-thread storage such as ThreadLocal. The object must not escape its intended scope.

safe publication

Make an initialized object visible

Safe publication ensures that another thread sees an object in the state established before it was shared. Common mechanisms include static initialization, storing the reference in a volatile field, guarding access with a lock, or handing the object through a thread-safe collection or queue. If the object is mutable, safe publication alone does not protect later changes.

producer-consumer pattern

Separate work creation from processing

The producer-consumer pattern separates the creation of work from its execution. Producers place work items on a shared queue, and consumers retrieve and process them independently. A blocking queue can make consumers wait when no work is available and slow producers when a bounded queue is full, providing coordination and a mechanism for managing overload.

Amdahl's law

Limits speedup from parallel work

Amdahl’s law estimates the maximum speedup available from additional processors when part of a computation must remain serial. If fraction F is serial, the theoretical speedup on N processors is limited by the serial portion, and as N grows without bound the maximum approaches 1/F. It highlights why shared locks, queues, and result handling can cap scalability.

compare-and-swap

Update only if unchanged

Compare-and-swap, or CAS, atomically compares a memory location with an expected value and replaces it only if the value still matches. A caller can read a value, calculate an update, and retry if another thread changed the value first. CAS supports atomic variables and nonblocking algorithms, but repeated retries under heavy contention can be costly.

thread starvation deadlock

Workers wait on queued work

Thread starvation deadlock occurs when tasks in a bounded executor block while waiting for other tasks that cannot start because all executor threads are occupied. A single-thread executor makes the simplest case clear: if its only task submits a second task and waits for its result, the second task remains queued indefinitely. Avoid incompatible task dependencies and execution policies.

FAQ

What's Java Concurrency in Practice about?

  • Focus on Concurrency: Java Concurrency in Practice by Brian Goetz is a comprehensive guide to writing concurrent applications in Java, addressing the complexities and challenges of multithreading.
  • Practical Techniques: It covers fundamental concepts like thread safety, synchronization, and the Java Memory Model, providing practical techniques for developing, testing, and debugging multithreaded programs.
  • Target Audience: The book is suitable for Java developers of all levels, offering insights into concurrency design patterns and real-world examples to enhance understanding.

Why should I read Java Concurrency in Practice?

  • Essential for Java Developers: Understanding concurrency is crucial for building responsive and efficient Java applications, making this book a must-read for developers.
  • Expert Insights: Written by Brian Goetz, a leading expert in Java concurrency, the book offers deep and practical insights into the design and implementation of concurrency features.
  • Real-World Applications: It includes real-world scenarios and solutions, helping developers apply concepts directly to their projects and improve code quality.

What are the key takeaways of Java Concurrency in Practice?

  • Thread Safety Principles: Emphasizes managing access to shared, mutable state through synchronization and locks to ensure thread safety.
  • Design Patterns: Introduces design patterns like the Java monitor pattern and thread confinement to structure concurrent applications effectively.
  • Performance Considerations: Discusses performance optimization techniques, including minimizing lock contention and understanding Amdahl's Law for scalability.

What is thread safety according to Java Concurrency in Practice?

  • Definition of Thread Safety: A class is thread-safe if it behaves correctly when accessed by multiple threads concurrently, maintaining consistent and valid state.
  • Importance of Synchronization: Achieving thread safety requires synchronization mechanisms to coordinate access to shared mutable state.
  • Invariants and Postconditions: Thread-safe classes must maintain their invariants and postconditions, ensuring state validity regardless of thread access.

How does Java Concurrency in Practice define the Java Memory Model?

  • Purpose of the Memory Model: Defines how threads interact through memory, providing guarantees about visibility and ordering of operations in concurrent programming.
  • Visibility Guarantees: Without synchronization, changes made by one thread may not be visible to others, emphasizing the need for proper synchronization.
  • Atomicity and Ordering: Discusses how the memory model allows optimizations, affecting atomicity and ordering, and the importance of understanding these implications.

What is the Executor framework in Java Concurrency in Practice?

  • Task Management Simplified: The Executor framework decouples task submission from execution policy, allowing flexible management of concurrent tasks.
  • Thread Pooling: Supports thread pooling, improving resource management by reusing threads and reducing overhead.
  • Simplified Concurrency: By using the Executor framework, developers can avoid complexities of thread management, focusing on task definition and execution policies.

What are some common concurrency hazards discussed in Java Concurrency in Practice?

  • Race Conditions: Occur when the correctness of a computation depends on the relative timing of threads, leading to unexpected behavior.
  • Deadlocks: Happen when threads are blocked forever, each waiting on the other to release a resource, with strategies provided to avoid them.
  • Visibility Issues: Arise when one thread modifies a variable, but another thread does not see the updated value, stressing the need for proper synchronization.

How can I avoid deadlocks according to Java Concurrency in Practice?

  • Consistent Lock Ordering: Acquire locks in a consistent global order to prevent cyclic dependencies between threads.
  • Use Open Calls: Avoid calling alien methods while holding locks to prevent unexpected dependencies and potential deadlocks.
  • Timed Lock Attempts: Implement timed lock attempts using explicit locks to regain control if a lock cannot be acquired within a reasonable timeframe.

What are the main synchronization techniques discussed in Java Concurrency in Practice?

  • Intrinsic Locks: Simplest form of synchronization in Java, providing mutual exclusion for critical sections but can lead to contention.
  • Explicit Locks: ReentrantLock offers more flexibility than intrinsic locks, allowing timed and interruptible lock acquisition.
  • Condition Variables: Allow threads to wait for certain conditions, crucial for implementing patterns like producer-consumer.

What is the significance of Amdahl's Law in Java Concurrency in Practice?

  • Performance Limitation: Illustrates that the maximum speedup of a program is limited by the serial portion of the workload.
  • Scalability Insight: Helps developers understand the impact of serial execution on overall application performance and scalability.
  • Guides Optimization Efforts: Identifying serial components helps focus optimization efforts to improve scalability.

What are the best quotes from Java Concurrency in Practice and what do they mean?

  • "The cost of fairness results primarily from blocking threads.": Highlights that fair algorithms can lead to performance issues due to increased blocking, requiring a balance between fairness and throughput.
  • "Testing concurrent programs for correctness can be extremely challenging.": Reflects the difficulties in ensuring concurrent applications behave as expected, emphasizing rigorous testing.
  • "The goal of testing is not so much to find errors as it is to increase confidence that the code works as expected.": Encourages a focus on building reliable systems rather than merely identifying bugs.

What are some advanced topics covered in Java Concurrency in Practice?

  • Explicit Locks and Condition Variables: Advanced locking mechanisms like ReentrantLock provide more control over synchronization.
  • Nonblocking Algorithms: Use atomic operations instead of locks, offering performance and scalability advantages.
  • The Java Memory Model: In-depth look at how it governs visibility and ordering of operations, essential for writing correct multithreaded applications.

About the Author

Brian Goetz is a renowned expert in Java concurrency and performance optimization. He serves as the Java Language Architect at Oracle, where he plays a crucial role in evolving the Java programming language. Goetz has made significant contributions to Java's concurrency libraries and language features. He is widely respected in the Java community for his deep technical knowledge and ability to explain complex concepts clearly. Besides authoring "Java Concurrency in Practice," Goetz has written numerous articles on Java programming and is a frequent speaker at technology conferences. His work has greatly influenced the development of concurrent programming practices in Java.

Download PDF

To save this Java Concurrency in Practice summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.42 MB     Pages: 21

Download EPUB

To read this Java Concurrency in Practice summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.42 MB     Pages: 26
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...