在多线程环境中运行应用程序

Question

In the application,a heavy file is being loaded in a function. If multiple threads try calling the same
function, then the application crashes due to multiple objects being created and multiple threads loading the same file. If a single thread calls the function, then the application becomes slow as each thread is waiting for the previous thread to be completed. Suggestions for a good approach to mitigate this issue !

Answer 1

Your code is lacking synchronization. Usually you have one UI thread for user interaction and N worker threads. File loading function should be called only by worker thread and you have to prevent other worker threads from accessing function if loading process started already.

Consider using:

• Java Synchronize
• https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantLock.html
• Atomic objects
• RxJava - could be used here to simplify threading but

With above you can implement two strategies:

1. prevent any function call if function is running already
2. wait for previous execution to complete and then block&execute it doesn't solve synchronization problem by default.

I think you need to do 1. - why load same file multiple times?

class FileLoader {

  private boolean isFileLoaded = false

  @WorkerThread
  public synchronized void loadFilePseudoCode() {
     if(isFileLoaded) return;
     if(startFileLoading()) isFileLoaded = true;
  }
}

You need to make sure that isFileLoaded is written only inside synchronized function. In code above function is synchronized by class instance.

Answer 2

Most likely your application crashes due to OutOfMemory . If several threads load large files into the application.

In blind (without code and example),i can advice the following:

1. The increase of -xmx
2. Use NIO to process the file
3. You can yourself, instead of NIO, load the file into native memory
4. Make a cache for the function and save the cached file locally on the application