Changed the version. (#481)

* Changed the version.

* Start ThreadPoolService.

Author: oleg-vyalyh

build.gradle

@@ -5,7 +5,7 @@ apply plugin: 'signing'
 
 
 group 'com.backendless'
-version '6.1.1'
+version '6.2.0'
 archivesBaseName='backendless'
 
 

src/com/backendless/Backendless.java

@@ -64,6 +64,7 @@ public final class Backendless
 {
   private static String url = "https://api.backendless.com";
   private static final boolean isAndroid = isAndroidEnvironment();
+  // do not remove or change 'isCoderunner', because it is used in CodeRunner initialization process
   private static boolean isCodeRunner = false;
   private static final BackendlessPrefs prefs;
 
@@ -222,8 +223,11 @@ public static void initApp( Object context, final String applicationId, final St
     }
 
     if( isCodeRunner() )
+    {
+      ThreadPoolService.getPoolExecutor();
       return;
-
+    }
+    
     String userToken = UserTokenStorageFactory.instance().getStorage().get();
 
     if( userToken != null && !userToken.equals( "" ) )

src/com/backendless/ThreadPoolService.java

@@ -20,23 +20,55 @@
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
 
 public class ThreadPoolService
 {
-  private static volatile ExecutorService threadPoolExecutor;
-  private final static int corePoolSize = 10;
+  private final static ExecutorService threadPoolExecutor;
+  private final static int MAX_THREAD_POOL_SIZE = 10;
 
+  static
+  {
+    if (Backendless.isCodeRunner())
+      threadPoolExecutor = new ThreadPoolExecutor(0, MAX_THREAD_POOL_SIZE, 2, TimeUnit.SECONDS,
+          new LinkedBlockingQueue<Runnable>(),
+          new SimpleThreadFactory("BackendlessSDK_CR"));
+    else
+      threadPoolExecutor = new ThreadPoolExecutor(2, MAX_THREAD_POOL_SIZE, 60, TimeUnit.SECONDS,
+        new LinkedBlockingQueue<Runnable>(),
+        new SimpleThreadFactory("BackendlessSDK"));
+  
+  }
+  
   public static ExecutorService getPoolExecutor()
   {
-    if( threadPoolExecutor == null )
+    return threadPoolExecutor;
+  }
+  
+  private static class SimpleThreadFactory implements ThreadFactory
+  {
+    private final ThreadFactory threadFactory = Executors.defaultThreadFactory();
+    private final String threadNamePrefix;
+    private final boolean isDaemon = true;
+    private final AtomicInteger threadNumber = new AtomicInteger();
+    
+    public SimpleThreadFactory( String poolName )
     {
-      synchronized( ThreadPoolService.class )
-      {
-        if( threadPoolExecutor == null )
-          threadPoolExecutor = Executors.newFixedThreadPool( corePoolSize );
-      }
+      this.threadNamePrefix = "pool-" + poolName + "-thread-";
+    }
+    
+    @Override
+    public Thread newThread( Runnable r )
+    {
+      Thread t = threadFactory.newThread( r );
+      t.setName( threadNamePrefix + threadNumber.getAndIncrement() );
+      t.setDaemon( isDaemon );
+      return t;
     }
-
-    return threadPoolExecutor;
   }
 }