来自 AsyncTask 块 UI 的线程

Question

我有MainActivity，它在执行名为"Datensammlung"的AsyncTask之前会做一些工作。此任务通过不同的类启动其他一些线程。它们都实现了 Runnable 并正常工作。两个用于与服务器通信（TCP连接），一些用于侦听事件/生成随机数（间隔10秒）。

现在我想显示每个线程工作的一些值（我总是使用同步）。当我只启动侦听器线程时，"onProgressUpdate"可能会被调用 5 次，直到它结束更新 UI。当我启动通信的另外两个线程时，什么都不会显示。

为什么尽管我使用了异步任务，但我的 UI 仍然被阻止？

有人有想法吗？谢谢！

法比安

AsyncTask：Datensammlung

protected Void doInBackground(String[]... params) {
    // TODO Auto-generated method stub
    while (true) {
        int counter = 0;
        ArrayList<String> texte = new ArrayList<String>();
        String test = "";
        for (Input i : this.Dataliste) {
            String text = " "+i.variablenName + ": "+String.valueOf(i.getAbstrakterWert())+"n";
            texte.add(text);
            test += text;
        //  Log.e("TEXT ", text);
        //  counter ++;
        }
        publishProgress(test);
        Log.e("TEXT", test);
        test = "";
        counter ++;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO: handle exception
        }
    }
}
@Override
protected void onProgressUpdate(String... listen) {
    TextView t = this.viewList.get(0);
    Log.e("hier isser", "1");
    for (String r : listen) {
        t.setText(r);
        Log.e("hier isser", r);
    }

}

我的交流课之一：

package kommunikation;

public class SensorAdapter implements Runnable{
    String iP;
    int port;
    Socket socket;
    ObjectOutputStream out;
    ObjectInputStream in;
    ArrayList<Nachricht> nachrichtenliste = new ArrayList<Nachricht>();
    Handler handler = new Handler();
    // Konstruktor
    public SensorAdapter(String iP, int port) {
        super();
        this.iP = iP;
        this.port = port;
    }
    public boolean initialisiere_sensor(ArrayList<Textobjekt> pObjekte){
        try {
            socket = new java.net.Socket(iP,port);
            // serialisiere alle Inputs und sende die Daten an das FW
            out = new ObjectOutputStream(new ObjectOutputStream(socket.getOutputStream()));
            out.writeObject(pObjekte);
            out.flush();
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
        return true; 
    }
    public void run() {
        try {
            while (true) {
                if (!nachrichtenliste.isEmpty()) {
                    PrintWriter printWriter =new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
                    Nachricht speicher = nachrichtenliste.get(0);
                    String senden = schreibe_nachricht(speicher);

                        printWriter.print(senden);
                        printWriter.flush();
                        synchronized (nachrichtenliste) {
                            nachrichtenliste.remove(speicher);
                        }
                }
                try {
                    Thread.sleep(500);
                    handler.post(this);
                } catch (InterruptedException e) {
                    // TODO: handle exception
                }
            }

        } catch (Exception e) {
            // TODO: handle exception
        }       
    }

通信线程开始的地方：

public class Kommunikator implements Callback{
    ArrayList<Input> objektliste;
    ArrayList<Textobjekt> textliste;
    boolean update_erforderlich = false;
    public boolean bereit = false;
    private Verbindungsdaten verbindungsdaten;
    private SensorAdapter sadapter;
    private ClientAdapter cadapter;
    Thread sensorfred;
    Thread clientfred;

    // Konstruktor
    public  Kommunikator(ArrayList<Input> plist, ArrayList<Textobjekt> ptextliste){
        boolean check;
        boolean cCheck;
        this.objektliste = plist;
        this.textliste = ptextliste;
        // startet die kommunikation
        this.sadapter = new SensorAdapter("192.168.2.106", 1111);
        this.cadapter = new ClientAdapter("192.168.2.106", 2222,this);
    check = sadapter.initialisiere_sensor(ptextliste);

    if (check ) {
        sensorfred = new Thread(sadapter);
        sensorfred.start();
    }
    // client darf wirklcih erst nach dem sensorlayer starten
    cCheck = cadapter.initialisiere_client(ptextliste);
    if (cCheck) {
        clientfred = new Thread(cadapter);
        clientfred.start();
    }
    this.bereit = true;
    }
    // kann vom Sensor aufgerufen werden um die updates an das framework zu senden
    public void melde(Nachricht na){
            Nachricht speicher =null;
            for (Nachricht n : this.sadapter.nachrichtenliste) {
                if (n.getName().equals(na.getName())) {
                    speicher = n;
                }
            }
            // lösche die alte nachricht
            if (speicher != null) {
                int index = sadapter.nachrichtenliste.indexOf(speicher);
                sadapter.nachrichtenliste.remove(index);
            }
            synchronized (sadapter.nachrichtenliste) {
                this.sadapter.nachrichtenliste.add(na);
            }
    }

    public void melde_Abstract(String name, int Version, float wert){
        // hier synchronized rein???
            for (Input i : objektliste) {
                if (i.variablenName.equals(name)) {
                    // mache Versionscheck und schreibe dann dort den wert
                    synchronized (i) {
                        i.setAbstrakterWert(wert);
                    }
                }
            }
    }

Answer 1

当你使用 Handler.post（） 时，它将在 UI 线程上执行可运行的（如果处理程序是在 UI 线程中创建的）。因此，当您执行 handler.post（this）时，您实际上在UI线程上进行所有通信。