CODEWITHSUNDEEP
javaperformancenetwork-programmingprofilingnetty
Matthias
Matthias

Reputation: 10379

Java: Faster alternative to String(byte[])

I am developing a Java-based downloader for binary data. This data is transferred via a text-based protocol (UU-encoded). For the networking task the netty library is used. The binary data is split by the server into many thousands of small packets and sent to the client (i.e. the Java application).

From netty I receive a ChannelBuffer object every time a new message (data) is received. Now I need to process that data, beside other tasks I need to check the header of the package coming from the server (like the HTTP status line). To do so I call ChannelBuffer.array() to receive a byte[] array. This array I can then convert into a string via new String(byte[]) and easily check (e.g. compare) its content (again, like comparison to the "200" status message in HTTP).

The software I am writing is using multiple threads/connections, so that I receive multiple packets from netty in parallel.

This usually works fine, however, while profiling the application I noticed that when the connection to the server is good and data comes in very fast, then this conversion to the String object seems to be a bottleneck. The CPU usage is close to 100% in such cases, and according to the profiler very much time is spent in calling this String(byte[]) constructor.

I searched for a better way to get from the ChannelBuffer to a String, and noticed the former also has a toString() method. However, that method is even slower than the String(byte[]) constructor.

So my question is: Does anyone of you know a better alternative to achieve what I am doing?

Upvotes: 15

Views: 10199

Answers (3)

Eric Grunzke
Eric Grunzke

Reputation: 1657

Perhaps you could skip the String conversion entirely? You could have constants holding byte arrays for your comparison values and check array-to-array instead of String-to-String.

Here's some quick code to illustrate. Currently you're doing something like this:

String http200 = "200";
// byte[] -> String conversion happens every time
String input = new String(ChannelBuffer.array());
return input.equals(http200);

Maybe this is faster:

// Ideally only convert String->byte[] once.  Store these
// arrays somewhere and look them up instead of recalculating.
final byte[] http200 = "200".getBytes("UTF-8"); // Select the correct charset!
// Input doesn't have to be converted!
byte[] input = ChannelBuffer.array();
return Arrays.equals(input, http200);

Upvotes: 16

Paul Wagland
Paul Wagland

Reputation: 29116

Depending on what you are trying to do there are a few options:

  1. If you are just trying to get the response status to then can't you just call getStatus()? This would probably be faster than getting the string out.
  2. If you are trying to convert the buffer, then, assuming you know it will be ASCII, which it sounds like you do, then just leave the data as byte[] and convert your UUDecode method to work on a byte[] instead of a String.

The biggest cost of the string conversion is most likely the copying of the data from the byte array to the internal char array of the String, this combined with the conversion is most likely just a bunch of work that you don't need to do.

Upvotes: 0

Lee Meador
Lee Meador

Reputation: 12985

Some of the checking you are doing might just look at part of the buffer. If you could use the alternate form of the String constructor:

new String(byteArray, startCol, length)

That might mean a lot less bytes get converted to a string.

Your example of looking for "200" within the message would be an example.

2

You might find that you can use the length of the byte array as a clue. If some messages are long and you are looking for a short one, ignore the long ones and don't convert to characters. Or something like that.

3

Along with what @EricGrunzke said, partially looking in the byte buffer to filter out some messages and find that you don't need to convert them from bytes to characters.

4

If your bytes are ASCII characters, the conversion to characters might be quicker if you use charset "ASCII" instead of whatever the default is for your server:

new String(bytes, "ASCII")

might be faster in that case.

In fact, you might be able to pick and choose the charset for conversion byte-character in some organized fashion that speeds up things.

Upvotes: 2

Related Questions