如何在 java 7 (android) 中并行化嵌套循环

Question

I have the following code snippet

 String result;
        for (int s1 = 0; s1 < 10; s1++)
            for (int s2 = 0; s2 < 100; s2++)
                for (int s3 = 0; s3 < 10; s3++)
                    for (int s4 = 0; s4 < 100; s4++)
                    {
                        result = doSomething(s1, s2, s3, s4);
                        if (result != null)
                            addResult(result); //adds results to an ArrayList of strings
                    }

How can I parallelize this code to make it faster? I've seen similar posts here parallelizing a single loops but I want to evenly parallelize this whole thing to make it run decently on an android device.

Answer 1

You could use an AsyncTask to parallelize each of the s1 executions, eg:

for (int s1 = 0; s1 < 10; s1++)
{
    new AsyncTask<Integer, Object, ArrayList<String>>()
    {
        @Override
        protected ArrayList<String> doInBackground(Integer... params)
        {
            ArrayList<String> results = new ArrayList<>();
            for (int s2 = 0; s2 < 100; s2++)
            {
                for (int s3 = 0; s3 < 10; s3++)
                {
                    for (int s4 = 0; s4 < 100; s4++)
                    {
                        results.add(doSomething(params[0], s2, s3, s4));
                    }
                }
            }
            return results;
        }

        @Override
        protected void onPostExecute(ArrayList<String> results)
        {
            for(String result : results) {
                if (result != null)
                    addResult(result);
            }
        }
    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, s1);
};

Note that this assumes that the order of addResult calls do not matter, and of course that doSomething calls do not interfere with each other by modifying some shared state.

If the order of addResult calls do matter, you could solve this by creating an array of all the results, waiting until they all finish (by creating a counter, and waiting until all 10 tasks complete, and then processing the array of results afterwards, in order.