Android聊天界面刷新消息

今天，我想来分享一下自己初用线程的感受，虽然写法略显粗糙，并没有用线程Thread中核心的Looper，MessageQueue消息队列这些知识，正因为是初学线程，所以就只用最基础的来写了，慢慢学习优化改进。

上一节“Android中Thread的2种实现方法”中介绍过Android中Thread的2种实现方法，今天我用的是后一种，通过实现Runnable接口来实现我刷新聊天消息的线程RefreshThread。

 1 private class RefreshThread implements Runnable{ 
 2         private int await = 0; 
 3         private boolean flag = true; 
 4         @Override 
 5         public void run() { 
 6             while (flag) { 
 7                 try { 
 8                     Message message =new Message(); 
 9                     message.what = 1; 
10                     handler.sendMessage(message); 
11                     Thread.sleep(await()); 
12                 } catch (InterruptedException e) { 
13                     e.printStackTrace(); 
14                 } 
15             }    
16         } 
17         public void setFlag(boolean flag) { 
18             this.flag = flag; 
19         } 
20         public long await(){ 
21             if(await > 13){ 
22                 return 60000L; 
23             } 
24             if (await > 6) { 
25                 return 20000L; 
26             } 
27             return await < 3 ? 10000L:15000L; 
28         } 
29        public void setAwait(int await) { 
30             this.await = await; 
31         } 
32         public void ascAwait(){            
33             await ++; 
34         } 
35      }

RefreshThread

这个线程里呢最核心的就是await()这个方法了，当await这个变量<3时，Thread.sleep()线程睡眠10s，当然也就是我们的消息10s刷新一次；

当(await>3&&await<6)的时候，消息15s刷新一次；依次可以看出，await>6时，消息20s刷新一次；await>13时，消息一分钟刷新一次。那说了这么久，

await这个变量到底是什么呢？通过下面的这段代码一看便知，当我们去比较消息列表的长度值时，列表值刷新前与刷新后的size如果是没变化的话，那我们的await++，

对应线程就是refreshThread.ascAwait()这个方法，这个意思那就是说如果一直没人发消息，那我们刷新的时间就会变久，对应刷新的时间可能是10s，15s,20s，甚至一分钟；如果有人发消息，消息列表的值不等了的情况下，我们就要将await值赋值为0，这样就会及时刷新。

 1 case i_getMessageInfo: 
 2             ChatMsg chatMsg=ChatMsgData.getChatMsg(); 
 3             if(ViewUtil.isNotEmpty(chatMsg)){ 
 4                 if (Integer.parseInt(chatMsg.getState().toString())>0) 
 5                 { 
 6                     synchronized(this) { 
 7                         List<ChatMsgList> chatMsgList=chatMsg.getChatmsglist(); 
 8                         size=chatMsgLists.size(); 
 9                         chatMsgLists.clear(); 
10                         chatMsgLists.addAll(chatMsgList); 
11                         myAdapter.notifyDataSetChanged(); 
12                         listView.setSelection(chatMsgLists.size()); 
13                         if (chatMsgLists.size() == size) { 
14                                     refreshThread.ascAwait(); 
15                               }else { 
16                                     refreshThread.setAwait(0); 
17                               } 
18                     }        
19                 } 
20                 else 
21                 { 
22                     showToast("获取消息列表未成功", false); 
23                 } 
24             } 
25             break;

i_getMessageInfo

当然，线程之间交互是少不了Handler这个机制，通过handler来去通知主线程去更新消息列表，以便做消息列表size大小的比较。

 1 private Handler handler = new Handler(){ 
 2         @Override 
 3         public void handleMessage(android.os.Message msg) { 
 4             switch (msg.what) { 
 5             case 1: 
 6                 sendToBackgroud(OperateCode.i_getMessageInfo,new String[]{PersonalID,""}); 
 7                 break; 
 8             default: 
 9                 break; 
10             } 
11             super.handleMessage(msg); 
12         }; 
13     };

handler

好，那么这就是我用线程来去刷新消息的理解与实现。