多线程系列之 java多线程的个人理解(二)

 

   

前言：上一篇多线程系列之 java多线程的个人理解(一) 讲到了线程、进程、多线程的基本概念，以及多线程在java中的基本实现方式，本篇主要接着上一篇继续讲述多线程在实际项目中的应用以及遇到的诸多问题和解决方案

文章结构：

• 多线程在实际项目中应用
• 多线程的优缺点

1.多线程在实际项目中应用

项目分享(一)

​ 背景：重庆移动代维管理系统项目，主要负责对重庆移动各代维公司，分公司，代维人员，以及各类代维业务和资产的统筹管理；其中的装维管理模块，是在代维系统中占有一席之地，主要保障移动宽带装机的线上流程以及业务顺利运行；在装维管理中，装机宽带业务在代维系统被抽象成了的工单的形式，每张工单又对应了唯一的流程实体。在整个流转过程中，有很多关键环节，其中就有一个环节叫竣工校验归档。他要完成的工作是当装机工单流程从完成安装到归档前，应该通过调接口的方式校验工单对应的宽带账号是否有上网记录。

​ 遇到的问题：前期的做法是用单线程异步的方式调用目标系统的接口，返回报文来完成业务。按照这样的设计思路系统平稳的运行了一段时间；突然有一天开始，代维系统的运维人员频繁反映，装机工单有很多单子堵塞在竣工校验归档环节。通过日志分析并定位是单线程导致的执行效率过慢，所以考虑到使用多线程，分批次完成工单的校验任务。

