2

这是我的 onCreate 的一部分，有时会导致异常：

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_tilisting);
    _context = getApplicationContext();
    SDName = Environment.getExternalStorageDirectory();
    //listview = (ListView)findViewById(R.id.TIlistview);
    String TIdir = new File(SDName, "/TitaniumBackup/").toString();
    final ArrayList<String> apps = new ArrayList<String>();
    final StringBuffer done = new StringBuffer();
    Command command = new Command(0,"ls -a "+TIdir+"/*.properties") {
        @Override
        public void output(int arg0, String arg1) {
            synchronized(apps) {
                apps.add(arg1);
                if (!done.toString().equals("")) {
                    done.append("done");//oh no
                }
            }
        }
    };
    try {
        RootTools.getShell(true).add(command).waitForFinish();
        String attrLine = "";
        int ind;
        backups = new ArrayList<TIBackup>();
        synchronized(apps) {
            for (String app : apps) {
                try {
                    TIBackup bkup = new TIBackup(app);
                    FileInputStream fstream = new FileInputStream(app);
                    BufferedReader atts = new BufferedReader(new InputStreamReader(fstream));
                    while ((attrLine = atts.readLine()) != null) {
                        ind = attrLine.indexOf('=');
                        if (ind !=-1 && !attrLine.substring(0,1).equals("#"))
                        bkup.prop.put(attrLine.substring(0,ind), attrLine.substring(ind+1));
                    }
                    backups.add(bkup);
                    atts.close();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            done.append("done");
        }
        setListAdapter( new StableArrayAdapter(this,backups));
    } catch (InterruptedException e) {
        //TODO:errors
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (TimeoutException e) {
        e.printStackTrace();
    }

尽管在for (String app : apps) {它之前有 waitforfinish() ，但它导致了异常。

这个更新的代码应该修复它，从输出中添加数据，并等待主代码中同步的任何落后者，但如果你在上面的 //oh no 行设置断点，它仍然会到达它的位置尝试在 UI 主代码运行后添加项目。所以 waitforfinish() 不是在等待吗？如何防止这种竞争状况？

我也尝试了RootTask下面的代码，但它似乎停在了最后一行？

    RootTask getProfile = new RootTask() {
        @Override
        public void onPostExecute(ArrayList<String> result) {
            super.onPostExecute(result);
            for (String r : result) {
                System.out.println(r);
            }
        }
    };
    getProfile.execute("ls /data/data/org.mozilla.firefox/files/mozilla/" );

onPostExecute 永远不会运行。

4

2 回答 2

1

Output()将在等待期间 被调用。waitForFinish()实现命令执行的代码有问题。

最有可能：命令执行器（RootTools？）在 shell 上运行命令，获取一堆输出行，通知调用线程等待，然后为它作为输出获得的每一行调用output()命令。我认为它应该在命令对象上调用所有输出行之后 通知命令线程。output()

您仍然可以将列表修改代码和列表迭代代码包装在synchronized(<some common object>){}.

更新：

所以waitForFinish()是不是在等待？如何防止这种竞争状况？

它确实在等待，但不是等待您的代码。Synchronized关键字只是确保output()在迭代集合Command时不会同时调用对象。apps它不安排两个线程以特定顺序运行。

恕我直言，waitForFinish()这不是一个好的模式，使调用线程等待破坏了单独执行程序的意义。最好将其表述为一个AsyncTask或接受每个Command对象的事件侦听器。

只是一个粗略的例子，这个类：

public class RootTask extends AsyncTask<String,Void,List<String>> {
    private boolean mSuccess;

    public boolean isSuccess() {
        return mSuccess;
    }

    @Override
    protected List<String> doInBackground(String... strings) {
        List<String> lines = new ArrayList<String>();

        try {
            Process p = Runtime.getRuntime().exec("su");
            InputStream is = p.getInputStream();
            OutputStream os = p.getOutputStream();

            os.write((strings[0] + "\n").getBytes());

            BufferedReader rd = new BufferedReader(new InputStreamReader(is));

            String line;

            while ((line = rd.readLine()) != null){
                lines.add(line);
            }

            mSuccess = true;
            os.write(("exit\n").getBytes());
            p.destroy();

        } catch (IOException e) {
            mSuccess = false;
            e.printStackTrace();
        }

        return lines;
    }
}

可以用作：

RootTask listTask = new RootTask{
  @Override
  public void onPostExecute(List<String> result){
      super.onPostExecute();
      apps.addAll(result);
      //-- or process the results strings--
  }
};

listTask.execute("ls -a "+TIdir+"/*.properties");
于 2013-04-26T07:02:43.063 回答
1

这部分是由 RootTools 中的设计缺陷引起的。我认为问题的症结在于您在 shell 上执行的操作所花费的时间比为 shell 命令设置的默认超时时间要长。当超时发生时，它只是将命令返回为已完成，这是设计缺陷所在。

我提供了一个新的 jar 以供使用，以及一些关于此的更多信息。我也弃用了 waitForFinish() ，因为我同意它曾经是并且现在是一个糟糕的解决方案。

https://code.google.com/p/roottools/issues/detail?id=35

如果您有任何疑问或问题，请告诉我:)

于 2013-06-27T16:27:32.983 回答