Analysing Concurrent Programming In Java English Language Essay

When two events occur in same clip interval so it can be said as concurrent. It doesnot average exact blink of an eye. Harmonizing to Hughes and Hughess, ( 2004 ) Concurrence techniques are used to let a computing machine plan to make more work over the same clip period or clip interval. Rather than planing the plan to make one undertaking at a clip, the plan is broken down in such a manner that some of the undertakings can be executed at the same time. Each undertaking may put to death instead. It can put to death in a individual or multiprocessing environment. , by context exchanging undertakings exist concurrent at the same clip and execute within the same clip period in individual processing environment. In a multiprocessor environment, coincident undertakings may put to death at the same blink of an eye over the same clip period, if adequate processors are free.

Harmonizing to the application, the clip period is calculated in a coincident plan ( Hughes and Hughess, 2004 ) . Burns and Davies says that Concurrent programming plays a critical function in systems where many events appear to happen at the same time, such as operating systems, databases and real-time systems.The chief purpose of the concurrent system is bettering the package public presentation by managing big tonss, interrupting down the plan solution and do the package faster ( Hughes and Hughess, 2004 ) .

Purpose of concurrent system in modern computing machine architectures

Addition of application throughput – by put to deathing coincident plan in analogue it allows many undertaking can be completed in certain clip.

Responsiveness is high for both input/output – most application delay for finishing input or end product operations to finish.

The Time spent waiting to be used by another undertaking is allowed in concurrent scheduling.

Coincident undertakings are represented by some jobs and job spheres.

( Wikipedia, )

Some other intent are

System categorization

SISD: Single direction watercourse, individual information watercourse.

SIMD: Single direction watercourse, multiple informations watercourse.

MIMD: Multiple direction watercourse, multiple informations watercourse.

Shared memory multiprocessors

Multicomputer multiprocessors

Network-Based systems

Local area network: Local country webs.

Wide area network: Wide country webs ( Bacon,1992 ) .

Concurrency control and locking

Locking is really of import in concurrence control. Preventing two different users from updating the information at the same clip is the chief end of concurrence control.

Problems While inheriting in coincident plan in Java

Data synchronism are related to the issues making trouble when composing multithread applications. These mistakes make the design more complicated and difficult to observe.

Once an effort is made, one can non endorse off or give up after waiting for some clip period or call off a lock after an interrupt.

Semanticss of a lock can non be altered.

entree control for synchronism is denied.

By restricting the usage of rigorous block-structured lockup, synchronism is done within methods and blocks. One can non get a lock in one method and let go of it in another ( Mahmoud, 2005 ) .

Exercise 2


In Java scheduling linguistic communication has been designed and back up concurrent scheduling, and all executing in the Java takes topographic point in the context of yarn. It is really of import to understanding java coder the power and bounds of Java togss.

Here is an illustration for a coincident plan utilizing java togss.

import ;

import ;

import java.util.Date ;

import java.util.concurrent.Executors ;

import java.util.concurrent.ScheduledExecutorServices ;

import java.util.concurrent.ScheduledFurtur ;

import inactive java.util.concurrent.TimeUnit. * ;

