Commencez à lire Java Performance: The Definitive Guide sur votre Kindle dans moins d'une minute. Vous n'avez pas encore de Kindle ? Achetez-le ici Ou commencez à lire dès maintenant avec l'une de nos applications de lecture Kindle gratuites.

Envoyer sur votre Kindle ou un autre appareil

 
 
 

Essai gratuit

Découvrez gratuitement un extrait de ce titre

Envoyer sur votre Kindle ou un autre appareil

Désolé, cet article n'est pas disponible en
Image non disponible pour la
couleur :
Image non disponible
 

Java Performance: The Definitive Guide [Format Kindle]

Scott Oaks

Prix conseillé : EUR 32,70 De quoi s'agit-il ?
Prix éditeur - format imprimé : EUR 42,44
Prix Kindle : EUR 19,99 TTC & envoi gratuit via réseau sans fil par Amazon Whispernet
Économisez : EUR 22,45 (53%)

App de lecture Kindle gratuite Tout le monde peut lire les livres Kindle, même sans un appareil Kindle, grâce à l'appli Kindle GRATUITE pour les smartphones, les tablettes et les ordinateurs.

Pour obtenir l'appli gratuite, saisissez votre adresse e-mail ou numéro de téléphone mobile.

Formats

Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 19,99  
Broché EUR 43,22  
-40%, -50%, -60%, -70%... Découvrez les Soldes Amazon jusqu'au 4 août 2015 inclus. Profitez-en !





Les clients ayant acheté cet article ont également acheté

Cette fonction d'achat continuera à charger les articles. Pour naviguer hors de ce carrousel, veuillez utiliser votre touche de raccourci d'en-tête pour naviguer vers l'en-tête précédente ou suivante.

Descriptions du produit

Présentation de l'éditeur

Coding and testing are often considered separate areas of expertise. In this comprehensive guide, author and Java expert Scott Oaks takes the approach that anyone who works with Java should be equally adept at understanding how code behaves in the JVM, as well as the tunings likely to help its performance.

You’ll gain in-depth knowledge of Java application performance, using the Java Virtual Machine (JVM) and the Java platform, including the language and API. Developers and performance engineers alike will learn a variety of features, tools, and processes for improving the way Java 7 and 8 applications perform.

  • Apply four principles for obtaining the best results from performance testing
  • Use JDK tools to collect data on how a Java application is performing
  • Understand the advantages and disadvantages of using a JIT compiler
  • Tune JVM garbage collectors to affect programs as little as possible
  • Use techniques to manage heap memory and JVM native memory
  • Maximize Java threading and synchronization performance features
  • Tackle performance issues in Java EE and Java SE APIs
  • Improve Java-driven database application performance

Détails sur le produit


En savoir plus sur l'auteur

Découvrez des livres, informez-vous sur les écrivains, lisez des blogs d'auteurs et bien plus encore.

Commentaires en ligne

Il n'y a pas encore de commentaires clients sur Amazon.fr
5 étoiles
4 étoiles
3 étoiles
2 étoiles
1 étoiles
Commentaires client les plus utiles sur Amazon.com (beta)
Amazon.com: 4.2 étoiles sur 5  26 commentaires
2 internautes sur 2 ont trouvé ce commentaire utile 
3.0 étoiles sur 5 Generally a nice book and a good thing to use as references ... 6 février 2015
Par JavaSoftwareDeveloper - Publié sur Amazon.com
Format:Format Kindle|Achat vérifié
Generally a nice book and a good thing to use as references though I guess JVM documentation can do the same thing. The take-out of this book is that it can guide you into situation when you might want to think about some JVM param tuning. The author is also quite honest in his writing at the beginning. The best and most applicable way to improve software performance is at the algorithm and coding level.

