|By Tod Cunningham||
|January 1, 1998 12:00 AM EST||
Multi-tasking is rapidly becoming a necessity in software development today. All major operating systems support some form of multi-tasking, and as costs come down it is becoming common for high end systems to incorporate multiple processors.
Multi-Tasking and Threads
At its most basic level, multi-tasking allows multiple programs to be run at the "same" time. The best way to visualize this is to think of each application as running on its own processor.
It would be quite inefficient for each application to have a dedicated processor. A major function of most modern operating systems is to make each application share access to processors by preempting one application to let another one run. Figure 1 illustrates the difference between processor sharing and non-sharing.
Just like programs can run concurrently, pieces of the same program can run concurrently. This ability is known as threading and it is what Java supports. Figure 2 illustrates how a program can be threaded.
Threads are becoming more popular because they are faster to set up, often require less memory and allow better encapsulation.
Commonly, it is the responsibility of the operating system to schedule and preempt each thread, just like it preempts each application. This usually leads to platform-specific methods of multi-threading.
Most programming languages rely on operating system-specific calls to support multi-threading. For example: C/C++ programs in Unix often use fork() and Window 95/NT C/C++ programs often use CreateThread(). This can cause a lot of headaches when trying to port an application.
Since one of Java's goals is to "write once, run anywhere", the Java language specification contains support for threading. In theory, this allows multi-threaded programs to be run on any platform which supports Java without concern for how the Java Virtual Machine (JVM) actually implements the threading.
Most JVMs don't actually use native operating system threads to implement threading. They implement their own task scheduling and context switching algorithms within the JVM. This makes the JVM easier to port from one operating system to another. However, Sun is going to be releasing a JVM for the Sun Solaris SPARC which uses native threads to implement Java threads. Having the JVM use native threads can be a real benefit to Java applications because of gained responsiveness to other running processes. Best of all, a Java application doesn't have to do anything special to make use of benefits supplied by different implementations.
Introduction to Java Threading
Java is one of the few common-programming languages that actually supports threading in the language itself.
Java defines a Thread class and a Runnable interface that can be used to define a thread object. Take a look at the Basic Thread example that derives from the Thread class. It creates two threads that display messages asynchronously.
Run this example multiple times and under different JVMs and see how and when the messages are displayed.
Depending on the speed of your machine and the JVM you are using, it may appear that the threads are not being preempted. For example: All of the first thread's messages may be printed followed by all of the second thread's messages.
This usually happens when running on a fast computer or using Just-In-Time (JIT) Java. The reason for this is that one of the sample threads may actually finishing printing all of its messages before it is scheduled for preemption. Try making the threads take longer to finish by increasing MAX_INDEX to 100 (or more) and see what happens.
The Basic Thread example derives from the Thread class to create a thread object; However, a class may implement the Runnable interface instead.
Implementing the Runnable interface is useful when a class needs to be multi-threaded and also be derived from another class. Remember that Java supports only single inheritance.
To change the Basic Thread example to use a Runnable interface, change the CountThread definition to:
public class CountThread implements Runnable Then, change the CountThread object declarations to:
CountThread countRunnable1 =
new CountThread( "Thread 1" );
CountThread countRunnable2 =
new CountThread( "Thread 2" ); Thread countThread1 =
new Thread( CountRunnable1 ); Thread countThread2 =
new Thread( countRunnable2 );
This works because the Thread class supports a special constructor that accepts a Runnable interface. Therefore, we can create a thread based on a Runnable interface. The only method that the interface defines is run().
start() and run()
By calling a Thread object's start() method a Java application tells the JVM to start a separate thread of execution. The JVM will only allow a Thread object to create a single thread of execution for the lifetime of the object. Subsequent calls to an object's start() method will be ignored if the thread associated with the object has terminated; otherwise, the JVM will cause the start() method to throw illegalThreadStateException.
Once the JVM sets up the separate thread of execution it will call the object's run() method from within the newly created thread. The run() method of a Java Thread is like the thread's "main" method. Once started by the JVM, the thread exists until the run() method terminates.
The stop() method is used to stop the execution of a thread before its run() method terminates.
However, the use of stop() is discouraged because it will not always stop a thread. The stop() method is a synchronized method and as such will not stop other synchronized method blocks. This means that a deadlocked thread can't be stopped, which isn't very useful. Synchronized methods are discussed in the section on monitors.
The best way to stop a thread is to let the run() method exit gracefully by using proper synchronization techniques like the ones that follow.
Join is a simple synchronization mechanism that allows one thread to wait for another to finish. In the Basic Thread example, the main application waits for the threads that it started to finish. Note that the order in which threads are joined is not important.
Writing multi-threaded applications usually involves much more than just starting and stopping threads. Usually some form of thread synchronization is required at key points in time. There are two main types of synchronization that Java supports: Monitors and Mutexes.
The term monitor comes from the monolithic monitor (more commonly known today as a kernel) found in operating systems. A fundamental responsibility of an operating system is to protect system resources from unrestricted access, much like a monitor protects the internal data and methods of an object from unrestricted access by other threads.
Each Java object has a monitor and only one thread at a time has access to that monitor. When more than one thread wants access to an object's monitor, they must wait until that monitor is released. Notice that the Thread object itself has nothing to do with implementing monitors. Monitors are inherent in every Java object, and every Java object has its own independent monitor.
Java defines the keyword "synchronized" to gain access to an object's monitor. There are two ways to use synchronize: either by method or by block.
To allow only one thread at a time to access an object's method, use the "synchronized" keyword in the definition of the method.
public synchronized void sem_wait( String currentThreadName )
// Statements here are under protection of the object"s monitor.
// Each instance of the object will allow only one thread at a time access to the method.
To allow only one thread at a time access to a portion of an object's method, use the block form of synchronized within the method (see Listing 5).
Notice that the block form of "synchronized" takes an object as a parameter. The monitor associated with the given object is used to perform the synchronization.
Although we can specify individual methods and blocks to be synchronized, there is still only a single monitor per object. Once a thread enters a synchronized section of an object it has acquired that object's monitor. Since the object's monitor is now acquired, all other threads trying to acquire that monitor will have to wait until it is released. The monitor will be released when the one thread that entered the object's synchronized section leaves the section.
While a thread has acquired an object's monitor, it will immediately succeed in subsequent attempts to acquire that same object's monitor. This makes sense because the purpose of monitors is to allow only a single thread access to some section of code. Since the thread already has access to the monitor it is safe to let that thread execute the code. This is very useful because it means that an object's synchronized methods may call each other without fear of delay or deadlocking.
If for some reason a thread acquires an object's monitor and doesn't release it, the waiting threads will wait "forever". This is called a deadlock and can occur very easily. Deadlocks can be hard to find in code and may not show up under testing depending on the timing of the threads. It is recommended that a monitor be used to protect only what is absolutely necessary for correct behavior. Use the synchronized block mechanism to limit the scope of the monitor. In addition, don't call any methods within a synchronized block except the class Object methods (wait, notify,). This will greatly reduce the chances of deadlocks.
Remember that monitors are based on objects so be careful when using references to objects. Each reference to an object uses the monitor of the object being referenced.
One complexity of monitors is that static methods may also be synchronized. However, a static method is not associated with an object. To handle this, all static synchronized methods of a class share a single monitor that works independently of an object's monitor. When a synchronized method calls a static synchronized method, it must acquire another monitor (the one associated with all static synchronized methods of the class).
Mutexes are used when two or more threads can't interleave certain types of operations. Thus, one sequence must be completed before the other is started. The join() method, used in the Basic Thread example, was a simple fixed use mutex that waits for the thread being joined to stop.
The generic mutex methods: wait(), notify() and notifyAll() are available to all Java objects because they are declared in the Object Java class. These methods allow any thread to wait for any other thread to complete some activity. When the activity is complete, the thread notifies one (or all if notifyAll is called) waiting threads.
The thread that calls an object's wait() method will be suspended and any monitors the thread had acquired will be released. The thread will remain suspended until it is notified and the monitors needed by the thread can be reacquired.
In order for a thread to call an object's wait() method, it must own the object's monitor.
notify() and notifyAll()
A thread calls an object's notify() method when it wants to let a thread waiting on that object know that some activity has been completed. A waiting thread will be awakened and put back in the queue of running threads. However, the awakened thread still has to reacquire all monitors that it released when it called wait().
The thread that calls an object's notify() or notifyAll() method must have possession of the object's monitor.
When notifyAll() is called, all threads that are currently waiting on the object's monitor will be a awakened.
One of the problems with Java Mutexes is that notify will only wake up threads that are currently waiting. This can cause synchronization headaches because one must make sure that a thread waits before notify is called. In other words, the notification is lost when there is no one waiting. While not directly supported by Java, a semaphore can be emulated to solve this problem.
Just like mutexes, semaphores are used when two or more threads can't interleave certain types of operations. Thus, one sequence must be completed before the other is started. However, a semaphore contains more state information that allows it to overcome the limitations of Java mutexes.
We can emulate the most common form of semaphore, called a blocked-set semaphore, by using monitors and mutexes. The blocked-set semaphore has the following definition shown in Listing 4. A single thread awakens one suspended thread.
See the example Semaphore.java for an implementation of this semaphore.
Notice that we will only call notify() if we have first done a wait(), and we will remember when we called sem_signal() without wait() being called.
Putting it all Together
One of the classic concurrent programming problems is the producer/consumer problem. It involves two threads: one producer thread and one consumer thread. Take a look at the producer/consumer example.
The producer produces integer numbers and prints a message that states an integer was produced. The consumer consumes an integer number, supplied by the producer, and prints a message that states an integer was consumed. When the consumer receives the product (number) 0 it knows the producer is done and quits.
A small integer item buffer is used so that the producer can make multiple products without having to wait for the consumer to consume them.
The example just produces integer numbers to keep the example concise. However, the producer/consumer principle can be used to solve many real world problems. A producer could search for files and produce found filenames to a consumer window. A producer could do database queries that send results to a report window. There are countless concurrency problems that may be solved with this technique.
Java developers not only get a great object-oriented language, but also get a language that supports multi-threading. However, just like good object-oriented development requires a different way of thinking, good threaded programming requires a different way of thinking - with the rewards just as great.
Be creative and remember that all aspects of Java can be threaded to solve everyday problems: Windowing interfaces (AWT), saving and loading files (File I/O) and reusable components (Beansª).
M. Ben-Ari, "Principles of Concurrent and Distributed Programming", Prentice Hall, New York, 1990.
S. Oaks & H. Wong, "Java Threads", O'Reilly, MA 1997
Software AG helps organizations transform into Digital Enterprises, so they can differentiate from competitors and better engage customers, partners and employees. Using the Software AG Suite, companies can close the gap between business and IT to create digital systems of differentiation that drive front-line agility. We offer four on-ramps to the Digital Enterprise: alignment through collaborative process analysis; transformation through portfolio management; agility through process automation and integration; and visibility through intelligent business operations and big data.
Sep. 30, 2014 10:30 AM EDT Reads: 1,470
There will be 50 billion Internet connected devices by 2020. Today, every manufacturer has a propriety protocol and an app. How do we securely integrate these "things" into our lives and businesses in a way that we can easily control and manage? Even better, how do we integrate these "things" so that they control and manage each other so our lives become more convenient or our businesses become more profitable and/or safe? We have heard that the best interface is no interface. In his session at Internet of @ThingsExpo, Chris Matthieu, Co-Founder & CTO at Octoblu, Inc., will discuss how these devices generate enough data to learn our behaviors and simplify/improve our lives. What if we could connect everything to everything? I'm not only talking about connecting things to things but also systems, cloud services, and people. Add in a little machine learning and artificial intelligence and now we have something interesting...
Sep. 29, 2014 06:45 AM EDT Reads: 1,870
Last week, while in San Francisco, I used the Uber app and service four times. All four experiences were great, although one of the drivers stopped for 30 seconds and then left as I was walking up to the car. He must have realized I was a blogger. None the less, the next car was just a minute away and I suffered no pain. In this article, my colleague, Ved Sen, Global Head, Advisory Services Social, Mobile and Sensors at Cognizant shares his experiences and insights.
Sep. 28, 2014 09:45 AM EDT Reads: 1,532
We are reaching the end of the beginning with WebRTC and real systems using this technology have begun to appear. One challenge that faces every WebRTC deployment (in some form or another) is identity management. For example, if you have an existing service – possibly built on a variety of different PaaS/SaaS offerings – and you want to add real-time communications you are faced with a challenge relating to user management, authentication, authorization, and validation. Service providers will want to use their existing identities, but these will have credentials already that are (hopefully) irreversibly encoded. In his session at Internet of @ThingsExpo, Peter Dunkley, Technical Director at Acision, will look at how this identity problem can be solved and discuss ways to use existing web identities for real-time communication.
Sep. 27, 2014 11:30 PM EDT Reads: 1,896
Can call centers hang up the phones for good? Intuitive Solutions did. WebRTC enabled this contact center provider to eliminate antiquated telephony and desktop phone infrastructure with a pure web-based solution, allowing them to expand beyond brick-and-mortar confines to a home-based agent model. It also ensured scalability and better service for customers, including MUY! Companies, one of the country's largest franchise restaurant companies with 232 Pizza Hut locations. This is one example of WebRTC adoption today, but the potential is limitless when powered by IoT. Attendees will learn real-world benefits of WebRTC and explore future possibilities, as WebRTC and IoT intersect to improve customer service.
Sep. 27, 2014 10:30 PM EDT Reads: 1,818
From telemedicine to smart cars, digital homes and industrial monitoring, the explosive growth of IoT has created exciting new business opportunities for real time calls and messaging. In his session at Internet of @ThingsExpo, Ivelin Ivanov, CEO and Co-Founder of Telestax, will share some of the new revenue sources that IoT created for Restcomm – the open source telephony platform from Telestax. Ivelin Ivanov is a technology entrepreneur who founded Mobicents, an Open Source VoIP Platform, to help create, deploy, and manage applications integrating voice, video and data. He is the co-founder of TeleStax, an Open Source Cloud Communications company that helps the shift from legacy IN/SS7 telco networks to IP-based cloud comms. An early investor in multiple start-ups, he still finds time to code for his companies and contribute to open source projects.
Sep. 27, 2014 10:30 PM EDT Reads: 2,279
The Internet of Things (IoT) promises to create new business models as significant as those that were inspired by the Internet and the smartphone 20 and 10 years ago. What business, social and practical implications will this phenomenon bring? That's the subject of "Monetizing the Internet of Things: Perspectives from the Front Lines," an e-book released today and available free of charge from Aria Systems, the leading innovator in recurring revenue management.
Sep. 27, 2014 09:45 PM EDT Reads: 2,488
The Internet of Things will put IT to its ultimate test by creating infinite new opportunities to digitize products and services, generate and analyze new data to improve customer satisfaction, and discover new ways to gain a competitive advantage across nearly every industry. In order to help corporate business units to capitalize on the rapidly evolving IoT opportunities, IT must stand up to a new set of challenges.
Sep. 27, 2014 08:45 PM EDT Reads: 2,354
There’s Big Data, then there’s really Big Data from the Internet of Things. IoT is evolving to include many data possibilities like new types of event, log and network data. The volumes are enormous, generating tens of billions of logs per day, which raise data challenges. Early IoT deployments are relying heavily on both the cloud and managed service providers to navigate these challenges. In her session at 6th Big Data Expo®, Hannah Smalltree, Director at Treasure Data, to discuss how IoT, Big Data and deployments are processing massive data volumes from wearables, utilities and other machines.
Sep. 27, 2014 01:00 PM EDT Reads: 2,038
All major researchers estimate there will be tens of billions devices – computers, smartphones, tablets, and sensors – connected to the Internet by 2020. This number will continue to grow at a rapid pace for the next several decades. With major technology companies and startups seriously embracing IoT strategies, now is the perfect time to attend @ThingsExpo in Silicon Valley. Learn what is going on, contribute to the discussions, and ensure that your enterprise is as "IoT-Ready" as it can be!
Sep. 27, 2014 11:00 AM EDT Reads: 2,215
P2P RTC will impact the landscape of communications, shifting from traditional telephony style communications models to OTT (Over-The-Top) cloud assisted & PaaS (Platform as a Service) communication services. The P2P shift will impact many areas of our lives, from mobile communication, human interactive web services, RTC and telephony infrastructure, user federation, security and privacy implications, business costs, and scalability. In his session at Internet of @ThingsExpo, Erik Lagerway, Co-founder of Hookflash, will walk through the shifting landscape of traditional telephone and voice services to the modern P2P RTC era of OTT cloud assisted services.
Sep. 26, 2014 11:45 PM EDT Reads: 1,533
While great strides have been made relative to the video aspects of remote collaboration, audio technology has basically stagnated. Typically all audio is mixed to a single monaural stream and emanates from a single point, such as a speakerphone or a speaker associated with a video monitor. This leads to confusion and lack of understanding among participants especially regarding who is actually speaking. Spatial teleconferencing introduces the concept of acoustic spatial separation between conference participants in three dimensional space. This has been shown to significantly improve comprehension and conference efficiency.
Sep. 26, 2014 10:45 PM EDT Reads: 1,475
The Internet of Things is tied together with a thin strand that is known as time. Coincidentally, at the core of nearly all data analytics is a timestamp. When working with time series data there are a few core principles that everyone should consider, especially across datasets where time is the common boundary. In his session at Internet of @ThingsExpo, Jim Scott, Director of Enterprise Strategy & Architecture at MapR Technologies, will discuss single-value, geo-spatial, and log time series data. By focusing on enterprise applications and the data center, he will use OpenTSDB as an example to explain some of these concepts including when to use different storage models.
Sep. 26, 2014 07:45 PM EDT Reads: 2,289
SYS-CON Events announced today that Gridstore™, the leader in software-defined storage (SDS) purpose-built for Windows Servers and Hyper-V, will exhibit at SYS-CON's 15th International Cloud Expo®, which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. Gridstore™ is the leader in software-defined storage purpose built for virtualization that is designed to accelerate applications in virtualized environments. Using its patented Server-Side Virtual Controller™ Technology (SVCT) to eliminate the I/O blender effect and accelerate applications Gridstore delivers vmOptimized™ Storage that self-optimizes to each application or VM across both virtual and physical environments. Leveraging a grid architecture, Gridstore delivers the first end-to-end storage QoS to ensure the most important App or VM performance is never compromised. The storage grid, that uses Gridstore’s performance optimized nodes or capacity optimized nodes, starts with as few a...
Sep. 26, 2014 06:15 PM EDT Reads: 1,653
The Transparent Cloud-computing Consortium (abbreviation: T-Cloud Consortium) will conduct research activities into changes in the computing model as a result of collaboration between "device" and "cloud" and the creation of new value and markets through organic data processing High speed and high quality networks, and dramatic improvements in computer processing capabilities, have greatly changed the nature of applications and made the storing and processing of data on the network commonplace. These technological reforms have not only changed computers and smartphones, but are also changing the data processing model for all information devices. In particular, in the area known as M2M (Machine-To-Machine), there are great expectations that information with a new type of value can be produced using a variety of devices and sensors saving/sharing data via the network and through large-scale cloud-type data processing. This consortium believes that attaching a huge number of devic...
Sep. 26, 2014 06:00 PM EDT Reads: 1,583
Innodisk is a service-driven provider of industrial embedded flash and DRAM storage products and technologies, with a focus on the enterprise, industrial, aerospace, and defense industries. Innodisk is dedicated to serving their customers and business partners. Quality is vitally important when it comes to industrial embedded flash and DRAM storage products. That’s why Innodisk manufactures all of their products in their own purpose-built memory production facility. In fact, they designed and built their production center to maximize manufacturing efficiency and guarantee the highest quality of our products.
Sep. 26, 2014 05:00 PM EDT Reads: 1,584
All major researchers estimate there will be tens of billions devices - computers, smartphones, tablets, and sensors - connected to the Internet by 2020. This number will continue to grow at a rapid pace for the next several decades. Over the summer Gartner released its much anticipated annual Hype Cycle report and the big news is that Internet of Things has now replaced Big Data as the most hyped technology. Indeed, we're hearing more and more about this fascinating new technological paradigm. Every other IT news item seems to be about IoT and its implications on the future of digital business.
Sep. 26, 2014 10:00 AM EDT Reads: 2,069
Can call centers hang up the phones for good? Intuitive Solutions did. WebRTC enabled this contact center provider to eliminate antiquated telephony and desktop phone infrastructure with a pure web-based solution, allowing them to expand beyond brick-and-mortar confines to a home-based agent model. Download Slide Deck: ▸ Here
Sep. 26, 2014 10:00 AM EDT Reads: 1,528
BSQUARE is a global leader of embedded software solutions. We enable smart connected systems at the device level and beyond that millions use every day and provide actionable data solutions for the growing Internet of Things (IoT) market. We empower our world-class customers with our products, services and solutions to achieve innovation and success. For more information, visit www.bsquare.com.
Sep. 26, 2014 09:45 AM EDT Reads: 1,439
With the iCloud scandal seemingly in its past, Apple announced new iPhones, updates to iPad and MacBook as well as news on OSX Yosemite. Although consumers will have to wait to get their hands on some of that new stuff, what they can get is the latest release of iOS 8 that Apple made available for most in-market iPhones and iPads. Originally announced at WWDC (Apple’s annual developers conference) in June, iOS 8 seems to spearhead Apple’s newfound focus upon greater integration of their products into everyday tasks, cross-platform mobility and self-monitoring. Before you update your device, here is a look at some of the new features and things you may want to consider from a mobile security perspective.
Sep. 26, 2014 09:00 AM EDT Reads: 1,414