Archive for category Miscellaneous

Spring Framework: load resources sorted by filename

Sometimes it is necessary to load classpath-resources for working with them (e. g. loading data). In this case, the additional requirement was to provide the resources in a sorted way. The implementation is done with the ResourcePatternResolver from Spring Framework.

Custom resource comparator for sorting the resources:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import org.springframework.core.io.Resource;
import org.springframework.util.StringUtils;
import java.util.Comparator;
 
public class ResourceComparator implements Comparator<Resource> {
    @Override
    public int compare(Resource r1, Resource r2) {
        if (r1 == null || r2 == null
                || StringUtils.isEmpty(r1.getFilename()) || StringUtils.isEmpty(r2.getFilename()) ) {
            return 0;
        }
 
        final char v1[] = r1.getFilename().toCharArray();
        final char v2[] = r2.getFilename().toCharArray();
 
        int len1 = v1.length;
        int len2 = v2.length;
        int lim = Math.min(len1, len2);
 
        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }
}

The class loading the resources and providing them in a sorted way:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import java.util.Arrays;
 
public class ResourceLoader {
	private static final String PATTERN = "resource*.xml";
 
	public void loadResources() {
		ClassLoader cl = this.getClass().getClassLoader();
		ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(cl);
		Resource[] resources = resolver.getResources("classpath*:" + PATTERN);
		Arrays.sort(resources, new ResourceComparator());
 
		for (Resource resource : resources) {
			//process the resources
		}
	}
}

No Comments

High CPU load: finding the responsible Java thread in Linux/Unix

If a running Java application on a machine generates (too) much CPU load it is often necessary to identify the Java thread which is responsible for this behaviour. On a Linux or Unix environment this can easily be done by using a shell:

Finding the problematic Java process

The “top”-command which shows tasks sorted by load intensity is available on nearly all installations:

$ top

Analysing the given table it is quite simple to find out the PID (process id) of the Java process that causes the problem.
Another way is to use the “ps” command to identify the process:

$ ps axu | grep java

Creating a thread dump

Next step is to create a thread dump using the command “jstack”. This command is part of the JDK, so it is normally available per default. “jstack” needs the PID of the Java process given as parameter. If “jstack” hangs or does not respond it has to be forced to take the dump using the “-F” parameter. It is also a good idea write its output into a file, an example with PID=12345 that writes a file into “/tmp” directory:

$ jstack -F 12345 > /tmp/heapdump

Identifying the problematic Java thread(s)

The “top” command is also able to display all threads of a task by pressing “H” when started or using the “-H” parameter:

$ top -H

So this time the PID(s) of problematic thread(s) can also be found out.

Now it is possible to find information about the thread(s) causing the problem by searching the heapdump file for these PIDs, assuming a PID is 32145:

-in a dump created with Java 7 and newer a PID can be found directly, for example:
Thread 32145: (state = IN_NATIVE)

-in a dump created with Java 6 and earlier it is necessary to convert the PID to a HEX value, also using BASH for example:

$ printf '%x\n' 32145

The result for this example is “7d91” and can be found in heapdump file as an “nid”, for example:
“Thread-0” prio=10 tid=0x00002f6a98760000 nid=0x7d91 runnable [0x00001f9a4d123000]

,

No Comments

Design Patterns: Singleton in Java

A singleton is a design pattern that should restrict instantiation of a class to one single object. Normally a singleton contains a static getInstance() method that returns this instance.

The classic version of a singleton: lazy initialization

The modifier private of the standard constructor prevents instantiation from outside the class here. The getInstance() method creates the static instance on its first call:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class SingletonClassic {
  private static SingletonClassic instance = null;
 
  private SingletonClassic() {
  }
 
  public static SingletonClassic getInstance() {
    if (instance == null) {
      instance = new SingletonClassic();
    }
    return instance;
  }
}

This version of a singleton can lead to problems on multithreading-environments if getInstance() is called by two (or more) threads simultaneously at the time the static instance is not already there. In this case it is possible that two different instances are being created and returned. A simple solution would be to add the synchronized modifier to the getInstance() method:

1
2
3
4
5
6
7
8
[...]
  public static synchronized SingletonClassic getInstance() {
    if (instance == null) {
      instance = new SingletonClassic();
    }
    return instance;
  }
[...]

But this solution is not really nice because getInstance() only has to be synchronized at the time creating its instance. The cost of synchronized parts on multithreading-environments can be much higher (threads waiting for other threads to release the lock), so often these parts are slower executed.

Singleton using double-checked locking idiom

To solve the problem from above, it is possible to implement a singleton using the double-checked locking idiom that should restrict the part which has to run synchronized. This will only work with Java 5 and newer versions (change of volatile modifier, explained here).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SingletonDoubleCheckedLocking {
  private static volatile SingletonDoubleCheckedLocking instance = null;
 
  private SingletonDoubleCheckedLocking() {
  }
 
  public static SingletonDoubleCheckedLocking getInstance() {
    if (instance == null) {
      synchronized (SingletonDoubleCheckedLocking.class) {
        if (instance == null) {
          instance = new SingletonDoubleCheckedLocking();
        }
      }
    }
    return instance;
  }
}

Singleton with eager initialization

If creating an instance inside the singleton class is always needed, this is a solution that easily gets around the synchronizing-problems. The instance is created when the class is used. The final modifier ensures that it is not replaced or redefined.

1
2
3
4
5
6
7
8
9
10
public class SingletonEagerInit {
  private static final SingletonEagerInit INSTANCE = new SingletonEagerInit();
 
  private SingletonEagerInit() {
  }
 
  public static SingletonEagerInit getInstance() {
    return INSTANCE;
  }
}

Singleton using initialization-on-demand holder idiom

If it is a problem that the instance is automatically created at the time the class is being accessed like in the example above (perhaps in case of high cost or huge amount of resources necessary), here is the solution:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class SingletonWithHolder {
 
  private static class LazyHolder {
    private static final SingletonWithHolder INSTANCE = new SingletonWithHolder();
  }
 
  private SingletonWithHolder() {
  }
 
  public static SingletonWithHolder getInstance() {
    return LazyHolder.INSTANCE;
  }
}

This solution is as lazy as possible, creating the instance only if getInstance() is called.

Singleton using enum

Probably the most recommended version of implementing a singleton using a Java version that supports it is using enums.

1
2
3
4
5
6
7
public enum Singleton {
  INSTANCE;
 
  public void execute() {
    [...]
  }
}

The singleton can be used like this:

Singleton.INSTANCE.execute();

,

No Comments

Uptime image

With PHP, creating dynamic images is easy. For example combined with some shell commands, it is possible to generate a dynamic image which displays server uptime and some kernel infos:

Uptime image

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
  header("Content-type: image/png");
  $image = imagecreatefrompng("uptime.linux.png");
  $font_size = 7.5;
  $color = imagecolorallocate($image, 255, 255, 255);
 
  $uptime = exec("/bin/cat /proc/uptime | /usr/bin/cut -f 1 -d ' '");
  $days = (int) ($uptime / 86400);
  $uptime -= $days * 86400;
  $hours = (int) ($uptime / 3600);
  $uptime -= $hours * 3600;
  $minutes = (int) ($uptime / 60);
 
  $act_dir = getcwd();
  ImageTTFText($image, $font_size, 0, 55, 15, $color, $act_dir."/Tahoma.ttf", "http://www.dresselhaus.biz");
  ImageTTFText($image, $font_size, 0, 55, 34, $color, $act_dir."/Tahoma.ttf", "Host: ".exec("hostname -f"));
  ImageTTFText($image, $font_size, 0, 55, 45, $color, $act_dir."/Tahoma.ttf", "Uptime: ".$days. "d ".$hours."h ".$minutes."m");
  ImageTTFText($image, $font_size, 0, 55, 56, $color, $act_dir."/Tahoma.ttf", "System: ".exec("uname")." (".exec("uname -m").")");
  ImageTTFText($image, $font_size, 0, 55, 67, $color, $act_dir."/Tahoma.ttf", "Kernel: ".exec("uname -r"));
  imagepng($image);
  imagedestroy($image);
?>

,

No Comments

Hello world!

Just set up WordPress, so this site is still under construction. Please come back later! 🙂

No Comments