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

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.
Java Performance: The Definitive Guide
 
Agrandissez cette image
 

Java Performance: The Definitive Guide [Format Kindle]

Scott Oaks

Prix conseillé : EUR 27,80 De quoi s'agit-il ?
Prix éditeur - format imprimé : EUR 35,03
Prix Kindle : EUR 19,46 TTC & envoi gratuit via réseau sans fil par Amazon Whispernet
Économisez : EUR 15,57 (44%)

Formats

Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 19,46  
Broché EUR 35,35  

Auteurs, publiez directement sur Kindle !

KDP
Via notre service de Publication Directe sur Kindle, publiez vous-même vos livres dans la boutique Kindle d'Amazon. C'est rapide, simple et totalement gratuit.




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


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

  • Format : Format Kindle
  • Taille du fichier : 5861 KB
  • Nombre de pages de l'édition imprimée : 426 pages
  • Utilisation simultanée de l'appareil : Illimité
  • Editeur : O'Reilly Media; Édition : 1 (10 avril 2014)
  • Vendu par : Amazon Media EU S.à r.l.
  • Langue : Anglais
  • ASIN: B00JLTOZVQ
  • Synthèse vocale : Activée
  • X-Ray :
  • Classement des meilleures ventes d'Amazon: n°70.246 dans la Boutique Kindle (Voir le Top 100 dans la Boutique Kindle)
  •  Souhaitez-vous faire modifier les images ?


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.6 étoiles sur 5  10 commentaires
5 internautes sur 6 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Excellent Guide to Fine Tuning Java Applications 28 mai 2014
Par Matthew K. 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.
2 internautes sur 2 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Well Written 23 juin 2014
Par John F. Wright - Publié sur Amazon.com
Format:Broché|Commentaire client Vine pour produit gratuit (De quoi s'agit-il?)
Scott Oaks, writes very well, covering a topic which often is a bit obscure but Scott's discussion is clear and understandable.

I'm a bit surprised that Scott mentions that Faban was used as a load generator to measure performance in the examples in the book and he doesn't even mention JMeter.

About 160 pages is on garbage collection and optimizing the JVM About forty pages is on threading, a very welcome discussion!

All in all, I'd say this is a "must have" book for any serious expert Java developer.
1 internautes sur 1 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Good Overview for Pros and Learners Alike 16 juillet 2014
Par Steve Berczuk - Publié sur Amazon.com
Format:Broché|Commentaire client Vine pour produit gratuit (De quoi s'agit-il?)
While tools and technologies change rapidly, and looking up information online is sometimes the best way to get the information you need, I can be useful to occasionally read a book to get oriented in a subject and discover what you didn't know that you didn't know. For me a good technical book sets the context for the problem and gives you enough information to apply what you learned to harder problems that the book covers, but which also gives you information you can apply immediately. Java Performance: The Definitive Guide does a good job of both.

Not just about JVM params, the book covers application and algorithm issues, database connectivity, as well as JVM issues such as garbage collection algorithms. What is useful, and sadly rare, is that this book not only tells you things you can do, it also tells you things that you can skip, since not every thing you do has a good cost/ benefit payoff.

With an emphasis on standard tools, including open source and those that come with the JDK, you can apply what you learned immediately. The book does not cover every tool, and may not include your favorite, but the discussion has enough tools to get you started.

This book will be useful for both those new to programming in Java (since performance and resource use area rarely emphasized who you are learning to program) and those who have been programming a while but have not spent as much time thinking about performance as one might like.
1 internautes sur 1 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 I've already used it with great benefit on the application I work with 4 juillet 2014
Par Jeff Savit - Publié sur Amazon.com
Format:Format Kindle|Achat vérifié
An outstanding resource that lives up to its title. Oaks is expert and gives clear descriptions of how to measure and understand Java performance, why it works as it does, and the steps the practitioner should take to improve performance. I've already used it with great benefit on the application I work with. The strongest possible recommendation for anybody working with Java.
2 internautes sur 3 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Critical and essential information for the high performance Java coder 17 juin 2014
Par Charles Ashbacher - Publié sur Amazon.com
Format:Broché|Commentaire client Vine pour produit gratuit (De quoi s'agit-il?)
All life is a tradeoff and that extends into the the area of software creation. This is especially true in the area of memory management, where there is a dramatic contrast between languages such as C++ where it is the responsibility of the programmer and Java where there is a garbage collector. In my experience, this is the single most differentiating aspect of the languages. I have taught C, C++ and Java classes at a local avionics company and was told by the programmers that memory management was the single biggest issue when considering the adoption of Java. To quote one of them, "You absolutely cannot run out of memory and you absolutely cannot have the garbage collector activate when the plane is landing."
The authors recognize how critical this issue is, for they devote four chapters to memory management, which is slightly over one-third of the content. They delve into many of the details of how the garbage collectors work in Java and the differences between them, specifically the tradeoffs that are made when they are used. Knowledge of the garbage collectors is essential for programming anything that is done in real-time and in the words of one of my students at the avionics company, "If you cannot do it in real-time then there is no point."
Other topics are:

*) Working with the JIT compiler
*) Threading and synchronization performance
*) Database performance best practices
*) Java SE API tips

Writing code is one of the most frustrating and enjoyable things that you can do. There is nothing greater than swearing, sweating and anguishing over code for months and then have it work, doing exactly what you intended it to do. Occasionally, the performance of the code will exceed your expectations.
For most programmers, getting to that pinnacle of achievement also means that the software has to work fast. In the area of Java coding, there is a lot of critical information in this book that will aid the experienced Java programmer. There is some Java code but it is all in the form of snippets designed for illustrative purpose and not meant to be entered, compiled and executed. There are also a few charts and shots of the presentation screens of some of the most widely used tools to measure code performance. If you want to program efficient and crash proof Java programs, you need to know this stuff.
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