具体解决思路：在业务背景下，由于每张工单在进入校验队列后在后台数据库中都保存了一个执行时间，所以，通过与当前时间比较是否应该去调接口校验，前期由于是单线程，考虑的问题很少。后来利用多线程，将多张进入队列的工单分批次处理(即将执行时间的Long型数据对N取余，假使有N+1个线程在并发执行），这样每个线程所分配到的工单都是不同的，不会存在并发修改等多线程安全问题，当然这里还是以继承Thread类为例：

线程类：

 1 public class SmsSendThread extends Thread {
 2     
 3     private DataTable sendDt;
 4     private String SQL_DELETE_RECORD = "delete FROM BS_T_SM_SEND_SMS WHERE PID=?";
 5     
 6     @Override
 7     public void run() {//跑一次就结束
 8         if(sendDt!=null && sendDt.length()>0){
 9             DataAdapter dataAdapter = new DataAdapter();
10             
11             Integer counts = sendDt.length();
12             DataRow dr = null;
13             DataTable updateDt = null;
14             DataTable hisDt = null;
15             DataRow hisDr = null;
16             DataRow updateDr = null;
17             for(int i =0 ; i){
18                 
19                 updateDt = new DataTable("BS_T_SM_SEND_SMS");
20                 updateDt.setPrimaryKey(new String[]{"PID"});
21                 
22                 hisDt = new DataTable("BS_T_SM_SEND_SMS_LOG");
23                 
24                 dr = sendDt.getDataRow(i);
25                 //调用发送短信接口
26                 JSONObject jsonParam = new JSONObject();
27                 jsonParam.put("moblie", dr.getString("MOBILE"));
28                 jsonParam.put("message", dr.getString("CONTENT"));
29                 jsonParam.put("priority", dr.getString("PRIORITY"));
30                 JSONObject returnJson = SmsRestFullClient.postDataToInterface(SmsNewConstants.URL_SEND_SMS, jsonParam.toString(), null,"POST");
31                 String outResult = returnJson.getString("outResult");
32                 String outPut = returnJson.getString("outPut");
33 
34                 int maxSendNum = dr.getInt("MAX_SEND_NUM");
35                 if(maxSendNum==0)maxSendNum=maxSendNum+1;//最少一次
36                 int sendNum = dr.getInt("MAX_SEND_NUM");
37                 sendNum = sendNum+1;
38 
39                 dr.put("SEND_TIME", TimeUtils.getCurrentTime());
40                 dr.put("SEND_NUM", sendNum);
41                 dr.put("REMATK", returnJson);
42                 
43                 hisDr = dr.newRowClone();//历史记录
44                 updateDr = dr.newRowClone();
45                 
46                 if(SmsRestFullClient.OUTRESULT_SUCC.equals(outResult) && outPut!=null && outPut.contains("serial")){//成功后等待另一线程查询状态
47                     JSONObject serial = JSONObject.fromObject(outPut);
48                     String serialStr  = serial.getString("serial");
49                     
50                     updateDr.put("SEND_FLAG", SmsNewConstants.SEND_FLAG_SEARCHWAIT);//等待查询
51                     updateDr.put("PRE_SEND_TIME", TimeUtils.getCurrentTime()+120);//两分钟后
52                     updateDr.put("SERIAL", serialStr);
53                     updateDr.put("SEND_NUM", 0);//重置次数
54                     updateDt.putDataRow(updateDr);
55                     dataAdapter.executeUpdate(updateDt);
56                     
57                 }else{
58                     if(sendNum//继续发送，有发送次数变化，需保存
59                         
60                         updateDt.putDataRow(updateDr);
61                         dataAdapter.executeUpdate(updateDt);
62                         
63                     }else{//删除，不再发送短信
64                         
65                         dataAdapter.execute(SQL_DELETE_RECORD, new Object[]{dr.getString("PID")});
66                         
67                     }
68                     hisDr.put("SEND_FLAG", SmsNewConstants.SEND_FLAG_SENDFAIL);//发送失败
69                 }
70                 
71                 //插入历史记录表
72                 hisDt.putDataRow(hisDr);
73                 dataAdapter.executeAdd(hisDt);
74                 
75             }
76         }
77     }
78 
79     public DataTable getSendDt() {
80         return sendDt;
81     }
82 
83     public void setSendDt(DataTable sendDt) {
84         this.sendDt = sendDt;
85     }
86     
87 }

 

SQL查询：

 1 <sqlquery name="SQL_Thread_Eoms2Prov4OldRadius.query">
 2         <select>
 3              
 4                  
 5             SELECT /*COUNT*/ *  /*COUNT*/ FROM (
 6                 SELECT
 7                     t.*,
 8                     mod(RECORDTIME,10) threadid
 9                 FROM BS_T_WF4_FTTH_TOINTERFACE t
10                 WHERE RESULTTYPECODE ='RADIUSFILE' 
11                 $customwhere$ 
12             ) WHERE ROWNUM <100 $customwhere1$    
13                 /*ORDERBY*/ ORDER BY  /*ORDERBY*/  RECORDTIME ASC
14                 
15               ]]> 
16         select>
17         <customwhere name="customwhere" prepend="and" >
18             <field prepend="and" operator="="  colname="flag"  value="#flag#"/>
19             <field prepend="and" operator=">"  colname="calls"  value="#calls#"/>
20              <field prepend="and" operator="<"  colname="recordtime"  value="#recordtime#"/>
21         customwhere>
22         
23         <customwhere name="customwhere1" prepend="and" >
24             <field prepend="threadid" operator="="  colname="threadid"  value="#threadid#"/>
25         customwhere>
26     sqlquery>

 

这里没有直接在main方法中new 线程，而且采用配置表的方式，通过java反射机制动态的生成线程对象并执行。主要是为了后期的多线程智能化管理

Thread管理类：

