Android内存泄漏使用匿名类实现和特定于线程的局部变量

Question

In my application I want to do specific task in a separate thread.I want to know where it will cause any memory leak.

public class MainActivity extends Activity {

      @Override
      protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        runOnThread();
      }

      private void runOnThread() {
        new Thread() {
        private int value;
          @Override
          public void run() {
            while (true) {
              SystemClock.sleep(1000);
              callotherfunction(value);
            }
          }
        }.start();
      }
    }

So does this implementation cause Memory leak.And on more thing is that Having local variables in thread is it harmful? Will local variables in threads create memory leak.

Answer 1

I do not know what the problem is in your code, but I invite you to use the AsynTask if you need to do operations on other threads/background.

Doc: https://developer.android.com/reference/android/os/AsyncTask.html

Example in which a dialog is also opened which closes at the end of operations:

In your class where have to do operation in background:

/** Create variable */
private Dialog dialog;
private LoadAsyn loadAsync;

/** Call the AsyncTask */
dialog = ProgressDialog.show(getActivity(), "", "Caricamento...", false, true);
dialog.setCancelable(false);
loadAsync = new LoadAsyn();
loadAsync.execute((Void) null);

This is the class where is defined the AsynTask operation:

/** Define AsyncTask Class */
public class LoadAsyn extends AsyncTask<Void, Void, Boolean> {
    @Override
    protected void onPreExecute(){}

    @Override
    protected void onProgressUpdate(Void[] values) {};

    @Override
    protected Boolean doInBackground(Void... params) {

        //In this block all operation to do in background

        return true;

    }

    @Override
    protected void onPostExecute(final Boolean success) {
        dialog.dismiss();
        //Operation to do after execution
    }

    @Override
    protected void onCancelled() {
        loadCompAsync = null;
    }
}
}

Answer 2

The variables will take up memory as long as your thread is running. If your thread is never stopped and deallocated, then it will continue to take up memory.

You are fine as long as you have some exit condition that will make the thread stop. When thread is stopped, it will be garbage collected if you have no references to it.

Even so explicitly creating threads is not the recommended way to run background tasks in android. Use AsyncTask instead, or take a look at RxJava.