Android 异步任务块UI中的线程

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

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

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

有人有主意吗？谢谢大家!

费边

异步任务：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);
    }

protectedvoiddoinbackground（字符串[]…参数）{
//TODO自动生成的方法存根
while（true）{
int计数器=0；
ArrayList texte=新的ArrayList（）；
字符串测试=”；
for（输入i:this.Dataliste）{
String text=“+i.variablenName+”：“+String.valueOf（i.getAbstrakterWert（））+”\n”；
text.add（text）；
测试+=文本；
//Log.e（“文本”，文本）；
//计数器++；
}
出版进度（测试）；
Log.e（“文本”，测试）；
test=“”；
计数器++；
试一试{
《睡眠》（2000年）；
}捕捉（中断异常e）{
//TODO:处理异常
}
}
}
@凌驾
受保护的void onProgressUpdate（字符串…侦听）{
TextView t=this.viewList.get（0）；
Log.e（“hier isser”，“1”）；
for（字符串r:侦听）{
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
        }       
    }

包通信；
公共类SensorAdapter实现可运行{
字符串iP；
国际港口；
插座；
对象输出流输出；
目标输入流；
ArrayList nachrichtEnlist=新的ArrayList（）；
Handler=newhandler（）；
//康斯特鲁克托
公共传感器适配器（字符串iP，int端口）{
超级（）；
this.iP=iP；
this.port=端口；
}
公共布尔初始值传感器（ArrayList pObjekte）{
试一试{
socket=新的java.net.socket（iP，端口）；
//串行所有输入和发送日期均为FW
out=newObjectOutputStream（newObjectOutputStream（socket.getOutputStream（））；
out.writeObject（pObjekte）；
out.flush（）；
}捕获（未知后异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
} 
返回true；
}
公开募捐{
试一试{
while（true）{
如果（！nachrichtenste.isEmpty（））{
PrintWriter PrintWriter=新的PrintWriter（新的OutputStreamWriter（socket.getOutputStream（））；
Nachricht speicher=nachrichtenste.get（0）；
字符串senden=schreibe_nachricht（speicher）；
printWriter.print（senden）；
printWriter.flush（）；
已同步（NachrichTe）{
去除（斯派克）；
}
}
试一试{
睡眠（500）；
处理程序。post（本）；
}捕捉（中断异常e）{
//TODO:处理异常
}
}
}捕获（例外e）{
//TODO:处理异常
}       
}

通信线程开始的位置：

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);
                    }

                }
            }
    }

公共类Kommunikator实现回调{
arraylistobjektliste；
ArrayList文本列表；
布尔更新\u erforderlich=false；
公共布尔值：it=false；
私人逐字逐句逐字逐句；
专用传感器适配器；
私人客户适配卡；
螺纹传感器；
线程clientfred；
//康斯特鲁克托
公共社区（ArrayList plist、ArrayList ptextliste）{
布尔检查；
布尔检查；
this.objektliste=plist；
this.textliste=ptextliste；
//通讯卫星
this.sadapter=新的传感器适配器（“192.168.2.106”，1111）；
this.cadapter=新客户端适配器（“192.168.2.106”，2222，this）；
检查=辅助。初始化传感器（ptextliste）；
如果（检查）{
sensorfred=新螺纹（sadapter）；
sensorfred.start（）；
}
//客户darf WIRKLICH erst nach dem传感器层starten
cCheck=cadapter.initialisiere_客户端（ptextliste）；
如果（cCheck）{
clientfred=新线程（cadapter）；
clientfred.start（）；
}
this.bereit=true；
}
//kann vom传感器aufgerufen werden um die更新了das框架
公共无效melde（Nachricht na）{
Nachricht-speicher=null；
for（Nachricht n:this.sadapter.nachrichte）{
如果（n.getName（）.equals（na.getName（）））{
speicher=n；
}
}
//lösche die alte nachricht
if（speicher！=null）{
int index=sadapter.nachrichtenste.indexOf（speicher）；
sadapter.nachrichtenste.remove（索引）；
}
已同步（sadapter.nachrichtenste）{
这个.sadapter.nachrichtenste.add（na）；
}
}
公共void melde_摘要（字符串名称、int版本、float-wert）{
//他是谁？？？
for（输入i:objektliste）{
如果（i.name.equals（name））{
//机器版本检查和检查
同步（一）{