主要功能：完成对多种线程的创建与启动

 18 
 19 /**
 20  * 线程智能化管理
 21  * @author zhj
 22  *
 23  */
 24 public class ThreadManageAI {
 25     
 26     private static String projectInfo = null;
 27     
 28     static Map threadMap = new HashMap();
 29     /**
 30      * 获取线程SQL
 31      */
 32     String SQL_GET_THREADINFO_INDB = "SELECT * FROM BS_T_SM_THREADMANAGE WHERE SERVERINFO=? AND THREADFLAG=1 ORDER BY THREADNAME";
 33 
 34     QueryAdapter queryAdapter = new QueryAdapter();
 35     DataAdapter dataAdapter = new DataAdapter();
 36     
 37     /**
 38      * 线程监听
 39      */
 40     public  void threadMonitor(){
 41         if(projectInfo==null || "".equals(projectInfo)){
 42             projectInfo = PropertiesUtils.getProperty("ThreadManageAI.projectInfo");
 43         }
 44         DataTable logdt = new DataTable("BS_T_SM_THREADMANAGE_LOG");
 45         DataRow logdr = null;
 46         if(projectInfo!=null && !"".equals(projectInfo)){
 47             DataTable dt = queryAdapter.executeQuery(SQL_GET_THREADINFO_INDB, projectInfo);
 48             if(dt!=null && dt.length()>0){
 49                 DataRow dr = null;
 50                 String threadName = null;
 51                 String clazz = null;
 52                 String paramJsonStr = null;
 53                 String logDesc = null;
 54                 boolean isAlive = false;
 55                 for(int i=0,j=dt.length();i){
 56                     isAlive = false;
 57                     dr = dt.getDataRow(i);
 58                     threadName = dr.getString("THREADNAME");
 59                     threadName = projectInfo+"."+threadName;
 60                     Thread t = threadMap.get(threadName);
 61                     if(t!=null){
 62                         isAlive = t.isAlive();
 63                     }else{
 64                         isAlive = false;
 65                     }
 66                     
 67                     if(!isAlive){//需要重启线程
 68                         //重启线程
 69                         paramJsonStr = dr.getString("PARAMJSON");//获取线程参数
 70                         clazz = dr.getString("CLAZZ");//线程类
 71 
 72                         Class XXthreadClass = null;
 73                         try {
 74                             XXthreadClass = Class.forName(clazz);
 75                         } catch (ClassNotFoundException e) {
 76                             XXthreadClass = null;
 77                             e.printStackTrace();
 78                         }
 79                         if(XXthreadClass!=null){
 80                             Object xxthread = null;
 81                             try {
 82                                 xxthread = XXthreadClass.newInstance();
 83                             } catch (InstantiationException e) {
 84                                 xxthread = null;
 85                                 e.printStackTrace();
 86                             } catch (IllegalAccessException e) {
 87                                 xxthread = null;
 88                                 e.printStackTrace();
 89                             }
 90                             if(xxthread!=null){
 91                                 boolean isCanStart = true;//默认可以启动线程
 92                                 if(paramJsonStr!=null && !"".equals(paramJsonStr)){
 93                                     JSONObject paramJson = JSONObject.fromObject(paramJsonStr);
 94                                     Method method = null;
 95                                     if(paramJson==null||paramJson.size()==0){
 96                                         //参数不为空，但是有错误，不能启动
 97                                         logDesc = "参数不为空，但是有错误，不能启动";
 98                                         isCanStart = false;
 99                                     }else{
100                                         try {
101                                             
102                                             Set keys = paramJson.keySet();
103                                             for(String key:keys){
104                                                 //例子，参数名threadid，方法名：setThreadid(String threadid)
105                                                 String methodName = "set"+key.substring(0,1).toUpperCase()+key.substring(1);
106                                                 
107                                                 method = XXthreadClass.getMethod(methodName, String.class);
108                                                 try {
109                                                     method.invoke(xxthread, paramJson.getString(key));
110 
111                                                 } catch (IllegalArgumentException e) {
112                                                     isCanStart = false;
113                                                     e.printStackTrace();
114                                                 } catch (IllegalAccessException e) {
115                                                     isCanStart = false;
116                                                     e.printStackTrace();
117                                                 } catch (InvocationTargetException e) {
118                                                     isCanStart = false;
119                                                     e.printStackTrace();
120                                                 }
121                                             }
122                                         
123                                         } catch (SecurityException e) {
124                                             isCanStart = false;
125                                             e.printStackTrace();
126                                         } catch (NoSuchMethodException e) {
127                                             isCanStart = false;
128                                             e.printStackTrace();
129                                         }
130                                     }
131                                 }
132                                 if(isCanStart){
133                                     boolean isStarted = true;
134                                     try {
135                                         Method startMethod = XXthreadClass.getMethod("start");
136                                         try {
137                                             startMethod.invoke(xxthread);
138                                         } catch (IllegalArgumentException e) {
139                                             isStarted = false;
140                                             e.printStackTrace();
141                                         } catch (IllegalAccessException e) {
142                                             isStarted = false;
143                                             e.printStackTrace();
144                                         } catch (InvocationTargetException e) {
145                                             isStarted = false;
146                                             e.printStackTrace();
147                                         }
148                                     } catch (SecurityException e) {
149                                         isStarted = false;
150                                         e.printStackTrace();
151                                     } catch (NoSuchMethodException e) {
152                                         isStarted = false;
153                                         e.printStackTrace();
154                                     }
155                                     if(isStarted){
156                                         t = (Thread)xxthread;
157                                         threadMap.put(threadName,t);
158                                         //线程启动成功
159                                         logDesc = "线程启动成功";
160                                     }else{
161                                         //线程启动失败
162                                         logDesc = "线程启动失败";
163                                     }
164                                 }else{
165                                     //参数设置失败
166                                     logDesc = "参数设置失败";
167                                 }
168                                 
169                             }else{
170                                 //线程无法实例化
171                                 logDesc = "线程无法实例化";
172                             }
173                         }else{
174                             //CLAZZ有误，无法加载类
175                             logDesc = "CLAZZ有误，无法加载类";
176                         }
177 
178                     }else{
179                         //线程存在，打印日志
180                         logDesc = "线程还存活";
181                     }
182                     
183                     HashMap rowMap = dr.getRowHashMap();
184                     logdr = new DataRow();
185                     for(String key:rowMap.keySet()){
186                         Object value = rowMap.get(key);
187                         if(value!=null){
188                             logdr.put(key, value);
189                         }
190                     }
191                     logdr.put("PID", UUIDGenerator.getUUIDoffSpace());
192                     logdr.put("LOGTIME", TimeUtils.getCurrentTime());
193                     logdr.put("LOGDESC", logDesc);
194                     
195                     logdt.putDataRow(logdr);
196                 }
197             }else{
198                 logdr = new DataRow();
199                 logdr.put("PID", UUIDGenerator.getUUIDoffSpace());
200                 logdr.put("LOGTIME", TimeUtils.getCurrentTime());
201                 logdr.put("LOGDESC", "没有需要启动的线程");
202                 logdr.put("SERVERINFO", projectInfo);
203                 logdt.putDataRow(logdr);
204             }
205             
206         }else{
207             logdr = new DataRow();
208             logdr.put("PID", UUIDGenerator.getUUIDoffSpace());
209             logdr.put("LOGTIME", TimeUtils.getCurrentTime());
210             logdr.put("LOGDESC", "projectInfo为空，没有需要启动的线程");
211             logdt.putDataRow(logdr);
212         }
213         
214         dataAdapter.executeAdd(logdt);
215     }
216 }

 

 

 

 

