diff --git a/user/src/com/google/gwt/user/server/rpc/HybridServiceServlet.java b/user/src/com/google/gwt/user/server/rpc/HybridServiceServlet.java
index 9d7c619..16fbe7a 100644
--- a/user/src/com/google/gwt/user/server/rpc/HybridServiceServlet.java
+++ b/user/src/com/google/gwt/user/server/rpc/HybridServiceServlet.java
@@ -114,7 +114,7 @@
       onAfterResponseSerialized(toReturn);
 
       try {
-        stream.write(toReturn.getBytes("UTF-8"));
+        stream.write(toReturn.getBytes(RPCServletUtils.CHARSET_UTF8));
       } catch (IOException e) {
         throw new SerializationException("Unable to commit bytes", e);
       }
diff --git a/user/src/com/google/gwt/user/server/rpc/RPCServletUtils.java b/user/src/com/google/gwt/user/server/rpc/RPCServletUtils.java
index 05bf40d..d9d2178 100644
--- a/user/src/com/google/gwt/user/server/rpc/RPCServletUtils.java
+++ b/user/src/com/google/gwt/user/server/rpc/RPCServletUtils.java
@@ -1,12 +1,12 @@
 /*
  * Copyright 2008 Google Inc.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
@@ -19,6 +19,8 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.Method;
+import java.nio.charset.Charset;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.zip.GZIPOutputStream;
 
 import javax.servlet.ServletContext;
@@ -31,6 +33,16 @@
  * the RPC system.
  */
 public class RPCServletUtils {
+  
+  public static final String CHARSET_UTF8_NAME = "UTF-8";
+  
+  /**
+   * The UTF-8 Charset. Use this to avoid concurrency bottlenecks when
+   * converting between byte arrays and Strings.
+   * See http://code.google.com/p/google-web-toolkit/issues/detail?id=6398
+   */
+  public static final Charset CHARSET_UTF8 = Charset.forName(CHARSET_UTF8_NAME);
+
   /**
    * Package protected for use in tests.
    */
@@ -40,11 +52,6 @@
 
   private static final String ATTACHMENT = "attachment";
 
-  /**
-   * Used both as expected request charset and encoded response charset.
-   */
-  private static final String CHARSET_UTF8 = "UTF-8";
-
   private static final String CONTENT_DISPOSITION = "Content-Disposition";
 
   private static final String CONTENT_ENCODING = "Content-Encoding";
@@ -64,10 +71,24 @@
   private static final int UNCOMPRESSED_BYTE_SIZE_LIMIT = 256;
 
   /**
+   * Contains cached mappings from character set name to Charset. The
+   * null key maps to the default UTF-8 character set.
+   */
+  private static final ConcurrentHashMap<String, Charset> CHARSET_CACHE =
+      new ConcurrentHashMap<String, Charset>();
+
+  /**
+   * Pre-populate the character set cache with UTF-8.
+   */
+  static {
+    CHARSET_CACHE.put(CHARSET_UTF8_NAME, CHARSET_UTF8);
+  }
+
+  /**
    * Returns <code>true</code> if the {@link HttpServletRequest} accepts Gzip
    * encoding. This is done by checking that the accept-encoding header
    * specifies gzip as a supported encoding.
-   * 
+   *
    * @param request the request instance to test for gzip encoding acceptance
    * @return <code>true</code> if the {@link HttpServletRequest} accepts Gzip
    *         encoding
@@ -86,7 +107,7 @@
   /**
    * Returns <code>true</code> if the response content's estimated UTF-8 byte
    * length exceeds 256 bytes.
-   * 
+   *
    * @param content the contents of the response
    * @return <code>true</code> if the response content's estimated UTF-8 byte
    *         length exceeds 256 bytes
@@ -96,12 +117,38 @@
   }
 
   /**
+   * Get the Charset for a named character set. Caches Charsets to work around
+   * a concurrency bottleneck in FastCharsetProvider.
+   * See http://code.google.com/p/google-web-toolkit/issues/detail?id=6398
+   * @see {@link Charset#forName(String)}
+   *
+   * @param encoding the name of the Charset to get. If this is null
+   *                 the default UTF-8 character set will be returned.
+   * @return the named Charset.
+   */
+  public static Charset getCharset(String encoding) {
+        
+    if (encoding == null) {
+      return CHARSET_UTF8;
+    }
+    
+    Charset charset = CHARSET_CACHE.get(encoding);
+
+    if (charset == null) {
+      charset = Charset.forName(encoding);
+      CHARSET_CACHE.put(encoding, charset);
+    }
+
+    return charset;
+  }
+
+  /**
    * Returns true if the {@link java.lang.reflect.Method Method} definition on
    * the service is specified to throw the exception contained in the
    * InvocationTargetException or false otherwise. NOTE we do not check that the
    * type is serializable here. We assume that it must be otherwise the
    * application would never have been allowed to run.
-   * 
+   *
    * @param serviceIntfMethod the method from the RPC request
    * @param cause the exception that the method threw
    * @return true if the exception's type is in the method's signature
@@ -135,7 +182,7 @@
    * Returns the content of an {@link HttpServletRequest} by decoding it using
    * <code>expectedCharSet</code>, or <code>UTF-8</code> if
    * <code>expectedCharSet</code> is <code>null</null>.
-   * 
+   *
    * @param request the servlet request whose content we want to read
    * @param expectedContentType the expected content (i.e. 'type/subtype' only)
    *          in the Content-Type request header, or <code>null</code> if no
@@ -178,20 +225,18 @@
         }
         out.write(buffer, 0, byteCount);
       }
-      String contentCharSet = expectedCharSet != null
-          ? expectedCharSet : CHARSET_UTF8;
-      return out.toString(contentCharSet);
+      return new String(out.toByteArray(), getCharset(expectedCharSet));
     } finally {
       if (in != null) {
         in.close();
       }
     }
   }
-  
+
   /**
    * Returns the content of an {@link HttpServletRequest}, after verifying a
    * <code>gwt/x-gwt-rpc; charset=utf-8</code> content type.
-   * 
+   *
    * @param request the servlet request whose content we want to read
    * @return the content of an {@link HttpServletRequest} by decoding it using
    *         <code>UTF-8</code>
@@ -202,13 +247,13 @@
    */
   public static String readContentAsGwtRpc(HttpServletRequest request)
       throws IOException, ServletException {
-      return readContent(request, GWT_RPC_CONTENT_TYPE, CHARSET_UTF8);
+      return readContent(request, GWT_RPC_CONTENT_TYPE, CHARSET_UTF8_NAME);
   }
 
  /**
    * Returns the content of an {@link HttpServletRequest} by decoding it using
    * the UTF-8 charset.
-   * 
+   *
    * @param request the servlet request whose content we want to read
    * @return the content of an {@link HttpServletRequest} by decoding it using
    *         the UTF-8 charset
@@ -228,7 +273,7 @@
   /**
    * Returns the content of an {@link HttpServletRequest} by decoding it using
    * the UTF-8 charset.
-   * 
+   *
    * @param request the servlet request whose content we want to read
    * @param checkHeaders Specify 'true' to check the Content-Type header to see
    *          that it matches the expected value 'text/x-gwt-rpc' and the
@@ -246,7 +291,7 @@
   @Deprecated
   public static String readContentAsUtf8(HttpServletRequest request,
       boolean checkHeaders) throws IOException, ServletException {
-    return readContent(request, GWT_RPC_CONTENT_TYPE, CHARSET_UTF8);
+    return readContent(request, GWT_RPC_CONTENT_TYPE, CHARSET_UTF8_NAME);
   }
 
   /**
@@ -259,7 +304,7 @@
   /**
    * Returns <code>true</code> if the request accepts gzip encoding and the the
    * response content's estimated UTF-8 byte length exceeds 256 bytes.
-   * 
+   *
    * @param request the request associated with the response content
    * @param responseContent a string that will be
    * @return <code>true</code> if the request accepts gzip encoding and the the
@@ -275,7 +320,7 @@
    * Write the response content into the {@link HttpServletResponse}. If
    * <code>gzipResponse</code> is <code>true</code>, the response content will
    * be gzipped prior to being written into the response.
-   * 
+   *
    * @param servletContext servlet context for this response
    * @param response response instance
    * @param responseContent a string containing the response content
@@ -333,7 +378,7 @@
   /**
    * Called when the servlet itself has a problem, rather than the invoked
    * third-party method. It writes a simple 500 message back to the client.
-   * 
+   *
    * @param servletContext
    * @param response
    * @param failure
@@ -349,7 +394,7 @@
       response.setContentType("text/plain");
       response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
       try {
-        response.getOutputStream().write(GENERIC_FAILURE_MSG.getBytes("UTF-8"));
+        response.getOutputStream().write(GENERIC_FAILURE_MSG.getBytes(CHARSET_UTF8));
       } catch (IllegalStateException e) {
         // Handle the (unexpected) case where getWriter() was previously used
         response.getWriter().write(GENERIC_FAILURE_MSG);
@@ -363,7 +408,7 @@
 
   /**
    * Performs validation of the character encoding, ignoring case.
-   * 
+   *
    * @param request the incoming request
    * @param expectedCharSet the expected charset of the request
    * @throws ServletException if requests encoding is not <code>null</code> and
@@ -372,6 +417,8 @@
   private static void checkCharacterEncodingIgnoreCase(
       HttpServletRequest request, String expectedCharSet)
       throws ServletException {
+    
+    assert (expectedCharSet != null);
     boolean encodingOkay = false;
     String characterEncoding = request.getCharacterEncoding();
     if (characterEncoding != null) {
@@ -409,6 +456,8 @@
   private static void checkContentTypeIgnoreCase(
       HttpServletRequest request, String expectedContentType)
       throws ServletException {
+    
+    assert (expectedContentType != null);
     String contentType = request.getContentType();
     boolean contentTypeIsOkay = false;
 
diff --git a/user/src/com/google/gwt/user/server/rpc/impl/SerializabilityUtil.java b/user/src/com/google/gwt/user/server/rpc/impl/SerializabilityUtil.java
index 3b81cc9..7aa02db 100644
--- a/user/src/com/google/gwt/user/server/rpc/impl/SerializabilityUtil.java
+++ b/user/src/com/google/gwt/user/server/rpc/impl/SerializabilityUtil.java
@@ -1,12 +1,12 @@
 /*
  * Copyright 2008 Google Inc.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
@@ -21,6 +21,7 @@
 import com.google.gwt.user.client.rpc.SerializationException;
 import com.google.gwt.user.client.rpc.SerializationStreamReader;
 import com.google.gwt.user.client.rpc.SerializationStreamWriter;
+import com.google.gwt.user.server.rpc.RPCServletUtils;
 import com.google.gwt.user.server.rpc.SerializationPolicy;
 import com.google.gwt.user.server.rpc.ServerCustomFieldSerializer;
 
@@ -47,9 +48,6 @@
  * Serialization utility class used by the server-side RPC code.
  */
 public class SerializabilityUtil {
-
-  public static final String DEFAULT_ENCODING = "UTF-8";
-
   /**
    * Comparator used to sort fields.
    */
@@ -222,7 +220,7 @@
 
   /**
    * Return the concrete type that a generic type maps to, if known.
-   * 
+   *
    * @param genericType The generic type to resolve.
    * @param resolvedTypes A map of generic types to actual types.
    * @return The actual type, which may be of any subclass of Type.
@@ -244,11 +242,11 @@
 
   /**
    * Determine the expected types for any instance type parameters.
-   * 
+   *
    * This method also determines whether or not the instance can be assigned to
    * the expected type. We combine the tasks because they require traversing the
    * same data structures.
-   * 
+   *
    * @param instanceClass The instance for which we want generic parameter types
    * @param expectedType The type we are expecting this instance to be
    * @param resolvedTypes The types that have been resolved to actual values
@@ -269,14 +267,14 @@
       if (resolvedTypes != null) {
         findInstanceParameters(instanceClass, resolvedTypes, expectedParameterTypes);
       }
-      
+
       // With no expected type, the instance is assignable and we fall through
     } else {
       // First determine what type we are really expecting. The type may still
       // be a TypeVariable<?> at this time when we are deserializing class
       // fields or components of another data structure.
       Type actualType = findActualType(expectedType, resolvedTypes);
-      
+
       // Try to match the instanceClass to the expected type, updating the
       // expectedParameterTypes so that we can track them back to the resolved
       // types once we determine what class to treat the instance as. In
@@ -294,7 +292,7 @@
         // and we are done.
         return null;
       }
-      
+
       // Now that we know what class the instance should be,
       // get any remaining parameters using resolved types.
       if (resolvedTypes != null) {
@@ -309,7 +307,7 @@
 
   /**
    * Find the Class that a given type refers to.
-   * 
+   *
    * @param type The type of interest
    * @return The Class that type represents
    */
@@ -353,7 +351,7 @@
   /**
    * Returns the {@link Class} which can serialize the given instance type, or
    * <code>null</code> if this class has no custom field serializer.
-   * 
+   *
    * Note that arrays never have custom field serializers.
    */
   public static Class<?> hasCustomFieldSerializer(Class<?> instanceType) {
@@ -384,7 +382,7 @@
    * Returns the server-side {@link Class} which can serialize the given
    * instance type, or <code>null</code> if this class has no type-checking
    * custom field serializer.
-   * 
+   *
    * Note that arrays never have custom field serializers.
    */
   public static Class<?> hasServerCustomFieldSerializer(Class<?> instanceType) {
@@ -413,10 +411,10 @@
 
   /**
    * Remove all of the actual types that arose from the the given type.
-   * 
+   *
    * This method should always be called after a corresponding call to
    * resolveTypes.
-   * 
+   *
    * @param methodType The type we wish to assign this instance to
    * @param resolvedTypes The types that have been resolved to actual values
    */
@@ -428,10 +426,10 @@
    * Find all the actual types we can from the information in the given type,
    * and put the mapping from TypeVariable objects to actual types into the
    * resolved types map.
-   * 
+   *
    * The method releaseTypes should always be called after a call to this
    * method, unless the resolved types map is about to be discarded.
-   * 
+   *
    * @param methodType The type we wish to assign this instance to
    * @param resolvedTypes The types that have been resolved to actual values
    */
@@ -464,12 +462,12 @@
   /**
    * Loads a {@link CustomFieldSerializer} from a class that may implement that
    * interface.
-   * 
+   *
    * @param customSerializerClass the Custom Field Serializer class
-   * 
+   *
    * @return an instance the class provided if it implements
    *         {@link CustomFieldSerializer} or {@code null} if it does not
-   * 
+   *
    * @throws SerializationException if the load process encounters an unexpected
    *           problem
    */
@@ -567,7 +565,7 @@
     if (Throwable.class == field.getDeclaringClass()) {
       /**
        * Only serialize Throwable's detailMessage field; all others are ignored.
-       * 
+       *
        * NOTE: Changing the set of fields that we serialize for Throwable will
        * necessitate a change to our JRE emulation's version of Throwable.
        */
@@ -612,7 +610,7 @@
       }
     } else if (expectedType instanceof WildcardType) {
       WildcardType wildcardType = (WildcardType) expectedType;
-      
+
       Type[] lowerBounds = wildcardType.getLowerBounds();
       for (Type type : lowerBounds) {
         /* Require instance to be a superclass of type, or type itself. */
@@ -625,7 +623,7 @@
           }
           boundClass = boundClass.getSuperclass();
         }
-        
+
         // We fail if the class does not meet any bound, as we should.
         if (boundClass == null) {
           return false;
@@ -672,7 +670,7 @@
         return true;
       }
     }
-    
+
     Type[] interfaces = instanceClass.getGenericInterfaces();
     for (Type interfaceType : interfaces) {
       Type[] localTypes = expectedParameterTypes.clone();
@@ -691,7 +689,7 @@
   private static boolean findExpectedInstanceClassFromSuper(
       Type superType, Type expectedType, DequeMap<TypeVariable<?>, Type> resolvedTypes,
       Set<Class<?>> expectedInstanceClasses, Type[] expectedParameterTypes) {
-    
+
     if (superType instanceof GenericArrayType) {
       // Can't use array types as supertypes or interfaces
       return false;
@@ -723,18 +721,18 @@
       Type[] upperBounds = wildcardType.getUpperBounds();
       for (Type boundType : upperBounds) {
         if (findExpectedInstanceClassFromSuper(boundType, expectedType,
-            resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { 
+            resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) {
           return true;
         }
       }
     }
-    
+
     return false;
   }
 
     /**
    * Attempt to find known type for TypeVariable type from an instance.
-   * 
+   *
    * @param foundParameter The currently known parameter, which must be of type
    *          TypeVariable
    * @param instanceType The instance that we need to check for information
@@ -802,7 +800,7 @@
    * Attempt to find the actual types for the generic parameters of an instance,
    * given the types we have resolved from the method signature or class field
    * declaration.
-   * 
+   *
    * @param instanceClass The instance for which we want actual generic
    *          parameter types.
    * @param resolvedTypes The types that have been resolved to actual values
@@ -861,7 +859,7 @@
 
   private static void generateSerializationSignature(Class<?> instanceType, CRC32 crc,
       SerializationPolicy policy) throws UnsupportedEncodingException {
-    crc.update(getSerializedTypeName(instanceType).getBytes(DEFAULT_ENCODING));
+    crc.update(getSerializedTypeName(instanceType).getBytes(RPCServletUtils.CHARSET_UTF8));
 
     if (excludeImplementationFromSerializationSignature(instanceType)) {
       return;
@@ -882,8 +880,8 @@
          * generate the signature. Otherwise, use all known fields.
          */
         if ((clientFieldNames == null) || clientFieldNames.contains(field.getName())) {
-          crc.update(field.getName().getBytes(DEFAULT_ENCODING));
-          crc.update(getSerializedTypeName(field.getType()).getBytes(DEFAULT_ENCODING));
+          crc.update(field.getName().getBytes(RPCServletUtils.CHARSET_UTF8));
+          crc.update(getSerializedTypeName(field.getType()).getBytes(RPCServletUtils.CHARSET_UTF8));
         }
       }
 
@@ -954,7 +952,7 @@
       }
     } else if (methodType instanceof Class) {
       Class<?> classType = (Class<?>) methodType;
-      
+
       // A type that is of instance Class, with TypeParameters, must be a raw
       // class, so strip off any parameters in the map.
       TypeVariable<?>[] classParams = classType.getTypeParameters();
diff --git a/user/test/com/google/gwt/user/server/rpc/RPCServletUtilsTest.java b/user/test/com/google/gwt/user/server/rpc/RPCServletUtilsTest.java
index 27c6932..18928f2 100644
--- a/user/test/com/google/gwt/user/server/rpc/RPCServletUtilsTest.java
+++ b/user/test/com/google/gwt/user/server/rpc/RPCServletUtilsTest.java
@@ -1,12 +1,12 @@
 /*
  * Copyright 2008 Google Inc.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
@@ -23,6 +23,7 @@
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
 
 import javax.servlet.ServletException;
 import javax.servlet.ServletInputStream;
@@ -30,7 +31,6 @@
 
 /**
  * Tests some of the methods in {@link RPCServletUtils}.
- * 
  */
 public class RPCServletUtilsTest extends TestCase {
 
@@ -69,7 +69,7 @@
     public String getHeader(String name) {
       return null;
     }
-      
+
     @SuppressWarnings("unused")
     @Override
     public ServletInputStream getInputStream() throws IOException {
@@ -165,6 +165,31 @@
   }
 
   /**
+   * RPCServletUtils#getCharset() should return the same instance for
+   * every invocation of a given encoding.
+   */
+  public void testGetCharsetInstances() {
+    // Default UTF-8 character set.
+    assertSame(RPCServletUtils.getCharset(null),
+        RPCServletUtils.getCharset(null));
+    assertSame(RPCServletUtils.getCharset("UTF-8"),
+        RPCServletUtils.getCharset("UTF-8"));
+    assertSame(RPCServletUtils.getCharset("US-ASCII"),
+        RPCServletUtils.getCharset("US-ASCII"));
+    assertSame(RPCServletUtils.getCharset("ISO-8859-1"),
+        RPCServletUtils.getCharset("ISO-8859-1"));
+  }
+
+  /**
+   * Test that RPCServletUtils#getCharset() returns the correct
+   * default UTF-8 charachter set when passed a null encoding value.
+   */
+  public void testGetDefaultCharset() {
+    assertEquals(Charset.forName("UTF-8"), RPCServletUtils.CHARSET_UTF8);
+    assertSame(RPCServletUtils.CHARSET_UTF8, RPCServletUtils.getCharset(null));
+  }
+
+  /**
    * Character type doesn't match UTF-8, but ignore it.
    */
   public void testIgnoreCharacterEncoding() throws IOException,