Click here to close now.


Java IoT Authors: Elizabeth White, Yakov Fain, Liz McMillan, Pat Romanski, Esmeralda Swartz

Related Topics: Java IoT, Weblogic, Linux Containers

Java IoT: Article

Java Basics: Introduction to Java Threads, Part 2

Internet Portals Like Yahoo, CNN, or Your Bank's Web Site Use Them

In the previous lesson I've explained the basics of Java threads. This time we'll talk about using threads for creating a little more advanced programs.

I'm sure each of you have visited some of the major Internet portals like Yahoo, CNN or your bank's Web site. These portals usually display different types of information like News, Weather, Stock Market quotes, etc. Each of these info pieces appears on the screen instantaneously even though it's coming to the portal from different servers, i.e. the News server may be located in Washington and the stock market data come from New York (see Figure 1 below).

Let's say it takes 4 seconds to receive the news and 3 seconds to get the stock prices. If your program will do it in a sequence, it'll take you 7 seconds total, but why not do this in parallel and reduce the total time to 4 seconds? After all these servers have their own processors that can work in independently from each other! We are not going to discuss Web technologies here, but I'll show you how to spawn parallel processing using multi-threading, collect the returned data and display the results to the user in one shot.

Our program will consist of the following classes:

  • MyPortal that will spawn the threads and collect their returns in an ArrayList of strings. It'll print entire content of this array when all threads complete.
  • NewsServer that will run for 4 seconds and return a message "We have good and bad news";
  • StockServer that will run for 3 seconds and return a message "The stock market is on the rise!".
These threads do not contain any code that actually gets some news or market data. My goal is to show you how threads can communicate with other classes, and after this part works, it wont be difficult to replace the line that prints a static message with a method call that actually connects to the Internet and gets the data as it was explained in the lesson on getting data from the Internet:.

The class in Listing 1 creates and starts two threads (news and stocks) and goes to sleep for 10 seconds just to keep the program alive for a while. Please note that the class MyPortal also passes to each thread a reference to its instance so the threads know were to return the results. After each thread completes, it returns the result to MyPortal by calling its method submitResult(). Each of the resulting strings is being added to the ArrayList dataToDisplay, and when its size grows to two elements MyPortal prints the content of content the collection dataToDisplay. A little later I'll explain why such use of an ArrayList may not be the best solution for this example.

Listing 1. The source code of the class MyPortal