这样，我们只需要在目标表中配置线程ID 、线程的业务类型、线程实现类的全路径，以及入参，就可以通过反射的方式创建并启动多个线程，就这样，竣工归档校验功能第二版改造到一段落。通过运维人员反映，部分解决了工单由于等待太久而阻塞的问题。

然后在系统正常运行大概有一个月后，运维人员又一次发现了一个重大问题，那就是有很多装机工单是一直查不到上网记录，不断的进入队列，导致新工单本来可以归档的工单卡在了竣工校验环节。

通过查询日志并定位，又重新拟定了一套方案，就是分组处理工单，即一部分是处理没校验通过的老工单，另一部分则是处理新流转进来的工单。这样就有效解决了新工单不至于在处理队列中等待太久。

代码略___

项目场景分析(二)

背景：同样是重庆移动代维综合管理系统，web端大致可以分为两部分业务系统和流程引擎，其中业务系统主要处理的是各类工单，各种人员，资源以及代维公司和分公司的管理；但往往完成一个业务场景是需要多人协助参与的，所以就引入了工作流这个概念，但往往工作流底层是比较复杂的；流程引擎恰恰就是基于工作流的思想进行了封装和改造，使得开发人员可以更加简洁的新建、修改、启动一个自定义的流程。而由于是是多人参与，那么就会涉及到人与人，人与系统之间的通信，基于人性化考虑，我们决定采用发短信的方式推送给工单待办人。