Some readers here may dissect his examples further, but I think the author has already cautioned us at the beginning about the gain from tuning JVM parameters. Defaults JVM parameters will be good in the vast majority of cases. Overall, I would like to give a 3.5, but since I can't do that. I think 3 is a fair score.
10 internautes sur 14 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Excellent Guide to Fine Tuning Java Applications 28 mai 2014
Par Matt Morgan - Publié sur Amazon.com
Format:Broché|Commentaire client Vine pour produit gratuit (De quoi s'agit-il?)
Program efficiency has not been a major priority for most programmers in recent years as hardware improvements have increased computational speeds and storage capacities have grown tremendously. Why code for efficiency when the hardware will improve and make execution times better and memory requirements less taxing? This has been true not just of Java programmers but of programmers in general, such that fine tuning code to run more efficiently is becoming a lost art. “Java Performance, the Definitive Guide”, in the context of Java programming in particular, brings concepts of efficient programming back to the attention of programmers and offers a lot of solid guidance for developers.

This book is broken down into 12 chapters as follows: 1. Introduction, 2. An Approach to Performance Testing, 3. A Java Performance Toolbox, 4. Working with the JIT Compiler, 5. An Introduction to Garbage Collection, 6. Garbage Collection Algorithms, 7. Heap Memory Best Practices, 8. Native Memory Best Practices, 9. Threading and Synchronization Performance, 10. Java Enterprise Edition Performance, 11. Database Performance Best Practices, and finally 12. Java SE API Tips. The book concludes with an index of tuning flags.

It should be obvious, just from the chapter titles, that this book is more than just a tutorial on how to run a profiler or swap out a bubble sort and in drop in a quick sort. This book covers in detail a wide range of places where your Java code can be carefully tuned to run faster and more efficiently.

I am especially impressed with the coverage of garbage collection. I am no Java guru though I can cobble together an application when called upon to do so, so my understanding of Java’s garbage collection facility has been limited up to this point. I suspect many Java programmers are the same in their understanding of how garbage collection works – mindlessly gather up unused objects and recycle the memory they consume so that more heap memory is available. I never knew there were 4 garbage collection algorithms and that there is some control over which can be used. Author Scott Oaks goes into great technical detail about these algorithms and when to use each, how to tune the garbage collection and more.

The author also gives solid coverage on memory usage, not just the heap where objects are created but also native memory. There is a lot more going on than just using new() to create objects and letting the garbage collector gather up objects no longer in use; the application code itself takes up space and not all objects get created on the heap.

Finally, I like the coverage of thread management and synchronization. The author covers when to use threads, how to optimize data communications between threads more. I have seen several books that cover threads in some detail, but this is the first book where I have seen discussion about proper optimization of messages between threads. I am sure there is more discussion about this in some other books but I have not seen this collected all together like it is here in this book.

This is not an easy read by any stretch of the imagination. Beginning programmers will find themselves over their heads in a huge hurry, as much of the information is very advanced and requires more than a surface knowledge of Java. That said, developers that have a reasonable knowledge of Java will get a lot from this book and will become better developers as a result. Even well-seasoned Java gurus will learn much from this book.

“Java Performance, the Definitive Guide” is a must-read for Java developers looking to make their code as efficient and streamlined as possible. The author imparts a tremendous amount of good knowledge in this book that isn’t necessarily easy to find elsewhere. If you want to be a better Java developer and you want your code to be as sleek and streamlined as possible, and you want all of this information in one place, this is a book you really need.
5 internautes sur 7 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 A must buy for every Java developer struggling with performance or lacking understanding of how JVM works 18 octobre 2014
Par Tomasz Nurkiewicz - Publié sur Amazon.com
Format:Broché
Java Performance: The Definitive Guide is the best Java book I read this year. In about 400 pages Scott Oaks touches every aspect of Java-based applications, from core terminology and methodologies, through tooling, JIT, garbage collection, threading etc., to reach high-level topics, such as Java EE, JDBC/JPA, Java 8 and even... JavaScript and CSS compression. But let's go through this book chapter by chapter.

First the author explains common terms like what is a microbenchmark, measuring throughput versus response time, etc. Surprisingly few sections are devoted solely to statistics and interpretation of inherently varying benchmark results. Oaks goes as far as briefly explaining Student's t-test - important tool in measuring correctness of tests. I found that part very enjoyable (and way too short), but it's just about enough for ordinary purposes. Now it's time to get our hands dirty. Before we start exploring Java performance, author goes through various tool, both available out-of-the-box in JDK and proprietary. A lot is said about different types of profilers - and why they don't show the full picture.

JIT (just-in-time) compiler turns out to be one of the most important tools bringing performance to the JVM. First "real" chapter goes into great details of how JIT works in different modes, how to monitor and tune it. I learnt a lot already, but the best is yet to come. Obviously garbage collection is a major concern, thus Oaks devotes two full chapters to explain all popular GC algorithms. Besides pure description, expect strengths and weaknesses of every algorithm as well as unique tuning options. These two chapters are enough to buy this book, but there's plenty more.

Further into the book, topics are becoming more high-level. We start with assembly and JIT, through GC, heap and native memory, to reach chapters about threading, thread pools and synchronization. There are many, many examples of proper and broken use of multi-threading, including benchmarks - present throughout whole book as well. We also learn how to monitor and tune threads. Later we learn about somewhat related Java EE topics, including XML parsing performance (expect plenty of SAX/StAX/DOM benchmarks!), JSON and Java serialization. Also HTTP sessions and servlets are well covered, with amazing benchmarks how bloated session or incorrectly tuned thread pools affect performance. I was really amazed to see how increasing heap can degrade (!) performance. Last chapter, "Java SE API Tips" is surprisingly interesting, with many good advices about collections, streams and lambdas introduced in Java 8, class loading, I/O, etc. I think you see the overall picture by now - we start almost from hardware level to reach JDBC/JPA and JDK level in the end. Similarly to first chapter, still every concept is accompanied with microbenchmark.

Because this not-so-long book still manages to cover wide range of subjects, I can honestly recommend it to beginners and more experienced Java developers (the former should probably start reading it from back to front). Some aspects are covered only briefly, but in general it was a very enjoyable and thought-provoking lecture. A must buy for every Java developer struggling with performance or lacking understanding of how JVM works. Highly recommended.
2 internautes sur 3 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Java Performance: The Penultimate Guide 26 décembre 2014
Par Eric Jain - Publié sur Amazon.com
Format:Broché
Found this book more practical (and up to date) than Java Performance and Java Performance Tuning. Good explanations of how the different garbage collection algorithms work, how a JIT compiler can optimize code, threading-related issues etc.

The author also shows how to use the tools that ship with Java to see what's going on. Tools like Caliper or JMH for doing valid micro-benchmarks, and JMeter or Gatling for load testing aren't covered, but should at least have been mentioned.

Java Enterprise Performance might need a separate book: Some topics are covered well, but others, like the discussion of optimizing web pages are a bit lacking (read Even Faster Web Sites instead), or missing (no mention of alternatives for serializing data like Protocol Buffers or Avro, or any discussion of "NoSQL"-specific issues).
11 internautes sur 17 ont trouvé ce commentaire utile 
3.0 étoiles sur 5 The JVM can't fix stupid code 2 novembre 2014
Par Dr. Chrilly Donninger - Publié sur Amazon.com
Format:Broché
The author presents in the 2nd chapter code for storing and calculating simple statistics for simulated stock time-series. I have implemented such a programm for a real application (Godotfinance). The code of Oaks is unbelievable bloated. In the classic book "Programming Pearls" Jon Bentley would have shown how one can speed up this code by an order of 2 and reduce the memory-size by another order. An obvious optimization is: The stock-prices are stored as BigDecimal. But in fact an int is sufficient. The decimal places are defined by the contract. In case of stocks it's usually 2, in case of Yen-futures it is 6. But in any case it is known beforehand. One stores 98.17 as 9817. For calculations there is no need to scale at every step. It is sufficient to do this only once at the end. One has of course to know something about the field of application. One could argue that this is not related to Java at all. But if someone "shoots" with BigDecimal canons on stock-prices he has not to care about performance anymore. Besides BigDecimal there are other Java-specific datastructures (e.g. Hashmap) which are not suited for timeseries.
Instead of improving the poor Java code the author analyses in the following chapters to great detail if one can improve the performance with different parameters and flags of the JVM. This detailed coverage is the strong part of the book. His - obvious - conclusion is: The default parameters are hard to beat. The improvements are at it's best 10-20%. It is clear that there are no magic JVM flags which can speed up bad code by 2 orders.

The same pattern happens in the chapter about database performance. For each stock the data of a timestamp t are stored in a record of a relational database. This is even worse than using BigDecimal instead of ints. Relational DB were not made for storing timeseries efficiently. One has to store a whole chunk of the timeseries in a BLOB. The disadvantage of this "trick" is: The code depends now on the data-representation in the BLOB. But this solution is at least an order faster and reduces also disk-space considerable. In fact one could ask if there is any need for a Relational DB at all. Timeseries have a very simple structure. One can store each series in a file. This solution is 2-3 orders faster than the original one proposed by Oaks. Instead he tunes - with modest success - the parameters of JDBC and JPA.
His conclusions about the Java Native Interface are: "JNI is not a solution to performance problems. Javacode will almost always run faster than calling native code". Mixing managed and unmanaged code is certainly a pain in the ass. JNI has also a considerable overhead. But Oaks is wrong when he states: "Well-written Java code will run at least as fast on current versions of the JVM as corresponding C or C++ Code (it is not 1996 anymore)". JIT-Compilation has improved considerable in the last years. But Java has structural overheads. E.g. one has also for elementary datatypes the object-overhead. For typical Strings the overhead is about 70%. Garbagge Collection can also by quite demanding.

I would have given 5 (or even 6) stars if the title of the book would be "All about JVM-Tuning". But according my understanding is the main topic of Java-Performance how to implement efficient Java-code. The book is in this respect disappointing.
Ces commentaires ont-ils été utiles ?   Dites-le-nous

Discussions entre clients

Le forum concernant ce produit
Discussion Réponses Message le plus récent
Pas de discussions pour l'instant

Posez des questions, partagez votre opinion, gagnez en compréhension
Démarrer une nouvelle discussion
Thème:
Première publication:
Aller s'identifier
 

Rechercher parmi les discussions des clients
Rechercher dans toutes les discussions Amazon
   


Rechercher des articles similaires par rubrique