public category MyThreads {

public inactive nothingness chief ( Stringing [ ] statements )


MyThreads mt = new MyThreads ( statements ) ;


public MyThreads ( Stringing [ ] statements )


PrimeFinder [ ] finder = new PrimeFinder [ arguments.length ] ;

for ( int i=0 ; i & lt ; arguments.lenght ; i++ )




long count = Long.parseLong ( statements [ one ] ) ;

finder [ I ] = new PrimeFinder ( count ) ;

System.out.println ( “ happen the premier ” + count ) ;


gimmick ( NumberFormatException nfe )


System.out.println ( “ Mistake: “ + nfe.getMessage ( ) ) ;



bollean complete = false ;

while ( ! complete )


complete = true ;

for ( ( int j-0 ; J & lt ; finder.length ; j++ )


if ( finder [ J ] == nothing ) continu ;

if ( ! finder [ J ] .finished )


complete = false ;




displayResult ( finder [ J ] ) ;

finder [ J ] =null ;





Thread.sleep ( 2000 ) ;


gimmick ( InterruptedException Internet Explorer )

{ // nil here




private nothingness displayResult ( PrimeFinder findr )


System.out.println ( “ Prime ” + + “ is ” + ) ;



Program Explanation:

The My Threads plan can be usage for discovery one or more premier Numberss in sequence.

Stipulate the premier Numberss that you ‘re looking for as bid line statements and include every bit many as you want.

The plan can run the application:

Expected end product is java My threads 1 10 100 1000.

In this plan the first for cringle is used for the My Threads application creates one Prime Finder object for easiness bid line statement specified when the plan is run.

The statements are Strings and the Prime Finder builder requires long values, the Long.parseLong ( Stringing ) category method is used for handle the transition. All the figure parsing methods throw NumberFormatException exclusion, so they are enclosed in attempt gimmick blocks to cover with statements that are non numeral.

When a Prime Finder object is create, the object starts running in it ‘s ain yarn.

In the plan the pieces loop check to see whether any premier finder yarn has completed. Which is indicated by its finished case variable bing true? When a yarn has completed, the show consequence ( ) method is called to expose the premier figure that was found. The yarn so is set to null, liberating the object for refuse aggregation.

The call to thradmin_setupead. Sleep ( 2000 ) in the plan causes the piece cringle to hesitate for 2 seconds during each base on balls through the cringle. A lag in cringles helps maintain the Java translator from put to deathing statement at such a ferocious gait that it becomes bogged down.

Stoping a yarn:

Stoping a yarn is a little more complicated than get downing one. The thread category includes a halt ( ) method that can be called to halt a yarn, but it creates instabilities in Java runtime environment and can present difficult to observe mistakes into a plan. For this ground the method has been deprecated, bespeaking that it should non be used in favour of another technique.

the attempt and catch block are used in this plan for requires two things.

foremost one is protect the codification that contains the method that might throw an exclusion inside a attempt block.

the 2nd 1 is trade with an exclusion inside a gimmick block.

what attempt and catch efficaciously means is: “ seek this spot of codification that might do an exclusion. if it executes okay, travel on with the plan. if the codification does non put to death, catch the exclusion and trade with it. ”

The most coincident scheduling in Java utilizations bundles which are mentioned below,

java.util.concurrent Packages

java.util.concurrent.atomic Package

java.util.concurrent.locks Package

java.util.concurrent Packages description:

Utility classes normally utile in coincident scheduling. This bundle includes a few little standardized extensile models, every bit good as some categories that provide utile functionality and are otherwise boring or hard to implement. Used for The general intent toolkit for development concurrent applications.

java.util.concurrent.atomic Package description

java.util.concurrent.locks Package description:

Interface and categories supplying a model for locking and waiting for conditions that is distinguishable from constitutional synchronism and proctors. The model permits much greater flexibleness in the usage of locks and conditions, at the disbursal of more awkward sentence structure.

Cardinal words in this plan:


It is one of reserved cardinal word I java, which is used to import the other categories where this category is utilizing. Using import we can import any no of categories and you can utilize all the categories.


Class is besides reserved cardinal word in Java, is one type in Java with this we can specify a category and we can make object, where a object can province and behaviour.state is nil but member variables and behaviour is methods.


New is besides one reserved cardinal word in Java, utilizing this new we can make object for any category which is non-abstract category, after making the new object for a category we can entree all the case variables and case methods. We can non entree case variables and case methods without making object for the category. When we create object for the category the default builder will be invoked of that category. If you write the default zero parameterized builders for a category the JVM will non supply you the default builder. If you do n’t compose any builder in your category, the jvm will supply you the default builder as a zero parameterized builder.


Public is the one the entree qualifiers in Java, the other entree qualifiers are Private, protected. Public entree qualifiers can be applicable to category, member variables and methods. if use populace for a category, that category can be used anyplace in the application. Public gives cosmopolitan entree to all the resources that are in the application. If you are composing the populace to the methods those methods can be entree in all other categories, where this category has used.


Private is another entree qualifiers. Private can be applied to merely to methods and variables we can non compose for a category. For a category we can compose merely one entree qualifier i.e. , public, the other one is by non composing any one ( public, private, protected ) , it is a default entree. If you write private to the member variables and to the methods tey can be accessible with in that category merely, we can non entree outside the category.


Inactive is non-access qualifiers in Java, we can compose this inactive to member variables, methods. By composing the inactive to the member variables, methods will acquire entree without making any object to that category, means if we have inactive things declared in category, to entree that inactive thing s we no demand to make object for that category. The inactive things will lade along with the category, so the determination about the inactive things will be taken at compile clip. The case things determination will be taken at runtime.

Main: the chief is the chief method name, if category is holding the chief method so that category is said to be feasible category.

Nothingness: nothingness means the chief method does n’t return anything. The chief method itself is inactive method so all the inactive things can straight utilize in the chief method.

Leave a Reply

Your email address will not be published. Required fields are marked *