一段java并发编程代码

1 snmpGetDevicesTask方法

	public static Map<String,CapEbu> snmpGetDevicesTask(List<String> ipList, List<String> oidList) {
		if(ipList==null||ipList.size()==0 || oidList==null || oidList.size()==0) return null;
		Map<String,CapEbu> ebuMap = new HashMap<String,CapEbu>();
		List<CapEbu> ebulist = new Vector<CapEbu>();
		int ipsSize = ipList.size();//ip段大小
		//指定循环次数，如果不指定循环次数且IP段大小是65536，那么线程池的一个任务就包含600多个ip，那么在极短时间内，当前任务会有一个监听器线程，该线程可能会响应不过来，因为要处理600多个响应。
		//现在指定一次循环，线程池就只处理1000个ip,同时该循环中只向线程池发布100个任务，平均一个任务只处理10个ip。
		int cicleNumber = (ipsSize%ScanDeviceContants.DEAL_IPNUMBER == 0)?(ipsSize/ScanDeviceContants.DEAL_IPNUMBER):(ipsSize/ScanDeviceContants.DEAL_IPNUMBER+1);
		
		//创建线程执行器
		ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(ScanDeviceContants.THREADPOOL_SIZE);
		List<Future<List<CapEbu>>> resultList = new ArrayList<Future<List<CapEbu>>>();
		for(int cicle=0; cicle<cicleNumber; cicle++){
			List<String> iptemp = new ArrayList<String>();
			iptemp.addAll(ipList.subList(cicle*ScanDeviceContants.DEAL_IPNUMBER, cicle==cicleNumber-1?ipList.size():(cicle+1)*ScanDeviceContants.DEAL_IPNUMBER));
			
			//创建ip分配器
			AssignIps assignIps = new AssignIps(iptemp);
			
			 
		    for(int i=0; i<assignIps.getTaskSize(); i++){
		    	SnmpEbuTask snmpEbuTask = new SnmpEbuTask(assignIps.getAssignedIps(i),oidList);
		    	Future<List<CapEbu>> result = executor.submit(snmpEbuTask);
		    	resultList.add(result);
		    	snmpEbuTask = null;
		    }
		    System.out.println("CorePoolSize:"+executor.getCorePoolSize()+"---"+"MaximumPoolSize:"+executor.getMaximumPoolSize()+"-----LargestPoolSize:"+executor.getLargestPoolSize()+"-------PoolSize:"+executor.getPoolSize());
		    executor.allowCoreThreadTimeOut(false);
		    System.out.println("executor.getKeepAliveTime(TimeUnit.MILLISECONDS):"+executor.getKeepAliveTime(TimeUnit.NANOSECONDS));
		    
		    //直到所有任务都已完成，则停止循环
		    do {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
					System.out.println("线程活跃数量："+executor.getActiveCount());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} 
//		    while (executor.getCompletedTaskCount()<resultList.size()*(cicle+1)); 
		    while (executor.getActiveCount()!=0); 
		   
		    System.out.println("线程活跃数量："+executor.getActiveCount()+"，执行器执行完的数量："+executor.getCompletedTaskCount());
		    System.out.println("执行器"+(cicle+1)+"是否已终止："+executor.isTerminated());
		}
		executor.shutdown();//关闭线程执行器
		 //所有任务已经完成，开始取出任务
	    for (int i=0; i<resultList.size(); i++) {
			Future<List<CapEbu>> result=resultList.get(i);
			if(result.isDone()){
				try {
					List<CapEbu> ebus = result.get();
				    if(ebus!=null&&ebus.size()>0){
				    	for(int j = 0 ; j < ebus.size() ; j++){
				    		if(!ebuMap.containsKey(ebus.get(j).getEbuIp())){
				    			ebuMap.put(ebus.get(j).getEbuIp(), ebus.get(j));
				    			System.out.println("放入map中,测试结果为 : ip = " + ebus.get(j).getEbuIp());
				    		}
				    		
				    	}
				    }
//					ebulist.removeAll(ebus);
//					ebulist.addAll(ebus);
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (ExecutionException e) {
					e.printStackTrace();
				}
			}
		} 
	    return ebuMap;
	}

2 SnmpEbuTask.java

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import org.snmp4j.CommunityTarget;
import org.snmp4j.PDU;
import org.snmp4j.Snmp;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.event.ResponseListener;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.DefaultUdpTransportMapping;

import com.nufront.euht.model.CapEbu;
import com.nufront.euht.scanDevice.util.OidTranslatorUtil;
import com.nufront.euht.util.Beans;
import com.nufront.euht.util.StringUtil;

public class SnmpEbuTask implements Callable<List<CapEbu>> {
	private int version = SnmpConstants.version2c;
	private String protocol = "udp";
	private int port = 161;
	
	private String community = "euhtpub";
	private List<String> ipsAddress;
	private List<String> oids;
	
	private List<CapEbu> capEbus = new Vector<CapEbu>();
	private Object lock = new Object();//同步锁
	private int responseCounter = 0;//响应计数器
	private ConcurrentHashMap<String,Object> distinctIp = new ConcurrentHashMap<String,Object>();//ip响应去重器
	
	public SnmpEbuTask(List<String> ipsAddress, List<String> oids) {
		this.ipsAddress = ipsAddress;
		this.oids = oids;
	}

	private CommunityTarget createCommunityTarget(String address,String community, int version, long timeOut, int retry) {
		Address targetAddress = GenericAddress.parse(address);
		CommunityTarget target = new CommunityTarget();
		target.setCommunity(new OctetString(community));
		target.setAddress(targetAddress);
		target.setVersion(version);
		target.setTimeout(timeOut); // milliseconds
		target.setRetries(retry);
		return target;
	}

	@Override
	public List<CapEbu> call() throws Exception {
		String address = null;
		CommunityTarget target = null;
		DefaultUdpTransportMapping transport = null;
		Snmp snmp = null;
		
		try {
			
			transport = new DefaultUdpTransportMapping();
			transport.listen();
			snmp = new Snmp(transport);
			PDU pdu = new PDU();
			pdu.setType(PDU.GET);
			
			for (String oid : oids) {
				pdu.add(new VariableBinding(new OID(oid)));
			}

			ResponseListener listener = new ResponseListener() {
				public void onResponse(ResponseEvent event) {
					((Snmp) event.getSource()).cancel(event.getRequest(), this);
					PDU response = event.getResponse();
					PDU request = event.getRequest();
					System.out.println("[request]:" + request);
					String ip = null;
					if (Beans.isNotEmpty(event.getPeerAddress())) {
						ip  = event.getPeerAddress().toString(); // 获取IP
						if(!StringUtil.isNullOrBlank(ip)){
							ip = ip.split("/")[0];
							System.out.println("registerListener, ip=" + ip);
						}
					}
					if (response == null) {
						System.out.println("[ERROR]: response is null, ip is "+ip);
					} else if (response.getErrorStatus() != 0) {
						System.out.println("[ERROR]: response status"
								+ response.getErrorStatus() + " Text:"
								+ response.getErrorStatusText()
								+ " ip is "+ip);
					} else {
						if(ip.equals("192.168.22.226")){
							System.out.println();
						}
						System.out.println("Received response Success!!!"+"       ip:"+ip);
						CapEbu capEbu = new CapEbu();
						capEbu.setEbuIp(ip);
						List<OidData> oidDatas = new ArrayList<OidData>();
						for (int i = 0; i < response.size(); i++) {
							VariableBinding vb = response.get(i);
							OidData oidData = new OidData();
							oidData.setOid(vb.getOid().toString());
							oidData.setValue(vb.getVariable().toString());
							oidDatas.add(oidData);
						}
						if(Beans.isNotEmpty(oidDatas) && oidDatas.size()>0){
							for(OidData oidData : oidDatas){
								OidTranslatorUtil.oidvalueConvertToName(oidData, capEbu);
							}
						}
						if(!distinctIp.containsKey(ip)){
							distinctIp.put(ip, new Object());
							capEbus.add(capEbu);
							System.out.println("capEbus.size():"+capEbus.size());
						}
					}
					synchronized (lock) {
						responseCounter++;
						System.out.println("responseCounter++:"+responseCounter);
					}
				}
			};
			for(int i=0; i<ipsAddress.size(); i++){
				address = protocol + ":" + ipsAddress.get(i) + "/" + port;
				target = createCommunityTarget(address, community, version, 1000L, 5);
				snmp.send(pdu, target, null, listener);
				System.out.println("asynchronous send pdu wait for response...");
			}
			long baselineTime = System.currentTimeMillis();
			while(responseCounter < ipsAddress.size()){
				long sendedTime = System.currentTimeMillis();
				//如果逗留时间超过5秒，有可能是网络原因或者其他原因，导致响应不会到达监听器，为避免死循环，则应马上结束循环。
				if(sendedTime-baselineTime>5000){
					break;
				}
				TimeUnit.MILLISECONDS.sleep(1000);
			}
			
			return capEbus;
		} catch (Exception e) {
			System.out.println("SNMP GetNext Exception:" + e);
		}finally{
			snmp.close();//扫描结束后，得立刻关掉snmp，否则监听器的线程将一直处于wait状态，任务数过多的话，线程创建也将越来越多，最终导致系统崩溃
			transport.close();
		}
		return null;
	}
	
}