Question

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

现在我想显示每个线程工作的一些值（我总是使用synchronized）。当我只启动Listener-Threads时，“onProgressUpdate”可能被调用5次，直到它结束更新UI。当我启动另外两个用于通信的线程时，不会显示任何内容。

为什么我的UI仍然被阻止，虽然我使用了asynctasks？

有人有个主意吗？谢谢！

费边

的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
        }       
    }

Communication-Thread启动的地方：

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线程上执行runnable（如果在UI线程中创建了handler）。所以，当你执行handler.post（this）时，你实际上是在UI线程上进行所有的通信。

来自AsyncTask的线程阻止UI

1 个答案: