make java wait until variable changes

Question

I want to make my code wait until there is a change anywhere in my class to the variable finaloutcomes. Is there any way to do this? I am carrying this out within an Asynctask, which I posted below.

 public HashMap<String,String> checkbetoutcome() {

    new LoadAllGamet().execute();

    // INSERT CODE HERE

    return finaloutcomes;

}

ASYNCTASK

class LoadAllGamet extends AsyncTask<String, String, String> {
        @Override
        protected void onPreExecute() {
            super.onPreExecute();

        }

        protected String doInBackground(String... args) {
           // HttpParams httpParameters = new BasicHttpParams();
           // HttpConnectionParams.setConnectionTimeout(httpParameters, 250000);
            //HttpConnectionParams.setSoTimeout(httpParameters, 250000);
            HttpClient client = new DefaultHttpClient();
            HttpPost post = new HttpPost(url_check_bet);
            List<NameValuePair> params = new ArrayList<NameValuePair>();
            params.add(new BasicNameValuePair("param", bet));
           // Log.d("CURRENTITEM", currentitem);
            try {
                post.setEntity(new UrlEncodedFormEntity(params));
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            try {
                HttpResponse response = client.execute(post);
                Log.d("Http Post Responsecxxx:", response.toString());
                HttpEntity httpEntity = response.getEntity();
                InputStream is = httpEntity.getContent();
                JSONObject jObj = null;
                String json = "";
                client.getConnectionManager().closeExpiredConnections();
                try {
                    BufferedReader reader = new BufferedReader(new InputStreamReader(
                            is, "iso-8859-1"), 8);
                    StringBuilder sb = new StringBuilder();
                    String line = null;
                    while ((line = reader.readLine()) != null) {

                        if (!line.startsWith("<", 0)) {
                            if (!line.startsWith("(", 0)) {
                                sb.append(line + "\n");
                            }
                        }
                    }

                    is.close();
                    json = sb.toString();

                    json = json.substring(json.indexOf('{'));
                //    Log.d("sbsssssssssss", json);
                    try {
                        jObj = new JSONObject(json);
                    } catch (JSONException e) {
                        Log.e("JSON Parser", "Error parsing data " + e.toString());
                    }
                    allgames = jObj.getJSONArray("bets");
                 //   Log.d("WHAT IS MY ARRAY?", allgames.toString());

                       for (Integer i = 0; i < allgames.length(); i++) {
                           HashMap<String,String> statuses = new HashMap<>();
                            JSONObject c = allgames.getJSONObject(i);
                            JSONArray currentbet = c.getJSONArray("bet");
                            Log.d("Single array",currentbet.toString());

                           //  Storing each json item in variable

                           for (Integer a = 0; a < currentbet.length();a++) {
                               JSONObject d = currentbet.getJSONObject(a);
                            String Result = d.getString("Result");
                               String id = d.getString("gid");
                            Log.d("RESULTS",Result);

                           statuses.put(id, Result);
                        }
                           allbetsmap.add(i, statuses);
                           Log.d("ddd", statuses.toString());
                           Log.d("AAA", allbetsmap.get(i).toString());


                       }



                    } catch (Exception e) {
                        Log.e("Buffer Error", "Error converting result " + e.toString());
                    }


                }
             catch (IOException e) {
                e.printStackTrace();
            }




            return "";
        }



        @Override
        protected void onPostExecute(String param) {
            Log.d("SIZE",Integer.toString(allbetsmap.size()));
            //ArrayList<Map<String,String>> allbetsmap = new ArrayList<>();
            //ArrayList<Map<String,String>> passtocheck = new ArrayList<>();

            if (allbetsmap.size() == passtocheck.size()) {
                for (int i = 0; i < allbetsmap.size();i++) {
                if (allbetsmap.get(i).size() == passtocheck.get(i).size()) {
                    String finaloutcome = "won";
                    for (String a : allbetsmap.get(i).keySet()) {
                        String f = allbetsmap.get(i).get(a);
                        if(f.equals("null")) {
                            finaloutcome = "open";
                        }
                        else if (! (f.equals(passtocheck.get(i).get(a)))) {
                            finaloutcome = "lost";
                            break;
                        }
                    }
                    finaloutcomes.put(Integer.toString(i),finaloutcome);
                }
                }

            }
            Log.d("Vital",finaloutcomes.toString());


        }


    }

Answer 1

Ok, forget what I wrote before. I didn't realize you were writing code for android. Here is an improved version of LoadAllGamet. There are two important things here. 1. define as much as possible locally i.e. inside a method or - if that's not possible - inside the class. 2. return the result instead of putting it into some variable.

class LoadAllGamet extends AsyncTask<String, Void, HashMap<String,String>> {
    protected HashMap<String,String> doInBackground(String ... args) {
        HashMap<String,String> finaloutcomes = new HashMap<>(),
        HashMap<Integer, HashMap<String,String>> allbetsmap = new HashMap<>();

        HttpClient client = new DefaultHttpClient();
        ...
        Log.d("SIZE",Integer.toString(allbetsmap.size()));
        if (allbetsmap.size() == passtocheck.size()) {
          ...
        }
        Log.d("Vital",finaloutcomes.toString());
        return finaloutcomes;
    }
}

Whenever you want to do something that might take some time you should not run that in the UI thread of you App since it can block your UI. Instead run it asynchronously. One way of doing this is to use AsyncTask. Let's assume you want to do something and while that something is being processed you also want to update the UI (e.g. progress bars) from time to time. And once you are finished you want to do something else with the result. Here is one way of writing this.

void doSomething() {
  new AsyncTask<String, Progress, Result>() {
    protected Result doInBackground(String... args) {
      //some code
      publishProgress(values);
      //some more code
      return result;
    }

    protected void onProgressUpdate(Progress ... values) {
      updateProgessBars(values);
    }

    protected void onPostExecute(Result result) {
      doSomethingElse(result);
    }
  }.execute();
}

The String in new AsyncTask<String, Progress, Result> is the type of the arguments to doInBackground. Often however you don't really need that unless you want to pass arguments into execute. Progress is the type of the values you want to send to onProgressUpdate. That one you only need if you want to update your UI while the background processing is still going on. Result is of course your result type. Whatever you want to happen after the doInBackground is finished you write into onPostExecute.