Buy Viagra Soft

My news brief on Java Concurrency has been posted on OCI’s site.

Concurrent or multi-threaded software is not a new technology but its importance has been accelerating. This is primarily due to the low cost of multi-core CPUs that are becoming common in even the most basic machines. This trend is expected to continue as hardware manufacturers, following Moore’s law, cram greater numbers of cores onto a single die at ever lower costs. In the past older applications have taken advantage of faster hardware for improved performance, thus extending their functional life. In the future this will be less common because CPUs are not expected to be significantly faster; instead they will be doing more in parallel. There is no better feeling for a developer than knowing that his/her software has withstood the test of time. This is rare, of course, because technology and methodologies don’t remain static but continue to progress with the relentless march of time. It is not advisable to rewrite everything to make use of concurrent algorithms. However, finding places where it makes sense to add multi-threading and “use the right tool for the job” may greatly increase application longevity. It would require a short course to do justice to the topic of concurrent Java development so the remainder of this brief will focus on demonstrating a few of the features with the hope that the reader will continue further study on his/her own.

Read the full article here: Discover the Elegant Simplicity of JSR 166

When doing concurrent development it’s easy to make mistakes that may produce unexpected results. It can be very hard to track down these bugs. As a quick first look at the problem check to see how thread safety is being enforced. You should find one of the following techniques in use:

• Immutable objects can always be shared between threads without concern for thread safety. To accomplish this the object may need to be in an immutable wrapper class or marked as final/const.
• Objects that are accessed by only one thread that never changes do not need to add protective code because simultaneous access will not be possible. If a thread should die or need to be replaced the change logic will need to use of of the other another mechanisms to ensure thread safety.
• A lock must be held whenever reading or writing to a shared modifiable object. Lookout for situations of ‘check then modify’ where the code reads a value and then modifies the same variable. In these situations the lock must be held for the duration of both the read and the write.

The growing importance of concurrency in software development can not be over stated. Background Thanks to Weiqi Gao’s blog I recently found my self listening to a great lecture on the topic of concurrency by Herb Sutter. At the moment I am reading “The Singularity Is Near” by Ray Kurzweill and found many of the ideas mesh very well with what Mr. Sutter had to say. Kurzweill predicts that Moore’s law will continue for the foreseeable future but it may not be in the way we might first think. Just like Sutter he agrees that we will see more transistors per chip but much of his focus is on the point in the future when we will have enough computational power to simulate human brains. In order to achieve believable simulated humans with simulated neurons that truly fire in parallel we must begin developing more concurrent systems today and expand our expertise in this area of computer science. This lines up well with the physics limitations that Sutter points out in his paper that prevent us from further dramatic increases in the clock speed. In the past we have always enjoyed faster clock speeds with each new generation of CPU’s, in the future we will see CPU’s continue to grow in complexity and power but it will come in the form of more parallel instructions and multiple cores. We are already seeing these prognostications coming to fruition in the commercial sector with the introduction of multi-core CPU’s by major manufacturers. Quad-core CPU’s are less than a year away from both AMD and Intel. Based on Moore’s law we should expect 8 core CPU’s 18 months later and 16 cores shortly after that. Implications Developing excellent concurrent solutions is a very valuable skill that will serve you increasingly well over the years. Typical software that may only use a few threads or even be single threaded will not see significant performance gains as they are run on the next generation of CPU’s. Software must be redesigned to take advantage of the massively parallel capabilities that will be provided by tomorrows hardware. To this end it’s in our best interest to study up on the topic of concurrency in software development. Herb Sutter envisions a day when our programming languages can handle concurrent engineering in much more elegant ways than they can today. Threads and locks are too primitive therefore we need more abstract ways to describe tasks that must be done in parallel. My hope is that we will see these new idioms sooner so we can become more efficient with our time but the reality is such that we will be forced to use the tools at hand. To help you become more excellent in your development skills this post marks the beginning of a series on the topic of concurrency. To see all the posts on this topic click on the Concurrency Series link under CATEGORIES: on the left. Stay tuned for more. If you are not subscribed to this RSS feed please add this link to your favorite reader.