In Computer Science, synchronization refers to relationships among events. For example:

• Serialization: Event A must happen before Event B.
• Mutual Exclusion: Event A and Event B must not happen at the same time.

Java’s support for synchronization is based on implicit locks by the use of synchronized keyword. Every object has an intrinsic lock associated with it. When a thread invokes a synchronized non-static method, it acquires the intrinsic lock for that method’s object. The lock is returned when the method returns (even due to an uncaught exception). Similarly, every class has an intrinsic lock associated with it. A thread acquires this class lock to invoke a synchronized static method and releases when the method returns. These locks are acquired and released automatically.

In addition to intrinsic locks, each instance also has a wait set associated with it. When a thread invokes wait() (or any overloaded wait(...) methods) it is placed in this wait set. The wait(...) methods must be called from a synchronized block. This is used in scenarios like when a thread obtains the lock but is not ready to proceed code in the critical section.

Implicit locks demo

I will demonstrate implicit locks by implementing a solution to producer-consumer problem. Source code is attached as a link at the end of the article. The producer-consumer problem can be described as follows. There are M threads producing items and N threads consuming items. They share a common buffer for transfering these items. The problem is to make sure that producers won’t add items when the buffer is full and consumers won’t remove items from an empty buffer. In ImplicitLocksDemo class I have 3 nested classes – Producer, Consumer and Drop (shared buffer). Producer and Consumer are implemented as threads. Producer creates a String object and places in the drop object which is shared between producers and consumers as shown below:

22
23
24
25
26
27
28
29
30
31
32
33

	public static void main(String s[]) {
		Drop drop = new Drop();
		Consumer c1 = new Consumer("C1", drop);
		Producer p1 = new Producer("P1", drop);
		Consumer c2 = new Consumer("C2", drop);
		Producer p2 = new Producer("P2", drop);
 
		new Thread(p1).start();
		new Thread(c1).start();
		new Thread(p2).start();
		new Thread(c2).start();
	}

To make the problem a bit more complicated, the shared buffer is made to hold only one item. The Drop class has one member variable (shared) which will be set by a producer. Additionally, the Drop class has a variable called empty which tells if the buffer is full or empty. Producers can only set shared with an item when empty is true. Similarly, consumers can only read shared when empty is false. The Drop class has two methods called get() which the consumers call to read an item and a method called set(String) which is called by producers to set an item. Both get() and set() are made synchronized so only one thread can invoke get() or set() method at any time.

Now, what if a producer acquired a lock and wants to invoke set() method and the buffer is not empty? If a consumer had not read the item produced previously, the producer would be overwriting the item. To use the locks effectively, we use wait/notify mechanism provided by Java. wait() and notify are methods defined in Object class, hence, they are available to any class. Invoking wait() makes the current thread go into a waiting state or into the wait set associated with the object on which wait() was invoked. When a consumer reads the item it invokes notify() on drop object which sends a signal to all threads waiting in the wait set of drop object. That is to say that the shared object is now empty and a producer can safely fill the shared storage. So with the help of wait/notify, threads can effectively communicate with each other and share the critical sections in a safe manner. Complete solution is given below.

/**
 * @(#)ImplicitLocksDemo.java	Feb 26, 2008
 */
package lock;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
/**
 * Demonstrates Producer and Consumer with a
 * 
 * @author $Author: vijaykandy $
 * @version $Revision: 1.4 $
 */
public class ImplicitLocksDemo {
	/**
	 * Main.
	 * 
	 * @param s
	 */
	public static void main(String s[]) {
		Drop drop = new Drop();
		Consumer c1 = new Consumer("C1", drop);
		Producer p1 = new Producer("P1", drop);
		Consumer c2 = new Consumer("C2", drop);
		Producer p2 = new Producer("P2", drop);
 
		new Thread(p1).start();
		new Thread(c1).start();
		new Thread(p2).start();
		new Thread(c2).start();
	}
 
	/**
	 * Shared class
	 * 
	 * @author $Author: vijaykandy $
	 * @version $Revision: 1.4 $
	 */
	static class Drop {
		private String shared;
 
		private boolean empty = true;
 