遇到的问题：由于代维系统本身不提供发短信的服务，因此必须借助第三方系统，即通过调用第三方接口的方式，将代维系统的业务信息推送给代办人；那么问题来了，既然是调接口，那么肯定涉及到时延的问题，这样就存在主线程必须等待接口返回结果后才能往下执行，而往往发送短信是一个比较耗时的过程。

解决方案: 因此我们想到采用多线程异步的方式调用短信平台接口，这样既不阻塞主线程执行，也给用户带来了良好的体验。代码如下：

  1 package com.ultrapower.mams.smsnew.utils;
  2 
  3 import java.util.concurrent.ExecutionException;
  4 import java.util.concurrent.ExecutorService;
  5 import java.util.concurrent.Executors;
  6 import java.util.concurrent.Future;
  7 import java.util.concurrent.TimeUnit;
  8 import java.util.concurrent.TimeoutException;
  9 
 10 import com.ultrapower.eoms.common.core.component.data.DataAdapter;
 11 import com.ultrapower.eoms.common.core.component.data.DataRow;
 12 import com.ultrapower.eoms.common.core.component.data.DataTable;
 13 import com.ultrapower.eoms.common.core.util.TimeUtils;
 14 import com.ultrapower.eoms.common.core.util.UUIDGenerator;
 15 import com.ultrapower.mams.smsnew.constants.SmsNewConstants;
 16 import com.ultrapower.mams.smsnew.thread.SmsSendOnceThread;
 17 
 18 public class SmsNewUtil {
 19     
 20     public static DataAdapter dataAdapter = new DataAdapter();
 21     
 22     /**
 23      * 
 24      * @param smsType    业务分类
 25      * @param relateId    业务关联ID
 26      * @param content    短信内容
 27      * @param mobile    短信接收号码
 28      * @param PRIORITY    优先级,1/2/3,优先级一次降低(对于时效性较高的短信才使用1级,一般短信使用2,无时效性要求的使用3)
 29      * @param maxSendNum    最大发送次数
 30      * @param preSendTime    定时发送时间
 31      * @param remark    备注
 32      * @return
 33      */
 34     public static int insertSms(String smsType,String relateId,String content,
 35             String mobile,Integer maxSendNum,Integer priority,Long preSendTime,String remark){
 36         
 37         DataTable dt = new DataTable("BS_T_SM_SEND_SMS");
 38         DataRow dr = new DataRow();
 39         dr.put("PID", UUIDGenerator.getUUIDoffSpace());
 40         dr.put("SMS_TYPE", smsType);
 41         dr.put("RELATE_ID", relateId);
 42         dr.put("CONTENT", content);
 43         dr.put("MOBILE", mobile);
 44         if(priority==null){
 45             priority = 2;
 46         }
 47         dr.put("PRIORITY", priority);
 48         //dr.put("SEND_FLAG", null);
 49         if(maxSendNum==null){
 50             maxSendNum = 1;
 51         }
 52         dr.put("MAX_SEND_NUM", maxSendNum);
 53         dr.put("INPUT_TIME", TimeUtils.getCurrentTime());
 54         dr.put("PRE_SEND_TIME", preSendTime);
 55         //dr.put("SEND_TIME", null);
 56         dr.put("REMATK", remark);
 57         dt.putDataRow(dr);
 58         
 59         int re = dataAdapter.executeAdd(dt);
 60         
 61         return re;
 62     }
 63     
 64     public static void sendAndRecord(String smsType,String relateId,String content,
 65             String mobile,Integer maxSendNum,Integer priority,Long preSendTime,String remark){
 66         DataRow dr = new DataRow();
 67         dr.put("PID", UUIDGenerator.getUUIDoffSpace());
 68         dr.put("SMS_TYPE", smsType);
 69         dr.put("RELATE_ID", relateId);
 70         dr.put("CONTENT", content);
 71         dr.put("MOBILE", mobile);
 72         if(priority==null){
 73             priority = 2;
 74         }
 75         dr.put("PRIORITY", priority);
 76         if(maxSendNum==null){
 77             maxSendNum = 1;
 78         }
 79         if(preSendTime==null){
 80             dr.put("PRE_SEND_TIME", "");
 81         }else{
 82             dr.put("PRE_SEND_TIME", preSendTime);
 83         }
 84         dr.put("MAX_SEND_NUM", maxSendNum);
 85         dr.put("INPUT_TIME", TimeUtils.getCurrentTime());
 86         dr.put("REMATK", remark);
 87         
 88         ExecutorService exec = Executors.newCachedThreadPool();
 89         sendSMSByThread(exec,dr);
 90         
 91     }
 92     
 93    

 

​ PS:代码末尾使用了Executors类，Java通过Executors提供四种线程池，本例中使用了Executors创建了一个可以缓存线程池，应用中存在的线程数可以无限大，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

​ 下面再看下sendSMSByThread(exec,dr)方法的实现细节：

 1     public static void sendSMSByThread(ExecutorService exec,DataRow dr){
 2         
 3         SmsSendOnceThread task = new SmsSendOnceThread(dr);
 4         Future future = exec.submit(task);
 5         Boolean taskResult = null;
 6         String failReason = null;
 7         try {
 8             // 等待计算结果，最长等待300秒，300秒后中止任务
 9             taskResult = future.get(300, TimeUnit.SECONDS);
10         } catch (InterruptedException e) {
11             failReason = "短信线程在等待结果时被中断！";
12             exec.shutdownNow();
13         } catch (ExecutionException e) {
14             failReason = "短信等待结果，但计算抛出异常！";
15             exec.shutdownNow();
16         } catch (TimeoutException e) {
17             failReason = "短信等待结果超时，因此中断任务线程！";
18             exec.shutdownNow();
19         }finally{
20             
21             if(failReason!=null && !"".equals(failReason)){
22                 dr.put("REMATK", failReason);
23                 dr.put("SEND_TIME", TimeUtils.getCurrentTime());
24                 dr.put("SEND_FLAG", SmsNewConstants.SEND_FLAG_SENDFAIL);
25                 dr.put("SEND_NUM", 1);
26                 DataTable dataTable = new DataTable("BS_T_SM_SEND_SMS_LOG");
27                 dataTable.putDataRow(dr);
28 
29             //dataAdapter.execute(dataTable);
30 
31                 dataAdapter.executeAdd(dataTable);
32             }
33             
34         }
35 
36         
37     }

 

PS:可以看到是通过Futrue+Callable的方式来实现具有返回结果的线程啊，上一章节已经降到了。可以看到ExecutorService提交了一个Callable的实现类，我们接下来看下这个实现类(SmsSendOnceThread):

 1 public class SmsSendOnceThread implements Callable {
 2     
 3     private DataRow datarow;
 4     
 5     public SmsSendOnceThread(){
 6         
 7     }    
 8     
 9     public SmsSendOnceThread(DataRow datarow){
10         this.datarow = datarow;
11     }
12     
13     @Override
14     public Boolean call() throws Exception {//跑一次就结束
15         String inserSql = "INSERT INTO BS_T_SM_SEND_SMS_LOG(PID, SMS_TYPE, RELATE_ID, CONTENT, MOBILE, PRIORITY, PRE_SEND_TIME, MAX_SEND_NUM, INPUT_TIME, REMATK, SEND_TIME, SEND_NUM, SEND_FLAG, SERIAL) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
16         Boolean result =  Boolean.FALSE;
17         if(datarow!=null && datarow.length()>0){
18             DataAdapter dataAdapter = new DataAdapter();
19             //调用发送短信接口
20             JSONObject jsonParam = new JSONObject();
21             jsonParam.put("moblie", datarow.getString("MOBILE"));
22             jsonParam.put("message", datarow.getString("CONTENT"));
23             jsonParam.put("priority", datarow.getString("PRIORITY"));
24             JSONObject returnJson = SmsRestFullClient.postDataToInterface(SmsNewConstants.URL_SEND_SMS, jsonParam.toString(), null,"POST");
25             String outResult = returnJson.getString("outResult");
26             String outPut = returnJson.getString("outPut");
27 
28             datarow.put("SEND_TIME", TimeUtils.getCurrentTime());
29             datarow.put("SEND_NUM", 1);
30             datarow.put("REMATK", returnJson);
31             
32             if(SmsRestFullClient.OUTRESULT_SUCC.equals(outResult) && outPut!=null && outPut.contains("serial")){//成功后等待另一线程查询状态
33                 JSONObject serial = JSONObject.fromObject(outPut);
34                 String serialStr  = serial.getString("serial");
35                 
36                 datarow.put("SEND_FLAG", SmsNewConstants.SEND_FLAG_SEARCHWAIT);//等待查询
37                 datarow.put("PRE_SEND_TIME", TimeUtils.getCurrentTime()+120);//两分钟后
38                 datarow.put("SERIAL", serialStr);
39                 
40             }else{
41                 datarow.put("SEND_FLAG", SmsNewConstants.SEND_FLAG_SENDFAIL);//发送失败
42             }
43 
44             try {
45                 dataAdapter.execute(inserSql, new Object[]{datarow.getString("PID"),datarow.getString("SMS_TYPE"),datarow.getString("RELATE_ID"),datarow.getString("CONTENT"),
46                         datarow.getString("MOBILE"),datarow.getString("PRIORITY"),datarow.getString("PRE_SEND_TIME"),
47                         datarow.getString("MAX_SEND_NUM"),datarow.getString("INPUT_TIME"),datarow.getString("REMATK"),
48                         datarow.getString("SEND_TIME"),datarow.getString("SEND_NUM"),datarow.getString("SEND_FLAG"),datarow.getString("SERIAL")});
49                 result = Boolean.TRUE;
50             } catch (Exception e) {
51                 result = Boolean.FALSE;
52             }
53             
54             
55                 
56         }
57         return result;
58     }
59 
60     public DataRow getDatarow() {
61         return datarow;
62     }
63 
64     public void setDatarow(DataRow datarow) {
65         this.datarow = datarow;
66     }
67     
68 }

 

 

我们可以看到这个实现类返回的是一个Boolean类型的变量，至于它具体是怎么调接口的这里暂不做阐述。

二、多线程的优缺点

当然，这里仅仅是与单线程作比较

	单线程	多线程
成本	系统内存和IO占用较少	系统内存以及IO占用较多
性能	代码顺序执行，容易出现代码阻塞	线程间独立运行，能有效地避免代码阻塞，并且提高程序的运行性能
安全	很少出现线程安全的问题	如果控制不好会引来线程安全的问题

小结：多线程使程序的响应速度更快，因为用户界面可以在进行其他工作的同时一直处于活动状态。

​ 是否需要创建多线程应用程序取决于多个因素。在以下情况下，最适合采用多线程处理：

• 耗时或大量占用处理器的任务阻塞用户界面操作　　
• 各个任务必须等待外部资源（如远程文件、发送短信或 Internet 连接)

(未完待续......)

转载于:https://www.cnblogs.com/ft-greate/p/10212955.html