import java.util.ArrayList;
public class MyPortal {
	ArrayList dataToDisplay = new ArrayList();
    public static void main(String args[]){
    	MyPortal mp =new MyPortal();
    	// Spawn the threads and pass them the referennce
    	// to the instance of MyPortal
    	NewsServer myNews = new NewsServer(mp);
    	Thread newsThread = new Thread(myNews);

    	StockServer myStocks = new StockServer(mp);
    	Thread stockThread = new Thread(myStocks);

    	//Start the threads

    	try {
    		System.out.println("MyPortal is sleeping...!");
			Thread.sleep(10000); // wait for 10 sec 
		} catch (InterruptedException e) {

		System.out.println("Good bye!");

    // Add the data returned by a thread to collection
    public void submitResult(String data){

    	// Print the data if both threads have submitted the data
    	// (a buggy version)
    	if (dataToDisplay.size()==2){

The output of this program looks as follows:

MyPortal is sleeping...
[The stock market is on the rise!, We have good and bad news]
Good bye!

The first line will be printed almost immediately, the second line in 4 seconds and the third one in 10 seconds.

Listing 2. The source code of the class StockServer

public class StockServer implements Runnable {
    MyPortal papa;
    // Constructor
    StockServer(MyPortal parent){

    public void run() {
	// Sleep for 3 seconds to emulate some processing
	// and return a string with the market data to the parent
 	try {
		papa.submitResult("The stock market is on the rise!");
	} catch (InterruptedException e) {

Listing 3. The source code of the class NewsServer

public class NewsServer implements Runnable {
    MyPortal papa;

    // Constructor
    NewsServer(MyPortal parent){

	public void run() {
	// Sleep for 4 seconds to emulate some processing
	// and return a string with the news to the parent

		try {
			papa.submitResult("We have  good and bad news");
		} catch (InterruptedException e) {

The thread classes from Listing 2 and Listing 3 store the references to the parent class MyPortal in the variable papa. Each of the threads just sleeps for a specified number of seconds, wakes up and passes an appropriate text to papa.

Please note, that even on a single processor's machine the total execution time of our example is just a little more than 4 seconds. The reason is that our threads where "sleeping in parallel" and did not compete for the processor's time. But if you replace the sleeping part with a loop that performs some calculations, the timing will be different on a single processor machine: the program will run about 7 seconds. If you have a dual processor machine, you'll cut the processing time to 4 seconds again.

Thread Synchronization. A Race Condition.

When you write a multithreaded application you should consider possibility of a so-called race condition. This is a situation when you may get unpredictable results because multiple threads access a resource (i.e. a variable) at the same time. In our example two threads are calling the same method submitResult() which in turn accesses the variable dataToDisplay to add some data to it and check the size of this collection. Imagine that two or more threads finish their work at the same time. Let's look at a possible sequence of events:

  1. The NewsServer calls the method submitResult(). The size of dataToDisplay is 0.
  2. The StockServer calls the method submitResult() a split second later. The size of dataToDisplay is 0.
  3. The NewsServer grabs a zero-element dataToDisplay and starts adding its string there as a first element.
  4. The StockServer grabs a zero-element dataToDisplay (because the NewsServer has not finished adding its first the element yet) and starts adding its string there as a first element.
  5. After both threads are done, the dataToDisplay may wind up with having one element because the first thread's string has been overwritten by the second one. In this is the case, the size of the dataToDisplay will remain one and MyPortal will never print the news and stock data.
Since the probability of this situation is really small, your program may work properly for years and all of a sudden produce unexpected results. Bugs like this one are not easy to discover.

To avoid race conditions, the code that needs to access a "sensitive" variable must be locked (become unavailable for other threads) for the time when one thread works with it. When the first thread completes, the lock is released and another thread can get a hold of this variable/resource. You can arrange such locking either by using a Java keyword synchronized, or by using Java objects that are internally synchronized.

In our portal example, you can simply use the class Vector instead of ArrayList:

Vector dataToDisplay = new Vector();

Vector objects are internally synchronized in Java, and the second thread won't be able to add a string to the dataToDisplay collection until the first thread is done. Obviously, there is a price to pay for this convenience: synchronized objects are a little bit slower than non-synchronized ones.

The other solution is to put an explicit lock for a piece of code that must be completed without any interruption by other threads. For example, if you'll add the keyword synchronized to the signature of the method submitResult(), the second thread will not be able to call this method, if the first one is still executing it:

public synchronized void submitResult(String data){?}

You can also say that a lock is placed on the entire method submitResult().

You should try to minimize the locking time to avoid slowing down your programs. Java allows you to synchronize just a small portion of the code, which is more preferable than synchronizing an entire method.:

    public void submitResult(String data){
    	synchronized (this){

    	if (dataToDisplay.size()==2){

When a synchronized block is executed, the object in parenthesis is locked and cannot be used by any other thread until the lock is released.

Each Java thread has its own memory and the JVM copies there variables from the main program memory. The keyword synchronize means to synch up the content of the main and thread's portions of memory. This ensures that each thread works with the most current value of the resource (in our case its dataToDisplay).

If you spot a group of Java programmers in a bar, after a couple of beers they may start using some mysterious words: monitor and mutex.

A monitor is just a piece of a synchronized code. We can say that one of our threads can enter a monitor and safely modify the variable dataToDisplay. While the first thread is working, another thread(s) may start waiting for this monitor.

Mutex means mutually exclusive, and this term also refers to the fact that threads may take turns accessing some program variable(s).

In this lesson you've learned one of the ways of treating more than one thread as a group, but this is not the only way. Java has a class java.lang.ThreadGroup that allows you to create and start a group of threads, control the threads within the group and check which threads are still active. You may also consider the method join() of the class Thread if one thread needs to wait for completion of another.

Threads can communicate with other Java objects using special methods wait(), notify() and notifyAll(), but this is going to be a topic of another lesson. Meanwhile, you can read more about threads in the Java Tutorial over here:

More Stories By Yakov Fain

Yakov Fain is a co-founder of two software companies: Farata Systems and SuranceBay. He authored several technical books and lots of articles on software development. Yakov is Java Champion ( He leads leads Princeton Java Users Group. Two of Yakov's books will go in print this year: "Enterprise Web Development" (O'Reilly) and "Java For Kids" (No Starch Press).

Comments (3) View Comments

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.

Most Recent Comments
Slava Pestov 02/18/05 07:57:05 PM EST

Yakov, your last threads example has a race condition.

Consider this:

thread 1 executes: synchronized (this){ dataToDisplay.add(data); }.

then thread 2 executes: synchronized (this){ dataToDisplay.add(data); }.

then thread 1 executes: if (dataToDisplay.size()==2){ System.out.println(dataToDisplay); }

then thread 2 executes: if (dataToDisplay.size()==2){ System.out.println(dataToDisplay); }

That last System.out.println(dataToDisplay); executes twice, which is not what you intended.

Yakov Fain 02/04/05 11:41:26 AM EST

Yes, J2EE spec does not recommend it, but if you do it right everything works fine. Here's how this could be done

To control threads in a J2EE container use a thread pool (it's a singleton) and get threads from there. If you use J2SE 5.0, use the package java.util.concurrent (in particular, ThreadPoolExecutor). In J2SE 1.4 and below use an excellent concurrent package created by Doug Lea.

Disclaimer: It's just my personal opinion based on my prior experience with a pretty serious financial application. But I do not recommend you to violate J2EE spec.

Feldhacker 02/04/05 08:35:41 AM EST

Is a J2EE version of this example available? Since J2EE forbids explicit thread management, how would this be done on a web server?

@ThingsExpo Stories
WebRTC services have already permeated corporate communications in the form of videoconferencing solutions. However, WebRTC has the potential of going beyond and catalyzing a new class of services providing more than calls with capabilities such as mass-scale real-time media broadcasting, enriched and augmented video, person-to-machine and machine-to-machine communications. In his session at @ThingsExpo, Luis Lopez, CEO of Kurento, will introduce the technologies required for implementing these ideas and some early experiments performed in the Kurento open source software community in areas ...
Too often with compelling new technologies market participants become overly enamored with that attractiveness of the technology and neglect underlying business drivers. This tendency, what some call the “newest shiny object syndrome,” is understandable given that virtually all of us are heavily engaged in technology. But it is also mistaken. Without concrete business cases driving its deployment, IoT, like many other technologies before it, will fade into obscurity.
SYS-CON Events announced today that Dyn, the worldwide leader in Internet Performance, will exhibit at SYS-CON's 17th International Cloud Expo®, which will take place on November 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA. Dyn is a cloud-based Internet Performance company. Dyn helps companies monitor, control, and optimize online infrastructure for an exceptional end-user experience. Through a world-class network and unrivaled, objective intelligence into Internet conditions, Dyn ensures traffic gets delivered faster, safer, and more reliably than ever.
Today air travel is a minefield of delays, hassles and customer disappointment. Airlines struggle to revitalize the experience. GE and M2Mi will demonstrate practical examples of how IoT solutions are helping airlines bring back personalization, reduce trip time and improve reliability. In their session at @ThingsExpo, Shyam Varan Nath, Principal Architect with GE, and Dr. Sarah Cooper, M2Mi's VP Business Development and Engineering, will explore the IoT cloud-based platform technologies driving this change including privacy controls, data transparency and integration of real time context w...
Who are you? How do you introduce yourself? Do you use a name, or do you greet a friend by the last four digits of his social security number? Assuming you don’t, why are we content to associate our identity with 10 random digits assigned by our phone company? Identity is an issue that affects everyone, but as individuals we don’t spend a lot of time thinking about it. In his session at @ThingsExpo, Ben Klang, Founder & President of Mojo Lingo, will discuss the impact of technology on identity. Should we federate, or not? How should identity be secured? Who owns the identity? How is identity ...
The IoT market is on track to hit $7.1 trillion in 2020. The reality is that only a handful of companies are ready for this massive demand. There are a lot of barriers, paint points, traps, and hidden roadblocks. How can we deal with these issues and challenges? The paradigm has changed. Old-style ad-hoc trial-and-error ways will certainly lead you to the dead end. What is mandatory is an overarching and adaptive approach to effectively handle the rapid changes and exponential growth.
The buzz continues for cloud, data analytics and the Internet of Things (IoT) and their collective impact across all industries. But a new conversation is emerging - how do companies use industry disruption and technology enablers to lead in markets undergoing change, uncertainty and ambiguity? Organizations of all sizes need to evolve and transform, often under massive pressure, as industry lines blur and merge and traditional business models are assaulted and turned upside down. In this new data-driven world, marketplaces reign supreme while interoperability, APIs and applications deliver un...
Electric power utilities face relentless pressure on their financial performance, and reducing distribution grid losses is one of the last untapped opportunities to meet their business goals. Combining IoT-enabled sensors and cloud-based data analytics, utilities now are able to find, quantify and reduce losses faster – and with a smaller IT footprint. Solutions exist using Internet-enabled sensors deployed temporarily at strategic locations within the distribution grid to measure actual line loads.
The Internet of Everything is re-shaping technology trends–moving away from “request/response” architecture to an “always-on” Streaming Web where data is in constant motion and secure, reliable communication is an absolute necessity. As more and more THINGS go online, the challenges that developers will need to address will only increase exponentially. In his session at @ThingsExpo, Todd Greene, Founder & CEO of PubNub, will explore the current state of IoT connectivity and review key trends and technology requirements that will drive the Internet of Things from hype to reality.
The Internet of Things (IoT) is growing rapidly by extending current technologies, products and networks. By 2020, Cisco estimates there will be 50 billion connected devices. Gartner has forecast revenues of over $300 billion, just to IoT suppliers. Now is the time to figure out how you’ll make money – not just create innovative products. With hundreds of new products and companies jumping into the IoT fray every month, there’s no shortage of innovation. Despite this, McKinsey/VisionMobile data shows "less than 10 percent of IoT developers are making enough to support a reasonably sized team....
You have your devices and your data, but what about the rest of your Internet of Things story? Two popular classes of technologies that nicely handle the Big Data analytics for Internet of Things are Apache Hadoop and NoSQL. Hadoop is designed for parallelizing analytical work across many servers and is ideal for the massive data volumes you create with IoT devices. NoSQL databases such as Apache HBase are ideal for storing and retrieving IoT data as “time series data.”
Today’s connected world is moving from devices towards things, what this means is that by using increasingly low cost sensors embedded in devices we can create many new use cases. These span across use cases in cities, vehicles, home, offices, factories, retail environments, worksites, health, logistics, and health. These use cases rely on ubiquitous connectivity and generate massive amounts of data at scale. These technologies enable new business opportunities, ways to optimize and automate, along with new ways to engage with users.
The IoT is upon us, but today’s databases, built on 30-year-old math, require multiple platforms to create a single solution. Data demands of the IoT require Big Data systems that can handle ingest, transactions and analytics concurrently adapting to varied situations as they occur, with speed at scale. In his session at @ThingsExpo, Chad Jones, chief strategy officer at Deep Information Sciences, will look differently at IoT data so enterprises can fully leverage their IoT potential. He’ll share tips on how to speed up business initiatives, harness Big Data and remain one step ahead by apply...
There will be 20 billion IoT devices connected to the Internet soon. What if we could control these devices with our voice, mind, or gestures? What if we could teach these devices how to talk to each other? What if these devices could learn how to interact with us (and each other) to make our lives better? What if Jarvis was real? How can I gain these super powers? In his session at 17th Cloud Expo, Chris Matthieu, co-founder and CTO of Octoblu, will show you!
As a company adopts a DevOps approach to software development, what are key things that both the Dev and Ops side of the business must keep in mind to ensure effective continuous delivery? In his session at DevOps Summit, Mark Hydar, Head of DevOps, Ericsson TV Platforms, will share best practices and provide helpful tips for Ops teams to adopt an open line of communication with the development side of the house to ensure success between the two sides.
SYS-CON Events announced today that ProfitBricks, the provider of painless cloud infrastructure, will exhibit at SYS-CON's 17th International Cloud Expo®, which will take place on November 3–5, 2015, at the Santa Clara Convention Center in Santa Clara, CA. ProfitBricks is the IaaS provider that offers a painless cloud experience for all IT users, with no learning curve. ProfitBricks boasts flexible cloud servers and networking, an integrated Data Center Designer tool for visual control over the cloud and the best price/performance value available. ProfitBricks was named one of the coolest Clo...
SYS-CON Events announced today that IBM Cloud Data Services has been named “Bronze Sponsor” of SYS-CON's 17th Cloud Expo, which will take place on November 3–5, 2015, at the Santa Clara Convention Center in Santa Clara, CA. IBM Cloud Data Services offers a portfolio of integrated, best-of-breed cloud data services for developers focused on mobile computing and analytics use cases.
SYS-CON Events announced today that Sandy Carter, IBM General Manager Cloud Ecosystem and Developers, and a Social Business Evangelist, will keynote at the 17th International Cloud Expo®, which will take place on November 3–5, 2015, at the Santa Clara Convention Center in Santa Clara, CA.
Developing software for the Internet of Things (IoT) comes with its own set of challenges. Security, privacy, and unified standards are a few key issues. In addition, each IoT product is comprised of at least three separate application components: the software embedded in the device, the backend big-data service, and the mobile application for the end user's controls. Each component is developed by a different team, using different technologies and practices, and deployed to a different stack/target - this makes the integration of these separate pipelines and the coordination of software upd...
Mobile messaging has been a popular communication channel for more than 20 years. Finnish engineer Matti Makkonen invented the idea for SMS (Short Message Service) in 1984, making his vision a reality on December 3, 1992 by sending the first message ("Happy Christmas") from a PC to a cell phone. Since then, the technology has evolved immensely, from both a technology standpoint, and in our everyday uses for it. Originally used for person-to-person (P2P) communication, i.e., Sally sends a text message to Betty – mobile messaging now offers tremendous value to businesses for customer and empl...