		/**
		 * Takes a message when a signal is received.
		 * 
		 * @return
		 */
		public synchronized String get() {
			while (empty) {
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			String message = shared;
			empty = true;
			this.notifyAll();
			return message;
		}
 
		/**
		 * Sets a message when a signal is received.
		 * 
		 * @param s
		 */
		public synchronized void set(String s) {
			while (!empty) {
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			shared = s;
			empty = false;
			this.notifyAll();
		}
	}
 
	/**
	 * Produces a message
	 * 
	 * @author $Author: vijaykandy $
	 * @version $Revision: 1.4 $
	 */
	static class Producer implements Runnable {
 
		private String name;
 
		private Drop drop;
 
		private Random random = new Random();;
 
		private List<String> messages = new ArrayList<String>() {
			{
				add(Integer.toHexString(random.nextInt(1000)));
				add(Integer.toHexString(random.nextInt(1000)));
				add(Integer.toHexString(random.nextInt(1000)));
				add("DONE");
			}
		};
 
		public Producer(String name, Drop drop) {
			this.name = name;
			this.drop = drop;
		}
 
		public void run() {
			Random random = new Random();
			for (String msg : messages) {
				drop.set(msg);
				System.out.format("%s produced: %s%n", name, msg);
				try {
					Thread.sleep(random.nextInt(1000));
				} catch (InterruptedException e) {
				}
			}
		}
	}
 
	/**
	 * Consumes a message
	 * 
	 * @author $Author: vijaykandy $
	 * @version $Revision: 1.4 $
	 */
	static class Consumer implements Runnable {
 
		private String name;
 
		private Drop drop;
 
		public Consumer(String name, Drop drop) {
			this.name = name;
			this.drop = drop;
		}
 
		public void run() {
			Random random = new Random();
			while (true) {
				String message = drop.get();
				System.out.format("%s received: %s%n", name, message);
 
				if (message.equals("DONE")) {
					return;
				}
 
				try {
					Thread.sleep(random.nextInt(1000));
				} catch (InterruptedException e) {
				}
			}
		}
	}

The synchronized keyword can also be used with a block. In this case, threads are required to acquire the lock associated with the object in the synchronized statement as shown here:.

public void m() {
	Object anObject = ...
	// ...
	synchronized(anObject) { // threads must acquire anObject's lock
	}
	// ...
}

Finding the maximum or longest increasing subsequence (LIS) within a given a set of numbers is a classic Computer Science problem. The algorithm is central to many tools and is used in various disciplines related to mathematics, physics etc. In the field of Bioinformatics, LIS is used to find DNA subsequences matching a certain criteria. By recognizing certain patterns in DNA sequences scientists can determine diseases, genetic disorders etc.

Problem

Given a sequence of N integers, find the longest strictly increasing subsequence. For example in the sequence 56, 21, 33, 22, 34, 78, 11, 35, 46, the longest increasing subsequence is 21, 33, 34, 35, 46. In this context we will consider a NXN matrix of integers and find a sequence which is simply a series of adjacent squares. A square may not be used more than once. In the following 10 X 10 grid:

  | 0  1  2  3  4  5  6  7  8  9
--+------------------------------
0 | 95 47 30 36 60 31 57 66 12 55
1 | 35 57 41 13 82 80 71 93 31 62
2 | 89 36 98 75 91 24 95 53 37 99
3 | 25 45 26 17 15 84 80 73 96 21
4 | 75 22 43 96 96 36 64 31 45 86
5 | 45 99 68 74 54 14 93 17 14 55
6 | 14 42 52 54 34 50 22 84 32 41
7 | 90 44 73 10 71 84 20 12 55 52
8 | 95 33 25 31 76 45 44 84 90 52
9 | 94 64 95 24 41 63 87 93 79 12

the longest increasing subsequence is of length 8 consisting of entries 24, 25, 33, 44, 52, 68, 74, 96 as highlighted in red.

Solution

Each number and its position in the sequence are stored in an array. In the first pass, neighbors for each item in the array are found and are stored along with the item. Items are then sorted by their descending value. In the second and final pass, weights are assigned to the neighbors. The neighbor with the least value is assigned weight 1, the next highest neighbor is assigned 2 and so on. To get the longest increasing subsequence, find the element with the highest weight and print its neighbors in the descending order of weights.

Unzip the attachment and cd into the newly created folder. Compile the classes run as follows:

C:\MaximumIncreasingSubsequence>javac -d bin src\*.java
 
C:\MaximumIncreasingSubsequence>java -classpath bin MaximumIncreasingSubsequence small-grid.txt
(24, 0) with value 129 (weight = 15)
(24, 1) with value 138 (weight = 14)
(25, 2) with value 167 (weight = 13)
(25, 3) with value 236 (weight = 12)
(25, 4) with value 300 (weight = 11)
(26, 4) with value 338 (weight = 10)
(27, 5) with value 438 (weight = 9)
(28, 4) with value 469 (weight = 8)
(27, 4) with value 596 (weight = 7)
(27, 3) with value 709 (weight = 6)
(26, 2) with value 723 (weight = 5)
(27, 1) with value 778 (weight = 4)
(28, 1) with value 866 (weight = 3)
(27, 0) with value 939 (weight = 2)
(26, 0) with value 953 (weight = 1)
Program took: 380 milliseconds

Attachments

Source code

Boggle is a word game designed by Allan Turoff. The objective of the game is to construct as many different words as you can from a grid of letters. You can use letters (in positions) that are next to each other – above, below, left, right, diagonal but you can not use the same letter more than once. Each word must be defined in a dictionary. Points are assigned according to the length of the word.

The source code attached here is an implementation of this game in Java. It demonstrates recursion to solve problems like this game. The program attempts to construct words as defined in dic.txt from puzzle.txt. Points are assigned according to the length of the word.

Instructions

To run this program you need JDK 5 or better installed. You can get JDK from here.

1. Unzip the file. This creates a folder called Boggle
2. Compile the code: javac src\*.java -d bin
3. Run the program: java -classpath bin Boggle

C:\Boggle>javac src\*.java  -d bin
 
C:\Boggle>java -classpath bin Boggle
Enter boggle file:
puzzle.txt
Opened puzzle.txt
Enter dictionary name:
dic.txt
Opened dic.txt
Reading files...
Solving...
Word            | Points | Path
----------------+--------+-----------------------
            APR |      1 | [(0,0), (0,1), (0,2)]
      APRTOCFED |     15 | [(0,0), (0,1), (0,2), (1,2), (1,1), (1,0), (2,0), (2,1), (2,2)]
            COT |      1 | [(1,0), (1,1), (1,2)]
            FED |      1 | [(2,0), (2,1), (2,2)]

Attachments

Source code