diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 3722537ae..88f18ea29 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,6 +1,9 @@
 version: 2
 updates:
-
+  - package-ecosystem: "maven"
+    directory: "/aws-lambda-java-runtime-interface"
+    schedule:
+      interval: "weekly"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
diff --git a/.github/workflows/runtime-interface-client_merge_to_main.yml b/.github/workflows/runtime-interface-client_merge_to_main.yml
index 8909d56bf..3560207f3 100644
--- a/.github/workflows/runtime-interface-client_merge_to_main.yml
+++ b/.github/workflows/runtime-interface-client_merge_to_main.yml
@@ -49,7 +49,7 @@ jobs:
           
     - name: Build and install serialization dependency locally
       working-directory: ./aws-lambda-java-serialization
-      run: mvn clean install -DskipTests
+      run: mvn clean install
 
     - name: Test Runtime Interface Client xplatform build - Run 'build' target
       working-directory: ./aws-lambda-java-runtime-interface-client
diff --git a/.github/workflows/runtime-interface-client_pr.yml b/.github/workflows/runtime-interface-client_pr.yml
index 35c6ca06b..5819218c9 100644
--- a/.github/workflows/runtime-interface-client_pr.yml
+++ b/.github/workflows/runtime-interface-client_pr.yml
@@ -29,7 +29,7 @@ jobs:
 
     - name: Build and install serialization dependency locally
       working-directory: ./aws-lambda-java-serialization
-      run: mvn clean install -DskipTests
+      run: mvn clean install
 
     - name: Runtime Interface Client smoke tests - Run 'pr' target
       working-directory: ./aws-lambda-java-runtime-interface-client
@@ -65,7 +65,7 @@ jobs:
 
     - name: Build and install serialization dependency locally
       working-directory: ./aws-lambda-java-serialization
-      run: mvn clean install -DskipTests
+      run: mvn clean install
 
     - name: Test Runtime Interface Client xplatform build - Run 'build' target
       working-directory: ./aws-lambda-java-runtime-interface-client
diff --git a/README.md b/README.md
index b5153a87f..b6c67b9e8 100644
--- a/README.md
+++ b/README.md
@@ -163,7 +163,7 @@ The purpose of this package is to allow developers to deploy their applications
 <dependency>
  <groupId>com.amazonaws</groupId>
  <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
- <version>2.7.0</version>
+ <version>2.8.6</version>
 </dependency>
 ```
 
diff --git a/aws-lambda-java-runtime-interface-client/README.md b/aws-lambda-java-runtime-interface-client/README.md
index 67a5972d6..4e03f041f 100644
--- a/aws-lambda-java-runtime-interface-client/README.md
+++ b/aws-lambda-java-runtime-interface-client/README.md
@@ -70,7 +70,7 @@ pom.xml
     <dependency>
       <groupId>com.amazonaws</groupId>
       <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
-      <version>2.7.0</version>
+      <version>2.8.7</version>
     </dependency>
   </dependencies>
   <build>
@@ -203,7 +203,7 @@ platform-specific JAR by setting the `<classifier>`.
 <dependency>
     <groupId>com.amazonaws</groupId>
     <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
-    <version>2.7.0</version>
+    <version>2.8.7</version>
     <classifier>linux-x86_64</classifier>
 </dependency>
 ```
