Using synchronized methods in java

This post has long code segments in it, so I’ll explain what it all does at the top. Then at the end, just copy paste into your favourite editor/IDE to play with it.

So the title kind of gives it away, but the concept behind it was quite interesting. Imagine you have some kind of resource, like a network connection, a file etc, which is needs to be accessed by many threads, but only one thread at a time. Using synchronized methods achieves this. Its especially handy where you might have hundreds of threads which need to modify the same resource, but should do it, one at a time. This code can do that (although its not perfect by far)

In this example, we have a padlock, which we can open , and close. Of course, we can’t open it whilst its being closed, and vica versa. You could just run the openLock and closeLock methods one after the other, but using threads gives us some bonus features. For example, we might want to open the padlock, get half way through, and then realise we want to pause, leaving the rest of the work for later. Or maybe we want to get halfway through closing the padlock, and then change our mind and open it (i.e. without fully closing it)

So heres the code, enjoy!
The padlock:

package workingWithSynchronizedThreads;
 
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * This class represents a simple padlock. You know, like the kind you use to
 * lock up your bike. I use it as an example of how we can make fields in
 * java , then try and access them through different threads. Using syncronised
 * methods, we will prevent the lock from being opened whilst were still trying
 * to close it.
 * @author anton
 */
public class padlock {
 
    /**
     * Constructor object to make a new padlock
     * @param isThePadlockOpen Whether the padlock is open or closed
     */
    public padlock(boolean isThePadlockOpen) {
        this.isThePadlockOpen = isThePadlockOpen;
    }
    /**
     * This field tells us whether or not the lock is open or closed (true for
     * open, false for locked)
     */
    public boolean isThePadlockOpen;
 
    /**
     * This method simply sets the padlock to be closed by setting isOpen to false
     * Closing the lock takes two seconds (hence the sleep statements) ).
     */
    public synchronized void closeLock() {
        try {
            Thread.sleep(1000);
            isThePadlockOpen = false;
            System.out.println("I'm closing the lock");
            Thread.sleep(1000);
            tellMeIfThisLockIsOpen();
        } catch (InterruptedException ex) {
            System.out.println("I couldn't close the lock");
            Logger.getLogger(padlock.class.getName()).log(Level.SEVERE, null, ex);
        }
 
    }
 
    /**
     * This method simply sets the padlock to be open by setting isOpen to true.
     * Opening a lock takes two seconds (hence the sleep statements ).
     */
    public synchronized void openLock() {
        try {
            Thread.sleep(1000);
            isThePadlockOpen = true;
            System.out.println("I'm opening the lock");
            Thread.sleep(1000);
            tellMeIfThisLockIsOpen();
        } catch (InterruptedException ex) {
            System.out.println("I couldn't open the lock");
            Logger.getLogger(padlock.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
 
    /**
     * Lets us know if our padlock object is open or closed
     */
    public void tellMeIfThisLockIsOpen() {
        if (isThePadlockOpen == true) {
            System.out.println("The lock is open!");
        } else if (isThePadlockOpen == false) {
            System.out.println("The lock is closed!");
        } else {
            System.out.println("Something is seriously wrong!");
        }
    }
}

The closeLockThread:

package workingWithSynchronizedThreads;
 
/**
 *
 * @author anton
 */
public class closeLockThread extends Thread {
 
    public padlock padlock;
 
    public closeLockThread(Object padlock) {
        this.padlock = (padlock) padlock;
    }
 
    @Override
    public void run() {
        padlock.closeLock();
    }
}

The openLockThread:

package workingWithSynchronizedThreads;
 
/**
 *
 * @author anton
 */
public class openLockThread extends Thread {
 
    public padlock padlock;
 
    public openLockThread(Object padlock) {
        this.padlock = (padlock) padlock;
    }
 
    @Override
    public void run() {
        padlock.openLock();
 
    }
}

Okay, less mess with some threads!!!:

package workingWithSynchronizedThreads;
 
/**
 *
 * @author anton
 */
public class messAroundWithSomePadlocks {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        padlock myLock = new padlock(true);
        closeLockThread iWannaCloseTheLock = new closeLockThread(myLock);
        openLockThread iWannaOpenTheLock = new openLockThread(myLock);
        iWannaCloseTheLock.start();
        iWannaOpenTheLock.start();
    }
}

The things that need attention are:

Do we need to do that casting from padlock to padlock in the openLock and closeLock thread classes?
Is it ok/understandable to make a field a question? (public boolean isThePadlockOpen;) ?

The inspiration for this work came from looking at some code were working on in my department, but the learning was really done looking at the Java Tutorials, which are ace!

Tags: java, synchronized methods, threads

This entry was posted on Saturday, October 4th, 2008 at 9:14 pm and is filed under computing. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.

2 Responses to “Using synchronized methods in java”

Lamsey says:

October 5, 2008 at 7:19 am

Class names should start with a capital letter, thus differentiating them from variables/fields, which start with small letters. This should fix the problem you have with:

this.padlock = (padlock) padlock;

The above is confusing because ‘padlock’ could refer to the class or the variable.

Generally, boolean field names should be a statement, like ‘padlockIsOpen’. This is so they make sense when you use them in an if statement:

if (padlockIsOpen) { stealBike(); }

HTH!
Anton Parol says:

October 5, 2008 at 3:23 pm

Thats very helpful Liam! Thanks!
The following changes were made:

1. Made all classes begin with a capital letter. Like you say, nowits obvious whats a field and whats a class!
2. Changed the constructors for the threads, they now look like:
public OpenLockThread(Padlock padlock) {
this.padlock = padlock;
}
There was a small issue with casting still, because I was saying:
public OpenLockThread(Object padlock) {
this.padlock = padlock;
}
But once I told it it should expect a Padlock and not an object, no casting was needed!
3. That boolean field was changed, and it makes the code nice and easy to read.
I have to say, I really enjoy when code reads like normal English prose, its so much easier to understand!!!

Parolski.com

Using synchronized methods in java

2 Responses to “Using synchronized methods in java”

Leave a Reply