diff --git a/aws-lambda-java-runtime-interface-client/RELEASE.CHANGELOG.md b/aws-lambda-java-runtime-interface-client/RELEASE.CHANGELOG.md
index ac073ae85..93d8cf23a 100644
--- a/aws-lambda-java-runtime-interface-client/RELEASE.CHANGELOG.md
+++ b/aws-lambda-java-runtime-interface-client/RELEASE.CHANGELOG.md
@@ -1,3 +1,36 @@
+### September 22, 2025
+`2.8.7`
+- Remove Minimum and Maximum Limits of AWS_LAMBDA_MAX_CONCURRENCY.
+
+### September 22, 2025
+`2.8.6`
+- Set Multiconcurrent Trace ID using utils-lite.
+
+### September 17, 2025
+`2.8.5`
+- Log errorType and errorMessage from RAPID in C++ Client.
+- Performance Upgrade for Multiconcurrency Mode.
+
+### September 9, 2025
+`2.8.4`
+- Make Trace ID Accessible through Context Object.
+
+### July 19, 2025
+`2.8.3`
+- Ensure EventHandlerLoader Thread Safety.
+
+### June 26, 2025
+`2.8.2`
+- Allow AWS_LAMBDA_MAX_CONCURRENCY to be One. Crash the RIC if it is set to an un-parsable string to an integer or an out of bounds value.
+
+### June 26, 2025
+`2.8.1`
+- Refactoring
+
+### June 26, 2025
+`2.8.0`
+- Refactoring
+
 ### May 21, 2025
 `2.7.0`
 - Adding support for multi tenancy ([#540](https://github.com/aws/aws-lambda-java-libs/pull/540))
diff --git a/aws-lambda-java-runtime-interface-client/pom.xml b/aws-lambda-java-runtime-interface-client/pom.xml
index c854fabcd..2a4df9863 100644
--- a/aws-lambda-java-runtime-interface-client/pom.xml
+++ b/aws-lambda-java-runtime-interface-client/pom.xml
@@ -1,10 +1,10 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.amazonaws</groupId>
     <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
-    <version>2.8.4</version>
+    <version>2.8.7</version>
     <packaging>jar</packaging>
 
     <name>AWS Lambda Java Runtime Interface Client</name>
@@ -47,9 +47,9 @@
             separately from the Runtime Interface Client functionality until we figure something else out.
         -->
         <multiArch>true</multiArch>
-        <target_build_os/>
-        <target_build_arch/>
-        <ric.classifier/>
+        <target_build_os />
+        <target_build_arch />
+        <ric.classifier />
         <!--
             Some test/integration/codebuild/buildspec.*.yml files will set -DargLineForReflectionTestOnly=""
             as this is not supported by all flavors of java
@@ -68,7 +68,11 @@
             <artifactId>aws-lambda-java-serialization</artifactId>
             <version>1.1.6</version>
         </dependency>
-
+        <dependency>
+            <groupId>software.amazon.awssdk</groupId>
+            <artifactId>utils-lite</artifactId>
+            <version>2.34.0</version>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
@@ -152,11 +156,11 @@
                         <configuration>
                             <target name="Build JNI libraries for tests">
                                 <exec executable="${project.basedir}/src/main/jni/build-jni-lib.sh"
-                                      failonerror="true" logError="true">
-                                    <arg value="${project.build.directory}"/>
-                                    <arg value="false"/>
-                                    <arg value="${target_build_os}"/>
-                                    <arg value="${target_build_arch}"/>
+                                    failonerror="true" logError="true">
+                                    <arg value="${project.build.directory}" />
+                                    <arg value="false" />
+                                    <arg value="${target_build_os}" />
+                                    <arg value="${target_build_arch}" />
                                 </exec>
                             </target>
                         </configuration>
@@ -170,11 +174,11 @@
                         <configuration>
                             <target name="Build JNI libraries">
                                 <exec executable="${project.basedir}/src/main/jni/build-jni-lib.sh"
-                                      failonerror="true" logError="true">
-                                    <arg value="${project.build.directory}"/>
-                                    <arg value="${multiArch}"/>
-                                    <arg value="${target_build_os}"/>
-                                    <arg value="${target_build_arch}"/>
+                                    failonerror="true" logError="true">
+                                    <arg value="${project.build.directory}" />
+                                    <arg value="${multiArch}" />
+                                    <arg value="${target_build_os}" />
+                                    <arg value="${target_build_arch}" />
                                 </exec>
                             </target>
                         </configuration>
@@ -269,7 +273,7 @@
                     </execution>
                 </executions>
             </plugin>
-              <plugin>
+            <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-checkstyle-plugin</artifactId>
                 <version>${maven-checkstyle-plugin.version}</version>
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambda.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambda.java
index 2eeb14e3d..e5b221a80 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambda.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambda.java
@@ -15,10 +15,12 @@
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.LambdaError;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.LambdaRuntimeApiClient;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.LambdaRuntimeApiClientImpl;
+import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.LambdaRuntimeClientMaxRetriesExceededException;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.RapidErrorType;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.converters.LambdaErrorConverter;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.converters.XRayErrorCauseConverter;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.dto.InvocationRequest;
+import com.amazonaws.services.lambda.runtime.api.client.util.ConcurrencyConfig;
 import com.amazonaws.services.lambda.runtime.api.client.util.LambdaOutputStream;
 import com.amazonaws.services.lambda.runtime.api.client.util.UnsafeUtil;
 import com.amazonaws.services.lambda.runtime.logging.LogFormat;
@@ -35,6 +37,10 @@
 import java.net.URLClassLoader;
 import java.security.Security;
 import java.util.Properties;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import software.amazon.awssdk.utilslite.SdkInternalThreadLocal;
 
 /**
  * The entrypoint of this class is {@link AWSLambda#startRuntime}. It performs two main tasks:
@@ -49,8 +55,8 @@
  */
 public class AWSLambda {
 
-    protected static URLClassLoader customerClassLoader;
-
+    private static URLClassLoader customerClassLoader;
+    
     private static final String TRUST_STORE_PROPERTY = "javax.net.ssl.trustStore";
 
     private static final String JAVA_SECURITY_PROPERTIES = "java.security.properties";
@@ -69,8 +75,8 @@ public class AWSLambda {
 
     private static final String AWS_LAMBDA_INITIALIZATION_TYPE = System.getenv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_INITIALIZATION_TYPE);
 
-    private static LambdaRuntimeApiClient runtimeClient;
-
+    private static final String CONCURRENT_TRACE_ID_KEY = "AWS_LAMBDA_X_TRACE_ID";
+    
     static {
         // Override the disabledAlgorithms setting to match configuration for openjdk8-u181.
         // This is to keep DES ciphers around while we deploying security updates.
@@ -137,15 +143,13 @@ private static LambdaRequestHandler findRequestHandler(final String handlerStrin
         return requestHandler;
     }
 
-    private static LambdaRequestHandler getLambdaRequestHandlerObject(String handler, LambdaContextLogger lambdaLogger) throws ClassNotFoundException, IOException {
+    private static LambdaRequestHandler getLambdaRequestHandlerObject(String handler, LambdaContextLogger lambdaLogger, LambdaRuntimeApiClient runtimeClient) throws ClassNotFoundException, IOException {
         UnsafeUtil.disableIllegalAccessWarning();
 
         System.setOut(new PrintStream(new LambdaOutputStream(System.out), false, "UTF-8"));
         System.setErr(new PrintStream(new LambdaOutputStream(System.err), false, "UTF-8"));
         setupRuntimeLogger(lambdaLogger);
 
-        runtimeClient = new LambdaRuntimeApiClientImpl(LambdaEnvironment.RUNTIME_API);
-
         String taskRoot = System.getProperty("user.dir");
         String libRoot = "/opt/java";
         // Make system classloader the customer classloader's parent to ensure any aws-lambda-java-core classes
@@ -167,13 +171,13 @@ private static LambdaRequestHandler getLambdaRequestHandlerObject(String handler
         }
 
         if (INIT_TYPE_SNAP_START.equals(AWS_LAMBDA_INITIALIZATION_TYPE)) {
-            onInitComplete(lambdaLogger);
+            onInitComplete(lambdaLogger, runtimeClient);
         }
 
         return requestHandler;
     }
 
-    public static void setupRuntimeLogger(LambdaLogger lambdaLogger)
+    private static void setupRuntimeLogger(LambdaLogger lambdaLogger)
             throws ClassNotFoundException {
         ReflectUtil.setStaticField(
                 Class.forName("com.amazonaws.services.lambda.runtime.LambdaRuntime"),
@@ -213,10 +217,11 @@ private static LogSink createLogSink() {
     }
 
     public static void main(String[] args) throws Throwable {
-        try (LambdaContextLogger logger = initLogger()) {
-            LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandlerObject(args[0], logger);
-            startRuntimeLoop(lambdaRequestHandler, logger);
-
+        try (LambdaContextLogger lambdaLogger = initLogger()) {
+            LambdaRuntimeApiClient runtimeClient = new LambdaRuntimeApiClientImpl(LambdaEnvironment.RUNTIME_API);
+            LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandlerObject(args[0], lambdaLogger, runtimeClient);
+            ConcurrencyConfig concurrencyConfig = new ConcurrencyConfig(lambdaLogger);
+            startRuntimeLoops(lambdaRequestHandler, lambdaLogger, concurrencyConfig, runtimeClient);
         } catch (IOException | ClassNotFoundException t) {
             throw new Error(t);
         }
@@ -232,50 +237,111 @@ private static LambdaContextLogger initLogger() {
         return logger;
     }
 
-    private static void startRuntimeLoop(LambdaRequestHandler requestHandler, LambdaContextLogger lambdaLogger) throws Throwable {
-        boolean shouldExit = false;
-        while (!shouldExit) {
-            UserFault userFault = null;
-            InvocationRequest request = runtimeClient.nextInvocation();
-            if (request.getXrayTraceId() != null) {
-                System.setProperty(LAMBDA_TRACE_HEADER_PROP, request.getXrayTraceId());
-            } else {
-                System.clearProperty(LAMBDA_TRACE_HEADER_PROP);
+    private static void startRuntimeLoopWithExecutor(LambdaRequestHandler lambdaRequestHandler, LambdaContextLogger lambdaLogger, ExecutorService executorService, LambdaRuntimeApiClient runtimeClient) {
+        executorService.submit(() -> { 
+            try {
+                startRuntimeLoop(lambdaRequestHandler, lambdaLogger, runtimeClient, false);
+            } catch (Exception e) {
+                lambdaLogger.log(String.format("Runtime Loop on Thread ID: %s Failed.\n%s", Thread.currentThread().getName(), UserFault.trace(e)), lambdaLogger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);
             }
+        });
+    }
 
-            ByteArrayOutputStream payload;
+    protected static void startRuntimeLoops(LambdaRequestHandler lambdaRequestHandler, LambdaContextLogger lambdaLogger, ConcurrencyConfig concurrencyConfig, LambdaRuntimeApiClient runtimeClient) throws Exception {
+        if (concurrencyConfig.isMultiConcurrent()) {
+            lambdaLogger.log(concurrencyConfig.getConcurrencyConfigMessage(), lambdaLogger.getLogFormat() == LogFormat.JSON ? LogLevel.INFO : LogLevel.UNDEFINED);
+            ExecutorService platformThreadExecutor = Executors.newFixedThreadPool(concurrencyConfig.getNumberOfPlatformThreads());
             try {
-                payload = requestHandler.call(request);
-                runtimeClient.reportInvocationSuccess(request.getId(), payload.toByteArray());
-                // clear interrupted flag in case if it was set by user's code
-                Thread.interrupted();
-            } catch (UserFault f) {
-                shouldExit = f.fatal;
-                userFault = f;
-                UserFault.filterStackTrace(f);
-                LambdaError error = new LambdaError(
-                        LambdaErrorConverter.fromUserFault(f),
-                        RapidErrorType.BadFunctionCode);
-                runtimeClient.reportInvocationError(request.getId(), error);
-            } catch (Throwable t) {
-                shouldExit = t instanceof VirtualMachineError || t instanceof IOError;
-                UserFault.filterStackTrace(t);
-                userFault = UserFault.makeUserFault(t);
-
-                LambdaError error = new LambdaError(
-                        LambdaErrorConverter.fromThrowable(t),
-                        XRayErrorCauseConverter.fromThrowable(t),
-                        RapidErrorType.UserException);
-                runtimeClient.reportInvocationError(request.getId(), error);
+                for (int i = 0; i < concurrencyConfig.getNumberOfPlatformThreads(); i++) {
+                    startRuntimeLoopWithExecutor(lambdaRequestHandler, lambdaLogger, platformThreadExecutor, runtimeClient);
+                }
             } finally {
-                if (userFault != null) {
-                    lambdaLogger.log(userFault.reportableError(), lambdaLogger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);
+                platformThreadExecutor.shutdown();
+                try {
+                    platformThreadExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
                 }
             }
+        } else {
+            startRuntimeLoop(lambdaRequestHandler, lambdaLogger, runtimeClient, true);
+        }
+    }
+
+    private static LambdaError createLambdaErrorFromThrowableOrUserFault(Throwable t) {
+        if (t instanceof UserFault) {
+            return new LambdaError(
+                    LambdaErrorConverter.fromUserFault((UserFault) t),
+                    RapidErrorType.BadFunctionCode);
+        } else {
+            return new LambdaError(
+                    LambdaErrorConverter.fromThrowable(t),
+                    XRayErrorCauseConverter.fromThrowable(t),
+                    RapidErrorType.UserException);
         }
     }
 
-    static void onInitComplete(final LambdaContextLogger lambdaLogger) throws IOException {
+    private static void setEnvVarForXrayTraceId(InvocationRequest request) {
+        if (request.getXrayTraceId() != null) {
+            System.setProperty(LAMBDA_TRACE_HEADER_PROP, request.getXrayTraceId());
+        } else {
+            System.clearProperty(LAMBDA_TRACE_HEADER_PROP);
+        }
+    }
+
+    private static void reportNonLoopTerminatingException(LambdaContextLogger lambdaLogger, Throwable t) {
+        lambdaLogger.log(
+                String.format(
+                        "Runtime Loop on Thread ID: %s Faced and Exception. This exception will not stop the runtime loop.\nException:\n%s",
+                        Thread.currentThread().getName(), UserFault.trace(t)),
+                lambdaLogger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);
+    }
+
+    /*
+     * In multiconcurrent mode (exitLoopOnErrors = false), The Runtime Loop will not exit unless LambdaRuntimeClientMaxRetriesExceededException is thrown when calling nextInvocationWithExponentialBackoff.
+     * In normal/sequential mode (exitLoopOnErrors = true), The Runtime Loop will exit if nextInvocation call fails, when UserFault is fatal, or an Error of type VirtualMachineError or IOError is thrown.
+     */
+    private static void startRuntimeLoop(LambdaRequestHandler lambdaRequestHandler, LambdaContextLogger lambdaLogger, LambdaRuntimeApiClient runtimeClient, boolean exitLoopOnErrors) throws Exception {
+        boolean shouldExit = false;
+        while (!shouldExit) {
+            try {
+                UserFault userFault = null;
+                InvocationRequest request = exitLoopOnErrors ? runtimeClient.nextInvocation() : runtimeClient.nextInvocationWithExponentialBackoff(lambdaLogger);
+                if (exitLoopOnErrors) {
+                    setEnvVarForXrayTraceId(request);
+                } else {
+                    SdkInternalThreadLocal.put(CONCURRENT_TRACE_ID_KEY, request.getXrayTraceId());
+                }
+
+                try {
+                    ByteArrayOutputStream payload = lambdaRequestHandler.call(request);
+                    runtimeClient.reportInvocationSuccess(request.getId(), payload.toByteArray());
+                    // clear interrupted flag in case if it was set by user's code
+                    Thread.interrupted();
+                } catch (Throwable t) {
+                    UserFault.filterStackTrace(t);
+                    userFault = UserFault.makeUserFault(t);
+                    shouldExit = exitLoopOnErrors && (t instanceof VirtualMachineError || t instanceof IOError || userFault.fatal);
+                    LambdaError error = createLambdaErrorFromThrowableOrUserFault(t);
+                    runtimeClient.reportInvocationError(request.getId(), error);
+                } finally {
+                    if (userFault != null) {
+                        lambdaLogger.log(userFault.reportableError(), lambdaLogger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);
+                    }
+
+                    SdkInternalThreadLocal.remove(CONCURRENT_TRACE_ID_KEY);
+                }
+            } catch (Throwable t) {
+                if (exitLoopOnErrors || t instanceof LambdaRuntimeClientMaxRetriesExceededException) {
+                    throw t;
+                }
+
+                reportNonLoopTerminatingException(lambdaLogger, t);
+            }
+        }
+    }
+
+    private static void onInitComplete(final LambdaContextLogger lambdaLogger, LambdaRuntimeApiClient runtimeClient) throws IOException {
         try {
             Core.getGlobalContext().beforeCheckpoint(null);
             runtimeClient.restoreNext();
@@ -303,4 +369,8 @@ private static void logExceptionCloudWatch(LambdaContextLogger lambdaLogger, Exc
         UserFault userFault = UserFault.makeUserFault(exc, true);
         lambdaLogger.log(userFault.reportableError(), lambdaLogger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);
     }
+
+    protected static URLClassLoader getCustomerClassLoader() {
+        return customerClassLoader;
+    }
 }
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoader.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoader.java
index 2876499ec..f679c217c 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoader.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoader.java
@@ -57,10 +57,10 @@ private enum Platform {
         UNKNOWN
     }
 
-    private static volatile PojoSerializer<LambdaClientContext> contextSerializer;
-    private static volatile PojoSerializer<LambdaCognitoIdentity> cognitoSerializer;
+    private static volatile ThreadLocal<PojoSerializer<LambdaClientContext>> contextSerializer = new ThreadLocal<>();
+    private static volatile ThreadLocal<PojoSerializer<LambdaCognitoIdentity>> cognitoSerializer = new ThreadLocal<>();
 
-    private static final EnumMap<Platform, Map<Type, PojoSerializer<Object>>> typeCache = new EnumMap<>(Platform.class);
+    private static final ThreadLocal<EnumMap<Platform, Map<Type, PojoSerializer<Object>>>> typeCache = ThreadLocal.withInitial(() -> new EnumMap<>(Platform.class));
 
     private static final Comparator<Method> methodPriority = new Comparator<Method>() {
         public int compare(Method lhs, Method rhs) {
@@ -116,7 +116,7 @@ private static PojoSerializer<Object> getSerializer(Platform platform, Type type
         if (type instanceof Class) {
             Class<Object> clazz = ((Class) type);
             if (LambdaEventSerializers.isLambdaSupportedEvent(clazz.getName())) {
-                return LambdaEventSerializers.serializerFor(clazz, AWSLambda.customerClassLoader);
+                return LambdaEventSerializers.serializerFor(clazz, AWSLambda.getCustomerClassLoader());
             }
         }
         // else platform dependent (Android uses GSON but all other platforms use Jackson)
@@ -127,10 +127,11 @@ private static PojoSerializer<Object> getSerializer(Platform platform, Type type
     }
 
     private static PojoSerializer<Object> getSerializerCached(Platform platform, Type type) {
-        Map<Type, PojoSerializer<Object>> cache = typeCache.get(platform);
+        EnumMap<Platform, Map<Type, PojoSerializer<Object>>> threadTypeCache = typeCache.get();
+        Map<Type, PojoSerializer<Object>> cache = threadTypeCache.get(platform);
         if (cache == null) {
             cache = new HashMap<>();
-            typeCache.put(platform, cache);
+            threadTypeCache.put(platform, cache);
         }
 
         PojoSerializer<Object> serializer = cache.get(type);
@@ -143,17 +144,17 @@ private static PojoSerializer<Object> getSerializerCached(Platform platform, Typ
     }
 
     private static PojoSerializer<LambdaClientContext> getContextSerializer() {
-        if (contextSerializer == null) {
-            contextSerializer = GsonFactory.getInstance().getSerializer(LambdaClientContext.class);
+        if (contextSerializer.get() == null) {
+            contextSerializer.set(GsonFactory.getInstance().getSerializer(LambdaClientContext.class));
         }
-        return contextSerializer;
+        return contextSerializer.get();
     }
 
     private static PojoSerializer<LambdaCognitoIdentity> getCognitoSerializer() {
-        if (cognitoSerializer == null) {
-            cognitoSerializer = GsonFactory.getInstance().getSerializer(LambdaCognitoIdentity.class);
+        if (cognitoSerializer.get() == null) {
+            cognitoSerializer.set(GsonFactory.getInstance().getSerializer(LambdaCognitoIdentity.class));
         }
-        return cognitoSerializer;
+        return cognitoSerializer.get();
     }
 
 
@@ -527,15 +528,14 @@ private static LambdaRequestHandler wrapPojoHandler(RequestHandler instance, Typ
 
     private static LambdaRequestHandler wrapRequestStreamHandler(final RequestStreamHandler handler) {
         return new LambdaRequestHandler() {
-            private final ByteArrayOutputStream output = new ByteArrayOutputStream(1024);
-            private Functions.V2<String, String> log4jContextPutMethod = null;
+            private final ThreadLocal<ByteArrayOutputStream> outputBuffers = ThreadLocal.withInitial(() -> new ByteArrayOutputStream(1024));
+            private ThreadLocal<Functions.V2<String, String>> log4jContextPutMethod = new ThreadLocal<>();
 
-            private void safeAddRequestIdToLog4j(String log4jContextClassName,
-                                                 InvocationRequest request, Class contextMapValueClass) {
+            private void safeAddRequestIdToLog4j(String log4jContextClassName, InvocationRequest request, Class contextMapValueClass) {
                 try {
-                    Class<?> log4jContextClass = ReflectUtil.loadClass(AWSLambda.customerClassLoader, log4jContextClassName);
-                    log4jContextPutMethod = ReflectUtil.loadStaticV2(log4jContextClass, "put", false, String.class, contextMapValueClass);
-                    log4jContextPutMethod.call("AWSRequestId", request.getId());
+                    Class<?> log4jContextClass = ReflectUtil.loadClass(AWSLambda.getCustomerClassLoader(), log4jContextClassName);
+                    log4jContextPutMethod.set(ReflectUtil.loadStaticV2(log4jContextClass, "put", false, String.class, contextMapValueClass));
+                    log4jContextPutMethod.get().call("AWSRequestId", request.getId());
                 } catch (Exception e) {
                     // nothing to do here
                 }
@@ -558,6 +558,7 @@ private void safeAddContextToLambdaLogger(LambdaContext context) {
             }
 
             public ByteArrayOutputStream call(InvocationRequest request) throws Error, Exception {
+                ByteArrayOutputStream output = outputBuffers.get();
                 output.reset();
 
                 LambdaCognitoIdentity cognitoIdentity = null;
@@ -592,7 +593,7 @@ public ByteArrayOutputStream call(InvocationRequest request) throws Error, Excep
                     safeAddRequestIdToLog4j("org.apache.log4j.MDC", request, Object.class);
                     safeAddRequestIdToLog4j("org.apache.logging.log4j.ThreadContext", request, String.class);
                     // if put method not assigned in either call to safeAddRequestIdtoLog4j then log4jContextPutMethod = null
-                    if (log4jContextPutMethod == null) {
+                    if (log4jContextPutMethod.get() == null) {
                         System.err.println("Customer using log4j appender but unable to load either " 
                             + "org.apache.log4j.MDC or org.apache.logging.log4j.ThreadContext. " 
                             + "Customer cannot see RequestId in log4j log lines.");
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoader.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoader.java
index daea5911f..da37f7ca7 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoader.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoader.java
@@ -28,7 +28,7 @@ private static CustomPojoSerializer loadSerializer()
             return customPojoSerializer;
         }
 
-        ServiceLoader<CustomPojoSerializer> loader = ServiceLoader.load(CustomPojoSerializer.class, AWSLambda.customerClassLoader);
+        ServiceLoader<CustomPojoSerializer> loader = ServiceLoader.load(CustomPojoSerializer.class, AWSLambda.getCustomerClassLoader());
         Iterator<CustomPojoSerializer> serializers = loader.iterator();
 
         if (!serializers.hasNext()) {
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/ReservedRuntimeEnvironmentVariables.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/ReservedRuntimeEnvironmentVariables.java
index 7500a4943..9fdec6b9f 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/ReservedRuntimeEnvironmentVariables.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/ReservedRuntimeEnvironmentVariables.java
@@ -106,4 +106,10 @@ public interface ReservedRuntimeEnvironmentVariables {
      * The environment's time zone (UTC). The execution environment uses NTP to synchronize the system clock.
      */
     String TZ = "TZ";
+
+    /*
+     * If set to a string parsable as an integer > 0, It enables multiconcurrency mode. 
+     * Otherwise, if it is set to an invalid value, it will crash the whole RIC process.
+     */
+    String AWS_LAMBDA_MAX_CONCURRENCY = "AWS_LAMBDA_MAX_CONCURRENCY";
 }
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/UserFault.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/UserFault.java
index c7c5c9ddf..7d8a50347 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/UserFault.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/UserFault.java
@@ -38,7 +38,7 @@ public UserFault(String msg, String exception, String trace, Boolean fatal) {
      * No more user code should run after a fault.
      */
     public static UserFault makeUserFault(Throwable t) {
-        return makeUserFault(t, false);
+        return t instanceof UserFault ? (UserFault) t : makeUserFault(t, false);
     }
 
     public static UserFault makeUserFault(Throwable t, boolean fatal) {
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/JsonLogFormatter.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/JsonLogFormatter.java
index f463e7ee5..f1051a216 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/JsonLogFormatter.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/JsonLogFormatter.java
@@ -22,7 +22,7 @@ public class JsonLogFormatter implements LogFormatter {
                 withZone(ZoneId.of("UTC"));
     private final PojoSerializer<StructuredLogMessage> serializer = GsonFactory.getInstance().getSerializer(StructuredLogMessage.class);
 
-    private LambdaContext lambdaContext;
+    private ThreadLocal<LambdaContext> lambdaContext = new ThreadLocal<>();
 
     @Override
     public String format(String message, LogLevel logLevel) {
@@ -39,10 +39,12 @@ private StructuredLogMessage createLogMessage(String message, LogLevel logLevel)
         msg.message = message;
         msg.level = logLevel;
 
-        if (lambdaContext != null) {
-            msg.AWSRequestId = lambdaContext.getAwsRequestId();
-            msg.tenantId = lambdaContext.getTenantId();
+        LambdaContext lambdaContextForCurrentThread = lambdaContext.get();
+        if (lambdaContextForCurrentThread != null) {
+            msg.AWSRequestId = lambdaContextForCurrentThread.getAwsRequestId();
+            msg.tenantId = lambdaContextForCurrentThread.getTenantId();
         }
+
         return msg;
     }
 
@@ -53,6 +55,10 @@ private StructuredLogMessage createLogMessage(String message, LogLevel logLevel)
      */
     @Override
     public void setLambdaContext(LambdaContext context) {
-        this.lambdaContext = context;
+        if (context == null) {
+            lambdaContext.remove();
+        } else {
+            lambdaContext.set(context);
+        }
     }
 }
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/StdOutLogSink.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/StdOutLogSink.java
index 873e6fde5..90e7d39c2 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/StdOutLogSink.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/StdOutLogSink.java
@@ -15,7 +15,7 @@ public void log(byte[] message) {
         log(LogLevel.UNDEFINED, LogFormat.TEXT, message);
     }
 
-    public void log(LogLevel logLevel, LogFormat logFormat, byte[] message) {
+    public synchronized void log(LogLevel logLevel, LogFormat logFormat, byte[] message) {
         try {
             System.out.write(message);
         } catch (IOException e) {
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClient.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClient.java
index e2ae0969a..a62aeb9b8 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClient.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClient.java
@@ -4,6 +4,7 @@
 */
 package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
 
+import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.dto.InvocationRequest;
 import java.io.IOException;
 
@@ -24,6 +25,11 @@ public interface LambdaRuntimeApiClient {
      */
     InvocationRequest nextInvocation() throws IOException;
 
+    /**
+     * Get next invocation with exponential backoff
+     */
+    InvocationRequest nextInvocationWithExponentialBackoff(LambdaContextLogger lambdaLogger) throws Exception;
+
     /**
      * Report invocation success
      * @param requestId request id
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImpl.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImpl.java
index 65024b98e..caca69aa7 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImpl.java
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImpl.java
@@ -4,7 +4,11 @@
 */
 package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
 
+import com.amazonaws.services.lambda.runtime.api.client.UserFault;
+import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.dto.InvocationRequest;
+import com.amazonaws.services.lambda.runtime.logging.LogFormat;
+import com.amazonaws.services.lambda.runtime.logging.LogLevel;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -14,6 +18,8 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Supplier;
 import static java.net.HttpURLConnection.HTTP_ACCEPTED;
 import static java.net.HttpURLConnection.HTTP_OK;
 import static java.nio.charset.StandardCharsets.UTF_8;
@@ -30,6 +36,11 @@ public class LambdaRuntimeApiClientImpl implements LambdaRuntimeApiClient {
     private static final String ERROR_TYPE_HEADER = "Lambda-Runtime-Function-Error-Type";
     // 1MiB
     private static final int XRAY_ERROR_CAUSE_MAX_HEADER_SIZE = 1024 * 1024;
+    
+    // ~32 Seconds Max Backoff.
+    private static final long MAX_BACKOFF_PERIOD_MS = 1024 * 32;
+    private static final long INITIAL_BACKOFF_PERIOD_MS = 100;
+    private static final int MAX_NUMBER_OF_RETRIALS = 5;
 
     private final String baseUrl;
     private final String invocationEndpoint;
@@ -52,6 +63,65 @@ public InvocationRequest nextInvocation() {
         return NativeClient.next();
     }
 
+    /*
+     * Retry immediately then retry with exponential backoff.
+     */
+    public static <T> T getSupplierResultWithExponentialBackoff(LambdaContextLogger lambdaLogger, long initialDelayMS, long maxBackoffPeriodMS, int maxNumOfAttempts, Supplier<T> supplier, Function<Exception, String> exceptionMessageComposer, Exception maxRetriesException) throws Exception {
+        long delayMS = initialDelayMS;
+        for (int attempts = 0; attempts < maxNumOfAttempts; attempts++) {
+            boolean isFirstAttempt = attempts == 0;
+            boolean isLastAttempt = (attempts + 1) == maxNumOfAttempts;
+
+            // Try and log whichever exceptions happened
+            try {
+                return supplier.get();
+            } catch (Exception e) {
+                String logMessage = exceptionMessageComposer.apply(e);
+                if (!isLastAttempt) {
+                    logMessage += String.format("\nRetrying%s", isFirstAttempt ? "." : String.format(" in %d ms.", delayMS));
+                }
+
+                lambdaLogger.log(logMessage, lambdaLogger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);   
+            }
+
+            // throw if ran out of attempts.
+            if (isLastAttempt) {
+                throw maxRetriesException;
+            }
+
+            // update the delay duration.
+            if (!isFirstAttempt) {
+                try {
+                    Thread.sleep(delayMS);
+                    delayMS = Math.min(delayMS * 2, maxBackoffPeriodMS);
+                } catch (InterruptedException e) { 
+                    Thread.interrupted();
+                }
+            }
+        }
+
+        // Should Not be reached.
+        throw new IllegalStateException();
+    }
+
+    @Override
+    public InvocationRequest nextInvocationWithExponentialBackoff(LambdaContextLogger lambdaLogger) throws Exception {
+        Supplier<InvocationRequest> nextInvocationSupplier = () -> nextInvocation();
+        Function<Exception, String> exceptionMessageComposer = (e) -> {
+            return String.format("Runtime Loop on Thread ID: %s Failed to fetch next invocation.\n%s", Thread.currentThread().getName(), UserFault.trace(e));
+        };
+
+        return getSupplierResultWithExponentialBackoff(
+            lambdaLogger, 
+            INITIAL_BACKOFF_PERIOD_MS, 
+            MAX_BACKOFF_PERIOD_MS, 
+            MAX_NUMBER_OF_RETRIALS, 
+            nextInvocationSupplier, 
+            exceptionMessageComposer, 
+            new LambdaRuntimeClientMaxRetriesExceededException("Get Next Invocation")
+            );
+    }
+
     @Override
     public void reportInvocationSuccess(String requestId, byte[] response) {
         NativeClient.postInvocationResponse(requestId.getBytes(UTF_8), response);
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeClientMaxRetriesExceededException.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeClientMaxRetriesExceededException.java
new file mode 100644
index 000000000..467afa25c
--- /dev/null
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeClientMaxRetriesExceededException.java
@@ -0,0 +1,15 @@
+/*
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
+
+public class LambdaRuntimeClientMaxRetriesExceededException extends LambdaRuntimeClientException {
+    // 429 is possible; however, that is more appropriate when a server is responding to a spamming client that it wants to rate limit. 
+    // In Our case, however, the RIC is a client that is not able to get a response from an upstream server, so 500 is more appropriate.
+    public LambdaRuntimeClientMaxRetriesExceededException(String operationName) {
+        super("Maximum Number of retries have been exceed" + (operationName.equals(null)
+                ? String.format(" for the %s operation.", operationName)
+                : "."), 500);
+    }
+}
diff --git a/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfig.java b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfig.java
new file mode 100644
index 000000000..a768e240e
--- /dev/null
+++ b/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfig.java
@@ -0,0 +1,50 @@
+/*
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package com.amazonaws.services.lambda.runtime.api.client.util;
+
+import com.amazonaws.services.lambda.runtime.api.client.ReservedRuntimeEnvironmentVariables;
+import com.amazonaws.services.lambda.runtime.api.client.UserFault;
+import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
+import com.amazonaws.services.lambda.runtime.logging.LogFormat;
+import com.amazonaws.services.lambda.runtime.logging.LogLevel;
+
+public class ConcurrencyConfig {
+    private final int numberOfPlatformThreads;
+    private final String INVALID_CONFIG_MESSAGE_PREFIX = String.format("User configured %s is invalid.", ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY);
+
+    public ConcurrencyConfig(LambdaContextLogger logger) {
+        this(logger, new EnvReader());
+    }
+
+    public ConcurrencyConfig(LambdaContextLogger logger, EnvReader envReader) {
+        int readNumOfPlatformThreads = 0;
+        try {
+            String readLambdaMaxConcurrencyEnvVar = envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY);
+
+            if (readLambdaMaxConcurrencyEnvVar != null) {
+                readNumOfPlatformThreads = Integer.parseInt(readLambdaMaxConcurrencyEnvVar);
+            }
+        } catch (Exception e) {
+            String message = String.format("%s\n%s", INVALID_CONFIG_MESSAGE_PREFIX, UserFault.trace(e));
+            logger.log(message, logger.getLogFormat() == LogFormat.JSON ? LogLevel.ERROR : LogLevel.UNDEFINED);
+            throw e;
+        }
+
+        this.numberOfPlatformThreads = readNumOfPlatformThreads;
+    }
+
+    public String getConcurrencyConfigMessage() {
+        return String.format("Starting %d concurrent function handler threads.", this.numberOfPlatformThreads);
+    }
+
+    public boolean isMultiConcurrent() {
+        return this.numberOfPlatformThreads >= 1;
+    }
+
+    public int getNumberOfPlatformThreads() {
+        return numberOfPlatformThreads;
+    }
+}
diff --git a/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/include/aws/lambda-runtime/runtime.h b/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/include/aws/lambda-runtime/runtime.h
index d7db5f183..c4868c1ba 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/include/aws/lambda-runtime/runtime.h
+++ b/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/include/aws/lambda-runtime/runtime.h
@@ -172,7 +172,6 @@ class runtime {
 private:
     std::string const m_user_agent_header;
     std::array<std::string const, 3> const m_endpoints;
-    CURL* const m_curl_handle;
 };
 
 inline std::chrono::milliseconds invocation_request::get_time_remaining() const
diff --git a/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/src/runtime.cpp b/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/src/runtime.cpp
index eeaf0e7b9..84a84b439 100644
--- a/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/src/runtime.cpp
+++ b/aws-lambda-java-runtime-interface-client/src/main/jni/deps/aws-lambda-cpp-0.2.7/src/runtime.cpp
@@ -41,6 +41,7 @@ static constexpr auto COGNITO_IDENTITY_HEADER = "lambda-runtime-cognito-identity
 static constexpr auto DEADLINE_MS_HEADER = "lambda-runtime-deadline-ms";
 static constexpr auto FUNCTION_ARN_HEADER = "lambda-runtime-invoked-function-arn";
 static constexpr auto TENANT_ID_HEADER = "lambda-runtime-aws-tenant-id";
+thread_local static CURL* m_curl_handle = curl_easy_init();
 
 enum Endpoints {
     INIT,
@@ -163,63 +164,62 @@ runtime::runtime(std::string const& endpoint) : runtime(endpoint, "AWS_Lambda_Cp
 runtime::runtime(std::string const& endpoint, std::string const& user_agent)
     : m_user_agent_header("User-Agent: " + user_agent), m_endpoints{{endpoint + "/2018-06-01/runtime/init/error",
                                                                      endpoint + "/2018-06-01/runtime/invocation/next",
-                                                                     endpoint + "/2018-06-01/runtime/invocation/"}},
-      m_curl_handle(curl_easy_init())
+                                                                     endpoint + "/2018-06-01/runtime/invocation/"}}
 {
-    if (!m_curl_handle) {
+    if (!lambda_runtime::m_curl_handle) {
         logging::log_error(LOG_TAG, "Failed to acquire curl easy handle for next.");
     }
 }
 
 runtime::~runtime()
 {
-    curl_easy_cleanup(m_curl_handle);
+    curl_easy_cleanup(lambda_runtime::m_curl_handle);
 }
 
 void runtime::set_curl_next_options()
 {
     // lambda freezes the container when no further tasks are available. The freezing period could be longer than the
     // request timeout, which causes the following get_next request to fail with a timeout error.
-    curl_easy_reset(m_curl_handle);
-    curl_easy_setopt(m_curl_handle, CURLOPT_TIMEOUT, 0L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_CONNECTTIMEOUT, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_NOSIGNAL, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_TCP_NODELAY, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
+    curl_easy_reset(lambda_runtime::m_curl_handle);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_TIMEOUT, 0L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_CONNECTTIMEOUT, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_NOSIGNAL, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_TCP_NODELAY, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
 
-    curl_easy_setopt(m_curl_handle, CURLOPT_HTTPGET, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_URL, m_endpoints[Endpoints::NEXT].c_str());
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HTTPGET, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_URL, m_endpoints[Endpoints::NEXT].c_str());
 
-    curl_easy_setopt(m_curl_handle, CURLOPT_WRITEFUNCTION, write_data);
-    curl_easy_setopt(m_curl_handle, CURLOPT_HEADERFUNCTION, write_header);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_WRITEFUNCTION, write_data);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HEADERFUNCTION, write_header);
 
-    curl_easy_setopt(m_curl_handle, CURLOPT_PROXY, "");
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_PROXY, "");
 
 #ifndef NDEBUG
-    curl_easy_setopt(m_curl_handle, CURLOPT_VERBOSE, 1);
-    curl_easy_setopt(m_curl_handle, CURLOPT_DEBUGFUNCTION, rt_curl_debug_callback);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_VERBOSE, 1);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_DEBUGFUNCTION, rt_curl_debug_callback);
 #endif
 }
 
 void runtime::set_curl_post_result_options()
 {
-    curl_easy_reset(m_curl_handle);
-    curl_easy_setopt(m_curl_handle, CURLOPT_TIMEOUT, 0L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_CONNECTTIMEOUT, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_NOSIGNAL, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_TCP_NODELAY, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
+    curl_easy_reset(lambda_runtime::m_curl_handle);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_TIMEOUT, 0L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_CONNECTTIMEOUT, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_NOSIGNAL, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_TCP_NODELAY, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
 
-    curl_easy_setopt(m_curl_handle, CURLOPT_POST, 1L);
-    curl_easy_setopt(m_curl_handle, CURLOPT_READFUNCTION, read_data);
-    curl_easy_setopt(m_curl_handle, CURLOPT_WRITEFUNCTION, write_data);
-    curl_easy_setopt(m_curl_handle, CURLOPT_HEADERFUNCTION, write_header);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_POST, 1L);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_READFUNCTION, read_data);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_WRITEFUNCTION, write_data);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HEADERFUNCTION, write_header);
 
-    curl_easy_setopt(m_curl_handle, CURLOPT_PROXY, "");
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_PROXY, "");
 
 #ifndef NDEBUG
-    curl_easy_setopt(m_curl_handle, CURLOPT_VERBOSE, 1);
-    curl_easy_setopt(m_curl_handle, CURLOPT_DEBUGFUNCTION, rt_curl_debug_callback);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_VERBOSE, 1);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_DEBUGFUNCTION, rt_curl_debug_callback);
 #endif
 }
 
@@ -227,15 +227,15 @@ runtime::next_outcome runtime::get_next()
 {
     http::response resp;
     set_curl_next_options();
-    curl_easy_setopt(m_curl_handle, CURLOPT_WRITEDATA, &resp);
-    curl_easy_setopt(m_curl_handle, CURLOPT_HEADERDATA, &resp);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_WRITEDATA, &resp);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HEADERDATA, &resp);
 
     curl_slist* headers = nullptr;
     headers = curl_slist_append(headers, m_user_agent_header.c_str());
-    curl_easy_setopt(m_curl_handle, CURLOPT_HTTPHEADER, headers);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HTTPHEADER, headers);
 
     logging::log_debug(LOG_TAG, "Making request to %s", m_endpoints[Endpoints::NEXT].c_str());
-    CURLcode curl_code = curl_easy_perform(m_curl_handle);
+    CURLcode curl_code = curl_easy_perform(lambda_runtime::m_curl_handle);
     logging::log_debug(LOG_TAG, "Completed request to %s", m_endpoints[Endpoints::NEXT].c_str());
     curl_slist_free_all(headers);
 
@@ -247,13 +247,13 @@ runtime::next_outcome runtime::get_next()
 
     {
         long resp_code;
-        curl_easy_getinfo(m_curl_handle, CURLINFO_RESPONSE_CODE, &resp_code);
+        curl_easy_getinfo(lambda_runtime::m_curl_handle, CURLINFO_RESPONSE_CODE, &resp_code);
         resp.set_response_code(static_cast<aws::http::response_code>(resp_code));
     }
 
     {
         char* content_type = nullptr;
-        curl_easy_getinfo(m_curl_handle, CURLINFO_CONTENT_TYPE, &content_type);
+        curl_easy_getinfo(lambda_runtime::m_curl_handle, CURLINFO_CONTENT_TYPE, &content_type);
         resp.set_content_type(content_type);
     }
 
@@ -327,7 +327,7 @@ runtime::post_outcome runtime::do_post(
     invocation_response const& handler_response)
 {
     set_curl_post_result_options();
-    curl_easy_setopt(m_curl_handle, CURLOPT_URL, url.c_str());
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_URL, url.c_str());
     logging::log_info(LOG_TAG, "Making request to %s", url.c_str());
 
     curl_slist* headers = nullptr;
@@ -348,11 +348,11 @@ runtime::post_outcome runtime::do_post(
 
     std::pair<std::string const&, size_t> ctx{payload, 0};
     aws::http::response resp;
-    curl_easy_setopt(m_curl_handle, CURLOPT_WRITEDATA, &resp);
-    curl_easy_setopt(m_curl_handle, CURLOPT_HEADERDATA, &resp);
-    curl_easy_setopt(m_curl_handle, CURLOPT_READDATA, &ctx);
-    curl_easy_setopt(m_curl_handle, CURLOPT_HTTPHEADER, headers);
-    CURLcode curl_code = curl_easy_perform(m_curl_handle);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_WRITEDATA, &resp);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HEADERDATA, &resp);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_READDATA, &ctx);
+    curl_easy_setopt(lambda_runtime::m_curl_handle, CURLOPT_HTTPHEADER, headers);
+    CURLcode curl_code = curl_easy_perform(lambda_runtime::m_curl_handle);
     curl_slist_free_all(headers);
 
     if (curl_code != CURLE_OK) {
@@ -366,11 +366,11 @@ runtime::post_outcome runtime::do_post(
     }
 
     long http_response_code;
-    curl_easy_getinfo(m_curl_handle, CURLINFO_RESPONSE_CODE, &http_response_code);
+    curl_easy_getinfo(lambda_runtime::m_curl_handle, CURLINFO_RESPONSE_CODE, &http_response_code);
 
     if (!is_success(aws::http::response_code(http_response_code))) {
         logging::log_error(
-            LOG_TAG, "Failed to post handler success response. Http response code: %ld.", http_response_code);
+            LOG_TAG, "Failed to post handler success response. Http response code: %ld. %s", http_response_code, resp.get_body().c_str());
         return aws::http::response_code(http_response_code);
     }
 
diff --git a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambdaTest.java b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambdaTest.java
new file mode 100644
index 000000000..49b59c2cd
--- /dev/null
+++ b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambdaTest.java
@@ -0,0 +1,578 @@
+/*
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package com.amazonaws.services.lambda.runtime.api.client;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOError;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.LambdaRuntimeApiClientImpl;
+import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.LambdaRuntimeClientMaxRetriesExceededException;
+import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.dto.InvocationRequest;
+import com.amazonaws.services.lambda.runtime.api.client.util.ConcurrencyConfig;
+import com.amazonaws.services.lambda.runtime.api.client.util.EnvReader;
+import com.amazonaws.services.lambda.runtime.Context;
+import com.amazonaws.services.lambda.runtime.RequestHandler;
+import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
+import com.amazonaws.services.lambda.runtime.logging.LogFormat;
+import com.amazonaws.services.lambda.runtime.logging.LogLevel;
+import software.amazon.awssdk.utilslite.SdkInternalThreadLocal;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+class AWSLambdaTest {
+
+    private static final String CONCURRENT_TRACE_ID_KEY = "AWS_LAMBDA_X_TRACE_ID";
+
+    private static class SampleHandler implements RequestHandler<Map<String, String>, String> {
+        public static final String ADD_ENTRY_TO_MAP_ID_OP_MODE = "ADD_ENTRY_TO_MAP_ID";
+        public static final String FAIL_IMMEDIATELY_OP_MODE = "FAIL_IMMEDIATELY";
+
+        public static final int nOfIterations = 10;
+        public static final int perIterationDelayMS = 10;
+        public static Map<String, Integer> hashMap = new ConcurrentHashMap<String, Integer>();
+        public static AtomicInteger globalCounter = new AtomicInteger();
+
+        public static void resetStaticFields() {
+            hashMap.clear();
+            globalCounter = new AtomicInteger();
+        }
+
+        private static void addEntryToMapImplementation(String name) {
+            int i = 0;
+            while (i++ < nOfIterations) {
+                hashMap.put(name, hashMap.getOrDefault(name, 0) + 1);
+                globalCounter.incrementAndGet();
+                try {
+                    Thread.sleep(perIterationDelayMS);
+                } catch (InterruptedException e) {
+                }
+            }
+        }
+
+        @Override
+        public String handleRequest(Map<String, String> event, Context context) {
+            // Thread.currentThread().getId() instead of Thread.currentThread().getName() when upgrading JAVA
+            String name = "Thread " + Thread.currentThread().getName();
+            String opMode = event.get("id");
+
+            switch (opMode) {
+                case ADD_ENTRY_TO_MAP_ID_OP_MODE:
+                    addEntryToMapImplementation(name);
+                    break;
+                case FAIL_IMMEDIATELY_OP_MODE:
+                    String[] sArr = {};
+                    return sArr[1];
+                default:
+                    break;
+            }
+
+            return name;
+        }
+    }
+
+    // Handler for testing SdkInternalThreadLocal trace ID functionality in concurrent scenarios
+    private static class SdkInternalThreadLocalTraceIdHandler implements RequestHandler<Map<String, String>, String> {
+        public static final String CAPTURE_TRACE_ID_OP_MODE = "CAPTURE_TRACE_ID";
+        public static final int nOfIterations = 5;
+        public static final int perIterationDelayMS = 20;
+        public static CountDownLatch cdl = new CountDownLatch(1);
+        public static CountDownLatch readyLatch = null;
+        
+        public static Map<String, String> capturedTraceIds = new ConcurrentHashMap<>();
+
+        public static void resetStaticFields() {
+            capturedTraceIds.clear();
+            cdl = new CountDownLatch(1);
+            readyLatch = null;
+        }
+
+        @Override
+        public String handleRequest(Map<String, String> event, Context context) {
+            readyLatch.countDown();
+            try {
+                cdl.await();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+
+            String threadName = Thread.currentThread().getName();
+            String opMode = event.get("id");
+            
+            if (CAPTURE_TRACE_ID_OP_MODE.equals(opMode)) {
+                // Capture the SdkInternalThreadLocal trace ID for this thread
+                String traceId = SdkInternalThreadLocal.get(CONCURRENT_TRACE_ID_KEY);
+                if (traceId != null) {
+                    capturedTraceIds.put(threadName, traceId);
+                }
+                
+                // Simulate some work with delays to ensure concurrent execution
+                for (int i = 0; i < nOfIterations; i++) {
+                    try {
+                        Thread.sleep(perIterationDelayMS);
+                        // Re-check SdkInternalThreadLocal during processing to ensure it's consistent
+                        String currentTraceId = SdkInternalThreadLocal.get(CONCURRENT_TRACE_ID_KEY);
+                        if (currentTraceId != null && !currentTraceId.equals(traceId)) {
+                            throw new RuntimeException("SdkInternalThreadLocal trace ID changed during processing!");
+                        }
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        break;
+                    }
+                }
+            }
+            
+            return threadName;
+        }
+    }
+
+    @Mock
+    private LambdaRuntimeApiClientImpl runtimeClient;
+
+    @Mock
+    private LambdaContextLogger lambdaLogger;
+ 
+    @Mock
+    private EnvReader envReader;
+    
+    @Mock
+    private ConcurrencyConfig concurrencyConfig;
+
+    private LambdaRequestHandler lambdaRequestHandler = new LambdaRequestHandler() {
+        private SampleHandler sHandler = new SampleHandler();
+
+        @Override
+        public ByteArrayOutputStream call(InvocationRequest request) throws Error, Exception {
+            HashMap<String, String> eventMap = new HashMap<String,String>();
+            eventMap.put("id", request.getId());
+            String outStr = sHandler.handleRequest(eventMap, null);
+            ByteArrayOutputStream output = new ByteArrayOutputStream();
+            output.write(outStr.getBytes());
+            return output;
+        }
+    };
+
+    private LambdaRequestHandler SdkInternalThreadLocalRequestHandler = new LambdaRequestHandler() {
+        private SdkInternalThreadLocalTraceIdHandler SdkInternalThreadLocalHandler = new SdkInternalThreadLocalTraceIdHandler();
+
+        @Override
+        public ByteArrayOutputStream call(InvocationRequest request) throws Error, Exception {
+            HashMap<String, String> eventMap = new HashMap<>();
+            eventMap.put("id", request.getId());
+            String outStr = SdkInternalThreadLocalHandler.handleRequest(eventMap, null);
+            ByteArrayOutputStream output = new ByteArrayOutputStream();
+            output.write(outStr.getBytes());
+            return output;
+        }
+    };
+
+    private static InvocationRequest getFakeInvocationRequest(String id) {
+        InvocationRequest request = new InvocationRequest();
+        request.setId(id);
+        request.setDeadlineTimeInMs(Long.MAX_VALUE);
+        request.setContent("".getBytes());
+        return request;
+    }
+
+    private static InvocationRequest getFakeInvocationRequest(String id, String traceId) {
+        InvocationRequest request = getFakeInvocationRequest(id);
+        request.setXrayTraceId(traceId);
+        return request;
+    }
+
+    private static final LambdaRuntimeClientMaxRetriesExceededException fakelambdaRuntimeClientMaxRetriesExceededException = new LambdaRuntimeClientMaxRetriesExceededException("Fake max retries happened");
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        SampleHandler.resetStaticFields();
+    }
+
+    /*
+     * com.amazonaws.services.lambda.runtime.api.client.util.SampleHandler contains static fields. These fields are expected to be shared if initialization is behaving as expected.
+     * After execution of the Runtime loops, we should see that the SampleHandler.globalCounter has been acted on by all the threads.
+     * The concurrent hashmap in SampleHandler.hashMap should also have all the correct count of Threads that ran.
+     * IMPORTANT: This test fails through only timeout.
+     */
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testConcurrentRunWithPlatformThreads() throws Throwable {
+        when(concurrencyConfig.isMultiConcurrent()).thenReturn(true);
+        when(concurrencyConfig.getNumberOfPlatformThreads()).thenReturn(4);
+
+        InvocationRequest successfullInvocationRequest = getFakeInvocationRequest(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE);
+
+        when(runtimeClient.nextInvocationWithExponentialBackoff(lambdaLogger))
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException);
+
+        AWSLambda.startRuntimeLoops(lambdaRequestHandler, lambdaLogger, concurrencyConfig, runtimeClient);
+
+        // Success Reports Must Equal number of tasks that ran successfully.
+        verify(runtimeClient, times(7)).reportInvocationSuccess(eq(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE), any());
+        // Hashmap keys should equal the number of threads (runtime loops).
+        assertEquals(4, SampleHandler.hashMap.size());
+        // Hashmap total count should equal all tasks that ran * number of iterations per task
+        assertEquals(7 * SampleHandler.nOfIterations, SampleHandler.globalCounter.get());
+    }
+ 
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testConcurrentRunWithPlatformThreadsWithFailures() throws Throwable {
+        when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
+        when(concurrencyConfig.isMultiConcurrent()).thenReturn(true);
+        when(concurrencyConfig.getNumberOfPlatformThreads()).thenReturn(4);
+
+        InvocationRequest successfullInvocationRequest = getFakeInvocationRequest(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE);
+        InvocationRequest failImmediatelyRequest = getFakeInvocationRequest(SampleHandler.FAIL_IMMEDIATELY_OP_MODE);
+        InvocationRequest userFaultRequest = mock(InvocationRequest.class);
+        final String UserFaultID = "Injected Fault Request ID";
+        when(userFaultRequest.getId()).thenThrow(UserFault.makeUserFault(new Exception("OH NO"), true)).thenReturn(UserFaultID);
+
+        when(runtimeClient.nextInvocationWithExponentialBackoff(lambdaLogger))
+        .thenReturn(failImmediatelyRequest)
+        .thenReturn(userFaultRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException);
+
+        AWSLambda.startRuntimeLoops(lambdaRequestHandler, lambdaLogger, concurrencyConfig, runtimeClient);
+
+        // One for each of failImmediatelyRequest and userFaultRequest in finally block 
+        // Four for crashing the Four runtime loops in the outermost catch of the runtime loop after the Null responses.
+        // 2 + 4 = 6
+        verify(lambdaLogger, times(6)).log(anyString(), eq(LogLevel.ERROR));
+
+        // Failed invokes should be reported.
+        verify(runtimeClient).reportInvocationError(eq(SampleHandler.FAIL_IMMEDIATELY_OP_MODE), any());
+        verify(runtimeClient).reportInvocationError(eq(UserFaultID), any());
+        
+        // Success Reports Must Equal number of tasks that ran successfully.
+        verify(runtimeClient, times(2)).reportInvocationSuccess(eq(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE), any());
+        
+        // Hashmap keys should equal the minumum between(number of threads (runtime loops) AND number of tasks that ran successfully).
+        assertEquals(2, SampleHandler.hashMap.size());
+        
+        // Hashmap total count should equal all tasks that ran * number of iterations per task
+        assertEquals(2 * SampleHandler.nOfIterations, SampleHandler.globalCounter.get());
+    }
+
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testConcurrentModeLoopDoesNotExitExceptForLambdaRuntimeClientMaxRetriesExceededException() throws Throwable {
+        when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
+        when(concurrencyConfig.isMultiConcurrent()).thenReturn(true);
+        when(concurrencyConfig.getNumberOfPlatformThreads()).thenReturn(1);
+
+        InvocationRequest successfullInvocationRequest = getFakeInvocationRequest(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE);
+        InvocationRequest failImmediatelyRequest = getFakeInvocationRequest(SampleHandler.FAIL_IMMEDIATELY_OP_MODE);
+
+        InvocationRequest userFaultRequest = mock(InvocationRequest.class); // unrecoverable in sequential but recoverable in multiconcurrent mode.
+        final String UserFaultID = "Injected Fault Request ID";
+        when(userFaultRequest.getId()).thenThrow(UserFault.makeUserFault(new Exception("OH NO"), true)).thenReturn(UserFaultID);
+        
+        InvocationRequest virtualMachineErrorRequest = mock(InvocationRequest.class); // unrecoverable in sequential but recoverable in multiconcurrent mode.
+        final String IOErrorID = "ioerr1";
+        when(virtualMachineErrorRequest.getId()).thenThrow(UserFault.makeUserFault(new IOError(new Throwable()), true)).thenReturn(IOErrorID);
+
+        when(runtimeClient.nextInvocationWithExponentialBackoff(lambdaLogger))
+        .thenReturn(failImmediatelyRequest)
+        .thenReturn(userFaultRequest)
+        .thenReturn(virtualMachineErrorRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException)
+        .thenReturn(successfullInvocationRequest);
+
+        AWSLambda.startRuntimeLoops(lambdaRequestHandler, lambdaLogger, concurrencyConfig, runtimeClient);
+         
+         // One for each of failImmediatelyRequest, userFaultRequest, and virtualMachineErrorRequest + One for the runtime loop thread crashing.
+         verify(lambdaLogger, times(4)).log(anyString(), eq(LogLevel.ERROR));
+         
+         // Failed invokes should be reported.
+         verify(runtimeClient).reportInvocationError(eq(SampleHandler.FAIL_IMMEDIATELY_OP_MODE), any());
+         verify(runtimeClient).reportInvocationError(eq(UserFaultID), any());
+         verify(runtimeClient).reportInvocationError(eq(IOErrorID), any());
+         
+         // Success Reports Must Equal number of tasks that ran successfully.
+         verify(runtimeClient, times(2)).reportInvocationSuccess(eq(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE), any());
+         
+         // Hashmap keys should equal the minumum between(number of threads (runtime loops) AND number of tasks that ran successfully).
+         assertEquals(1, SampleHandler.hashMap.size());
+         
+         // Hashmap total count should equal all tasks that ran * number of iterations per task
+         assertEquals(2 * SampleHandler.nOfIterations, SampleHandler.globalCounter.get());
+    }
+  
+    /*
+     * 
+     * SdkInternalThreadLocal XRAY TRACE ID TESTS
+     * 
+     */
+
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testSdkInternalThreadLocalTraceIdIsInheritable() throws Throwable {
+        ExecutorService parentExecutorPool = Executors.newFixedThreadPool(1000);
+        CountDownLatch cdl = new CountDownLatch(1000);
+        CountDownLatch childCdl = new CountDownLatch(1000);
+        AtomicReference<Throwable> error = new AtomicReference<>();
+        
+        for (int i = 0; i < 1000; i++) {
+            final int threadIndex = i;
+            parentExecutorPool.submit(() -> {
+                try {
+                    String traceValue = "Val from parent thread" + threadIndex;
+                    SdkInternalThreadLocal.put(CONCURRENT_TRACE_ID_KEY, traceValue);
+                    
+                    cdl.countDown();
+                    cdl.await();
+
+                    assertEquals(SdkInternalThreadLocal.get(CONCURRENT_TRACE_ID_KEY), traceValue);
+
+                    ExecutorService internalExecutorPool = Executors.newFixedThreadPool(2);
+                    internalExecutorPool.submit(() -> {
+                        try {
+                            assertEquals(SdkInternalThreadLocal.get(CONCURRENT_TRACE_ID_KEY), traceValue);
+                        } catch (Throwable t) {
+                            error.set(t);
+                        } finally {
+                            childCdl.countDown();
+                        }
+                    });
+                } catch (Throwable t) {
+                    error.set(t);
+                    childCdl.countDown();
+                }
+            });
+        }
+
+        childCdl.await();
+        if (error.get() != null) {
+            throw error.get();
+        }
+        assertEquals(SdkInternalThreadLocal.get(CONCURRENT_TRACE_ID_KEY), null);
+    }
+    
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testSdkInternalThreadLocalTraceIdIsCleared() throws Throwable {
+        when(concurrencyConfig.isMultiConcurrent()).thenReturn(true);
+        when(concurrencyConfig.getNumberOfPlatformThreads()).thenReturn(1);
+
+        InvocationRequest requestWithTrace = getFakeInvocationRequest("req_with_traceID", "test-trace-123");
+        InvocationRequest requestWithNoTrace = getFakeInvocationRequest("req_without_traceID");
+        
+        when(runtimeClient.nextInvocationWithExponentialBackoff(any()))
+            .thenReturn(requestWithTrace)
+            .thenReturn(requestWithNoTrace)
+            .thenThrow(fakelambdaRuntimeClientMaxRetriesExceededException);
+
+        AtomicReference<Throwable> error = new AtomicReference<>();
+        LambdaRequestHandler traceCheckingHandler = new LambdaRequestHandler() {
+            @Override
+            public ByteArrayOutputStream call(InvocationRequest request) throws Error, Exception {
+                try {
+                    if (request.getId().equals("req_without_traceID")) {
+                        assertEquals(null, SdkInternalThreadLocal.get(CONCURRENT_TRACE_ID_KEY));
+                    }
+                    else {
+                        assertEquals("test-trace-123", SdkInternalThreadLocal.get(CONCURRENT_TRACE_ID_KEY));
+                    }
+                } catch (Throwable t) {
+                    error.set(t);
+                }
+
+                return new ByteArrayOutputStream();
+            }
+        };
+
+        AWSLambda.startRuntimeLoops(traceCheckingHandler, lambdaLogger, concurrencyConfig, runtimeClient);
+        
+        if (error.get() != null) {
+            throw error.get();
+        }
+    }
+
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testSdkInternalThreadLocalTraceIdInConcurrentMode() throws Throwable {
+        SdkInternalThreadLocalTraceIdHandler.resetStaticFields();
+
+        // Create invocation requests with different trace IDs
+        int numOfThreads = 1000;
+        HashSet<String> traceIds = new HashSet<>();
+        ArrayList<InvocationRequest> requests = new ArrayList<>();
+        for (int i = 0; i < numOfThreads - 1; i++) {
+            String randTId = java.util.UUID.randomUUID().toString();
+            traceIds.add(randTId);
+            requests.add(getFakeInvocationRequest(SdkInternalThreadLocalTraceIdHandler.CAPTURE_TRACE_ID_OP_MODE, randTId));
+        }
+
+        // Test Nulls as well.
+        requests.add(getFakeInvocationRequest(SdkInternalThreadLocalTraceIdHandler.CAPTURE_TRACE_ID_OP_MODE, null));
+        
+        when(concurrencyConfig.isMultiConcurrent()).thenReturn(true);
+        when(concurrencyConfig.getNumberOfPlatformThreads()).thenReturn(numOfThreads);
+        AtomicInteger iAtomic = new AtomicInteger();
+        when(runtimeClient.nextInvocationWithExponentialBackoff(lambdaLogger))
+                .thenAnswer((o) -> {
+                    if (iAtomic.get() < numOfThreads) {
+                        return requests.get(iAtomic.getAndIncrement());
+                    } else {
+                        throw fakelambdaRuntimeClientMaxRetriesExceededException;
+                    }
+                });
+
+        Thread thread = new Thread(() -> { try {
+            AWSLambda.startRuntimeLoops(SdkInternalThreadLocalRequestHandler, lambdaLogger, concurrencyConfig, runtimeClient);
+        } catch (Exception e) {
+        } });
+
+        SdkInternalThreadLocalTraceIdHandler.readyLatch = new CountDownLatch(numOfThreads);
+        thread.start();
+        SdkInternalThreadLocalTraceIdHandler.readyLatch.await();
+        SdkInternalThreadLocalTraceIdHandler.cdl.countDown();
+        thread.join();
+        
+        for (String traceId : SdkInternalThreadLocalTraceIdHandler.capturedTraceIds.values()) {
+            traceIds.remove(traceId);
+        }
+
+        assertTrue(traceIds.isEmpty());
+    }
+    
+    /*
+     * 
+     * NON-CONCURRENT-MODE TESTS
+     * 
+     */
+
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testSequentialWithFatalUserFaultErrorStopsLoop() throws Throwable {
+        when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
+        when(concurrencyConfig.isMultiConcurrent()).thenReturn(false);
+
+        InvocationRequest successfullInvocationRequest = getFakeInvocationRequest(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE);
+        InvocationRequest failImmediatelyRequest = getFakeInvocationRequest(SampleHandler.FAIL_IMMEDIATELY_OP_MODE); // recoverable error in all modes.
+        
+        InvocationRequest userFaultRequest = mock(InvocationRequest.class); // unrecoverable in sequential but recoverable in multiconcurrent mode.
+        final String UserFaultID = "Injected Fault Request ID";
+        when(userFaultRequest.getId()).thenThrow(UserFault.makeUserFault(new Exception("OH NO"), true)).thenReturn(UserFaultID);
+        
+        InvocationRequest virtualMachineErrorRequest = mock(InvocationRequest.class); // unrecoverable in sequential but recoverable in multiconcurrent mode.
+        final String IOErrorID = "ioerr1";
+        when(virtualMachineErrorRequest.getId()).thenThrow(UserFault.makeUserFault(new IOError(new Throwable()), true)).thenReturn(IOErrorID);
+
+        when(runtimeClient.nextInvocation())
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(failImmediatelyRequest)
+        .thenReturn(userFaultRequest)
+        // these two should not be even feltched since userFaultRequest is not recoverable.
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(virtualMachineErrorRequest);
+
+        AWSLambda.startRuntimeLoops(lambdaRequestHandler, lambdaLogger, concurrencyConfig, runtimeClient);
+
+        // One for failImmediatelyRequest and userFaultRequest in finally block.
+        verify(lambdaLogger, times(2)).log(anyString(), eq(LogLevel.ERROR));
+        
+        // Failed invokes should be reported.
+        verify(runtimeClient).reportInvocationError(eq(SampleHandler.FAIL_IMMEDIATELY_OP_MODE), any());
+        verify(runtimeClient).reportInvocationError(eq(UserFaultID), any());
+        
+        // Success Reports Must Equal number of tasks that ran successfully. And only 2 Error reports for failImmediatelyRequest and userFaultRequest.
+        verify(runtimeClient, times(2)).reportInvocationSuccess(eq(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE), any());
+        verify(runtimeClient, times(2)).reportInvocationError(any(), any());
+        
+        // Hashmap keys should equal one as it is not multithreaded.
+        assertEquals(1, SampleHandler.hashMap.size());
+        
+        // Hashmap total count should equal all tasks that ran * number of iterations per task
+        assertEquals(2 * SampleHandler.nOfIterations, SampleHandler.globalCounter.get());
+    }
+
+    @Test
+    @Timeout(value = 1, unit = TimeUnit.MINUTES)
+    void testSequentialWithVirtualMachineErrorStopsLoop() throws Throwable {
+        when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
+        when(concurrencyConfig.isMultiConcurrent()).thenReturn(false);
+
+        InvocationRequest successfullInvocationRequest = getFakeInvocationRequest(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE);
+        InvocationRequest failImmediatelyRequest = getFakeInvocationRequest(SampleHandler.FAIL_IMMEDIATELY_OP_MODE); // recoverable error in all modes.
+        
+        InvocationRequest userFaultRequest = mock(InvocationRequest.class); // unrecoverable in sequential but recoverable in multiconcurrent mode.
+        final String UserFaultID = "Injected Fault Request ID";
+        when(userFaultRequest.getId()).thenThrow(UserFault.makeUserFault(new Exception("OH NO"), true)).thenReturn(UserFaultID);
+        
+        InvocationRequest virtualMachineErrorRequest = mock(InvocationRequest.class); // unrecoverable in sequential but recoverable in multiconcurrent mode.
+        final String IOErrorID = "ioerr1";
+        when(virtualMachineErrorRequest.getId()).thenThrow(UserFault.makeUserFault(new IOError(new Throwable()), true)).thenReturn(IOErrorID);
+
+        when(runtimeClient.nextInvocation())
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(failImmediatelyRequest)
+        .thenReturn(virtualMachineErrorRequest)
+        // these two should not be even feltched since userFaultRequest is not recoverable.
+        .thenReturn(successfullInvocationRequest)
+        .thenReturn(userFaultRequest);
+
+        AWSLambda.startRuntimeLoops(lambdaRequestHandler, lambdaLogger, concurrencyConfig, runtimeClient);
+
+        // One for failImmediatelyRequest and userFaultRequest in finally block.
+        verify(lambdaLogger, times(2)).log(anyString(), eq(LogLevel.ERROR));
+        
+        // Failed invokes should be reported.
+        verify(runtimeClient).reportInvocationError(eq(SampleHandler.FAIL_IMMEDIATELY_OP_MODE), any());
+        verify(runtimeClient).reportInvocationError(eq(IOErrorID), any());
+        
+        // Success Reports Must Equal number of tasks that ran successfully. And only 2 Error reports for failImmediatelyRequest and virtualMachineErrorRequest.
+        verify(runtimeClient, times(2)).reportInvocationSuccess(eq(SampleHandler.ADD_ENTRY_TO_MAP_ID_OP_MODE), any());
+        verify(runtimeClient, times(2)).reportInvocationError(any(), any());
+        
+        // Hashmap keys should equal one as it is not multithreaded.
+        assertEquals(1, SampleHandler.hashMap.size());
+        
+        // Hashmap total count should equal all tasks that ran * number of iterations per task
+        assertEquals(2 * SampleHandler.nOfIterations, SampleHandler.globalCounter.get());
+    }
+}
\ No newline at end of file
diff --git a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoaderTest.java b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoaderTest.java
index 76e6f0249..aae2f1afe 100644
--- a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoaderTest.java
+++ b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoaderTest.java
@@ -4,8 +4,16 @@
 import org.junit.jupiter.api.Test;
 
 import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class EventHandlerLoaderTest {
 
@@ -37,7 +45,6 @@ void PojoHandlerTest_oneParamEvent() throws Exception {
         assertSuccessfulInvocation(lambdaRequestHandler);
     }
 
-
     @Test
     void PojoHandlerTest_oneParamContext() throws Exception {
         String handler = "test.lambda.handlers.POJOHanlderImpl::oneParamHandler_context";
@@ -74,4 +81,72 @@ private static InvocationRequest getTestInvocationRequest() {
         invocationRequest.setXrayTraceId("traceId");
         return invocationRequest;
     }
-}
\ No newline at end of file
+
+    // Multithreaded test methods
+
+    @Test
+    void RequestHandlerTest_Multithreaded() throws Exception {
+        testHandlerConcurrency("test.lambda.handlers.RequestHandlerImpl");
+    }
+
+    @Test
+    void RequestStreamHandlerTest_Multithreaded() throws Exception {
+        testHandlerConcurrency("test.lambda.handlers.RequestStreamHandlerImpl");
+    }
+
+    @Test
+    void PojoHandlerTest_noParams_Multithreaded() throws Exception {
+        testHandlerConcurrency("test.lambda.handlers.POJOHanlderImpl::noParamsHandler");
+    }
+
+    @Test
+    void PojoHandlerTest_oneParamEvent_Multithreaded() throws Exception {
+        testHandlerConcurrency("test.lambda.handlers.POJOHanlderImpl::oneParamHandler_event");
+    }
+
+    @Test
+    void PojoHandlerTest_oneParamContext_Multithreaded() throws Exception {
+        testHandlerConcurrency("test.lambda.handlers.POJOHanlderImpl::oneParamHandler_context");
+    }
+
+    @Test
+    void PojoHandlerTest_twoParams_Multithreaded() throws Exception {
+        testHandlerConcurrency("test.lambda.handlers.POJOHanlderImpl::twoParamsHandler");
+    }
+
+    private void testHandlerConcurrency(String handlerName) throws Exception {
+        // Create one handler instance
+        LambdaRequestHandler handler = getLambdaRequestHandler(handlerName);
+        
+        int threadCount = 10;
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        List<Future<String>> futures = new ArrayList<>();
+        CountDownLatch startLatch = new CountDownLatch(1);
+        
+        try {
+            for (int i = 0; i < threadCount; i++) {
+                futures.add(executor.submit(() -> {
+                    try {
+                        InvocationRequest request = getTestInvocationRequest();
+                        startLatch.await();
+                        ByteArrayOutputStream result = handler.call(request);
+                        return result.toString();
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                }));
+            }
+            
+            // Release all threads simultaneously and Verify all invocations return the expected result
+            startLatch.countDown();
+            
+            for (Future<String> future : futures) {
+                String result = future.get(5, TimeUnit.SECONDS);
+                assertEquals("\"success\"", result);
+            }
+        } finally {
+            executor.shutdown();
+            assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS));
+        }
+    }
+}
diff --git a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoaderTest.java b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoaderTest.java
index c2c887973..4ebcf5d7e 100644
--- a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoaderTest.java
+++ b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoaderTest.java
@@ -7,8 +7,8 @@
 
 import com.amazonaws.services.lambda.runtime.CustomPojoSerializer;
 import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
diff --git a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/AbstractLambdaLoggerTest.java b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/AbstractLambdaLoggerTest.java
index baeb4c242..3a5ee8d5f 100644
--- a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/AbstractLambdaLoggerTest.java
+++ b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/AbstractLambdaLoggerTest.java
@@ -5,10 +5,15 @@
 import com.amazonaws.services.lambda.runtime.logging.LogFormat;
 import org.junit.jupiter.api.Test;
 
+import java.nio.charset.StandardCharsets;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
+import com.amazonaws.lambda.thirdparty.org.json.JSONObject;
 import com.amazonaws.services.lambda.runtime.LambdaLogger;
+import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
 import com.amazonaws.services.lambda.runtime.logging.LogLevel;
 
 
@@ -20,12 +25,12 @@ public TestSink() {
         }
 
         @Override
-        public void log(byte[] message) {
+        public synchronized void log(byte[] message) {
             messages.add(message);
         }
 
         @Override
-        public void log(LogLevel logLevel, LogFormat logFormat, byte[] message) {
+        public synchronized void log(LogLevel logLevel, LogFormat logFormat, byte[] message) {
             messages.add(message);
         }
 
@@ -62,6 +67,45 @@ public void testLoggingNullValuesWithoutLogLevelInText() {
         assertEquals("null", new String(sink.getMessages().get(1)));
     }
 
+    /*
+     * Makes Sure Logging Contexts are thread local. 
+     * We start `setLambdaContext` operations using the **single** shared `logger` object on a fixed thread pool, differentiating them with thread IDs.
+     * We then start concurrent `log` operations which are scheduled using that fixed pool.
+     * It is then verified that a given log operation, which logs the thread ID it is running on, used a context that had the same thread ID. 
+     */
+    @Test
+    public void testMultiConcurrentLoggingWithoutLogLevelInJSON() {
+        TestSink sink = new TestSink();
+        LambdaContextLogger logger = new LambdaContextLogger(sink, LogLevel.INFO, LogFormat.JSON);
+
+        String someMessagePrefix = "Some Message from ";
+        String reqIDPrefix = "Thread ID as request# ";
+
+        final int nThreads = 5;
+        ExecutorService es = Executors.newFixedThreadPool(nThreads);
+        for (int i = 0; i < nThreads; i++) {
+            es.submit(() -> logger.setLambdaContext(new LambdaContext(Integer.MAX_VALUE, Long.MAX_VALUE, reqIDPrefix + Thread.currentThread().getName(), "", "", "", null, "", "", "", null, null)));
+        }
+
+        final int nMessages = 100_000;
+        for (int i = 0; i < nMessages; i++) {
+            es.submit(() -> logger.log(someMessagePrefix + Thread.currentThread().getName()));
+        }
+
+        es.shutdown();
+        while (!es.isTerminated()) {
+            ;
+        }
+
+        assertEquals(nMessages, sink.getMessages().size());  
+        for (byte[] message : sink.getMessages()) {
+            JSONObject parsedLog = new JSONObject(new String(message, StandardCharsets.UTF_8));
+            String parsedMessage = parsedLog.getString("message");
+            String parsedReqID = parsedLog.getString("AWSRequestId");
+            assertEquals(parsedMessage.substring(someMessagePrefix.length()), parsedReqID.substring(reqIDPrefix.length()));
+        }
+    }
+
     @Test
     public void testLoggingNullValuesWithoutLogLevelInJSON() {
         TestSink sink = new TestSink();
diff --git a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImplTest.java b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImplTest.java
index 473e2aef3..710c1565e 100644
--- a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImplTest.java
+++ b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImplTest.java
@@ -14,6 +14,8 @@
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.dto.ErrorRequest;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.dto.InvocationRequest;
 import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.dto.StackElement;
@@ -22,8 +24,18 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
 import okhttp3.HttpUrl;
 import static java.net.HttpURLConnection.HTTP_ACCEPTED;
 import static java.net.HttpURLConnection.HTTP_OK;
@@ -36,6 +48,14 @@
 @DisabledOnOs(OS.MAC)
 public class LambdaRuntimeApiClientImplTest {
 
+    @SuppressWarnings("rawtypes")
+    private final Supplier mockSupplier = mock(Supplier.class);
+    @SuppressWarnings("rawtypes")
+    private final Function mockExceptionMessageComposer = mock(Function.class);
+    private final LambdaContextLogger mockLambdaContextLogger = mock(LambdaContextLogger.class);
+    private final LambdaRuntimeClientMaxRetriesExceededException retriesExceededException = new LambdaRuntimeClientMaxRetriesExceededException("Testing Invocations");
+    final String fakeExceptionMessage = "Something bad";
+
     MockWebServer mockWebServer;
     LambdaRuntimeApiClientImpl lambdaRuntimeApiClientImpl;
 
@@ -43,7 +63,7 @@ public class LambdaRuntimeApiClientImplTest {
     ErrorRequest errorRequest = new ErrorRequest("testErrorMessage", "testErrorType", errorStackStrace);
 
     String requestId = "1234";
-
+    
     @BeforeEach
     void setUp() {
         mockWebServer = new MockWebServer();
@@ -51,6 +71,67 @@ void setUp() {
         lambdaRuntimeApiClientImpl = new LambdaRuntimeApiClientImpl(hostnamePort);
     }
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testgetSupplierResultWithExponentialBackoffAllFailing() throws Exception {
+
+        when(mockSupplier.get()).thenThrow(new RuntimeException(new Exception(fakeExceptionMessage)));
+        when(mockExceptionMessageComposer.apply(any())).thenReturn(fakeExceptionMessage);
+
+        try {
+            LambdaRuntimeApiClientImpl.getSupplierResultWithExponentialBackoff(mockLambdaContextLogger, 5, 200, 5, mockSupplier, mockExceptionMessageComposer, retriesExceededException);
+        } catch (LambdaRuntimeClientMaxRetriesExceededException e) { }
+
+        verify(mockSupplier, times(5)).get();
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying."), any());
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying in 5 ms."), any());
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying in 10 ms."), any());
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying in 20 ms."), any());
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage), any());
+        verify(mockLambdaContextLogger, times(5)).log(anyString(), any());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testgetSupplierResultWithExponentialBackoffTwoFailingThenSuccess() throws Exception {
+        InvocationRequest fakeRequest = new InvocationRequest();
+        
+        when(mockExceptionMessageComposer.apply(any())).thenReturn(fakeExceptionMessage);
+        
+        when(mockSupplier.get())
+        .thenThrow(new RuntimeException(new Exception(fakeExceptionMessage)))
+        .thenThrow(new RuntimeException(new Exception(fakeExceptionMessage)))
+        .thenReturn(fakeRequest);
+
+        InvocationRequest invocationRequest = (InvocationRequest) LambdaRuntimeApiClientImpl.getSupplierResultWithExponentialBackoff(mockLambdaContextLogger, 5, 200, 5, mockSupplier, mockExceptionMessageComposer, retriesExceededException);
+
+        assertEquals(fakeRequest, invocationRequest);
+        verify(mockSupplier, times(3)).get();
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying."), any());
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying in 5 ms."), any());
+        verify(mockLambdaContextLogger, times(2)).log(anyString(), any());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testgetSupplierResultWithExponentialBackoffDoesntGoAboveMax() throws Exception {
+
+        when(mockSupplier.get()).thenThrow(new RuntimeException(new Exception(fakeExceptionMessage)));
+
+        when(mockExceptionMessageComposer.apply(any())).thenReturn(fakeExceptionMessage);
+
+        try {
+            LambdaRuntimeApiClientImpl.getSupplierResultWithExponentialBackoff(mockLambdaContextLogger, 100, 200, 5, mockSupplier, mockExceptionMessageComposer, retriesExceededException);
+        } catch (LambdaRuntimeClientMaxRetriesExceededException e) { }
+
+        verify(mockSupplier, times(5)).get();
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying."), any());
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage + "\nRetrying in 100 ms."), any());
+        verify(mockLambdaContextLogger, times(2)).log(eq(fakeExceptionMessage + "\nRetrying in 200 ms."), any());
+        verify(mockLambdaContextLogger).log(eq(fakeExceptionMessage), any());
+        verify(mockLambdaContextLogger, times(5)).log(anyString(), any());
+    }
+
     @Test
     public void reportInitErrorTest() {
         try {
diff --git a/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfigTest.java b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfigTest.java
new file mode 100644
index 000000000..b1284e90c
--- /dev/null
+++ b/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/util/ConcurrencyConfigTest.java
@@ -0,0 +1,90 @@
+/*
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package com.amazonaws.services.lambda.runtime.api.client.util;
+
+import com.amazonaws.services.lambda.runtime.api.client.ReservedRuntimeEnvironmentVariables;
+import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
+import com.amazonaws.services.lambda.runtime.logging.LogFormat;
+import com.amazonaws.services.lambda.runtime.logging.LogLevel;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.contains;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class ConcurrencyConfigTest {
+    @Mock
+    private LambdaContextLogger lambdaLogger;
+
+    @Mock
+    private EnvReader envReader;
+
+    private static final String exitingRuntimeString = String.format("User configured %s is invalid.", ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY);
+
+    @Test
+    void testDefaultConfiguration() {
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn(null);
+        
+        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        verifyNoInteractions(lambdaLogger);
+        assertEquals(0, config.getNumberOfPlatformThreads());
+        assertEquals(false, config.isMultiConcurrent());
+    }
+
+    @Test
+    void testMinValidPlatformThreadsConfig() {
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("1");
+
+        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        verifyNoInteractions(lambdaLogger);
+        assertEquals(1, config.getNumberOfPlatformThreads());
+        assertEquals(true, config.isMultiConcurrent());
+    }
+
+    @Test
+    void testValidPlatformThreadsConfig() {
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("4");
+
+        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        verifyNoInteractions(lambdaLogger);
+        assertEquals(4, config.getNumberOfPlatformThreads());
+        assertEquals(true, config.isMultiConcurrent());
+    }
+
+    @Test
+    void testInvalidPlatformThreadsConfig() {
+        when(lambdaLogger.getLogFormat()).thenReturn(LogFormat.JSON);
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("invalid");
+
+        assertThrows(NumberFormatException.class, () -> new ConcurrencyConfig(lambdaLogger, envReader));
+        verify(lambdaLogger).log(contains(exitingRuntimeString), eq(LogLevel.ERROR));
+    }
+
+    @Test
+    void testGetConcurrencyConfigMessage() {
+        when(envReader.getEnv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_MAX_CONCURRENCY)).thenReturn("4");
+
+        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        String expectedMessage = "Starting 4 concurrent function handler threads.";
+        verifyNoInteractions(lambdaLogger);
+        assertEquals(expectedMessage, config.getConcurrencyConfigMessage());
+        assertEquals(true, config.isMultiConcurrent());
+    }
+
+    @Test
+    void testGetConcurrencyConfigWithNoConcurrency() {
+        ConcurrencyConfig config = new ConcurrencyConfig(lambdaLogger, envReader);
+        verifyNoInteractions(lambdaLogger);
+        assertEquals(0, config.getNumberOfPlatformThreads());
+        assertEquals(false, config.isMultiConcurrent());
+    }
+}
diff --git a/aws-lambda-java-runtime-interface-client/test/integration/test-handler/pom.xml b/aws-lambda-java-runtime-interface-client/test/integration/test-handler/pom.xml
index 46d191a74..e854831e7 100644
--- a/aws-lambda-java-runtime-interface-client/test/integration/test-handler/pom.xml
+++ b/aws-lambda-java-runtime-interface-client/test/integration/test-handler/pom.xml
@@ -15,7 +15,7 @@
         <dependency>
             <groupId>com.amazonaws</groupId>
             <artifactId>aws-lambda-java-runtime-interface-client</artifactId>
-            <version>2.8.4</version>
+            <version>2.8.7</version>
         </dependency>
     </dependencies>