java 多线程的一个例子

这个 例子是在IBM的一个文章中找到的，http://www.ibm.com/developerworks/cn/java/j-lo-concurrent-frmk/index.html

我只是作出了自己的实现，虽然比不上别人，但是也算是学习了

先贴代码：

<?xml version="1.0" encoding="UTF-8"?>
<threadlist>
	<thread-ins thread-id="1"/>
	<thread-ins thread-id="2">
		<pre-threadID>1</pre-threadID>
	</thread-ins>
	<thread-ins thread-id="3">
		<pre-threadID>2</pre-threadID>
	</thread-ins>
	<thread-ins thread-id="4">
		<pre-threadID>2</pre-threadID>
		<pre-threadID>3</pre-threadID>
	</thread-ins>
	<thread-ins thread-id="5">
		<pre-threadID>3</pre-threadID>
	</thread-ins>
	<thread-ins thread-id="6">
		<pre-threadID>4</pre-threadID>
		<pre-threadID>5</pre-threadID>
	</thread-ins>
	<thread-ins thread-id="7">
		<pre-threadID>6</pre-threadID>
	</thread-ins>
</threadlist>

 这个是xml的格式，这个xml表示了线程之间的依赖关系

我的结构上是ThreadEntity

代码如下

package com.simple;

import java.util.HashMap;
import java.util.Map;

public class ThreadEntity {

	private Integer threadID;
	
	private Map<Integer,ThreadEntity> preEntities;

	private Thread process;
	
	private boolean ready = false;
	
	public ThreadEntity(){
		preEntities = new HashMap<Integer, ThreadEntity>();
		process = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("this ThreadEntity ID:" + ThreadEntity.this.threadID);
			}
		});
	}
	
	public void runProcess(){
		
		if(process.getState() == Thread.State.NEW){
			process.start();
		}
	}
	
	public Integer getThreadID() {
		return threadID;
	}

	public void setThreadID(Integer threadID) {
		this.threadID = threadID;
	}

	public Map<Integer, ThreadEntity> getPreEntities() {
		return preEntities;
	}
	
	public void addPreEntity(ThreadEntity te){
		this.preEntities.put(te.getThreadID(), te);
	}
	
	public boolean isReady(){
		return this.ready;
	}
	public void setReady(boolean Flag){
		this.ready = Flag;
	}
	public Thread.State getState(){
		return process.getState();
	}
}

 下面是一个list存放ThreadEntity

package com.simple;

import java.util.List;

/**
 * 描述：
 * @author tippy
 * @date 2011-5-15
 */
public class ThreadList {

	private List<ThreadEntity> threadlist;

	public List<ThreadEntity> getThreadlist() {
		return threadlist;
	}

	public void setThreadlist(List<ThreadEntity> threadlist) {
		this.threadlist = threadlist;
	}
	
	
}

 最后是解析xml的代码，对了解使用java自带的dom解析xml的可以不看

 

package com.support;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.simple.ThreadEntity;

//用Java自带的xml parser进行解析xml文档
public class SimpleParse {

	
	
	public SimpleParse(){
	}
	//算法采用的是，如果这个element有pre-thread 那么就递归，解析pre-thread 对应的threadins
	public static List<ThreadEntity> parseSimpleXML(){
		DocumentBuilderFactory domfac = DocumentBuilderFactory.newInstance();
		InputStream is = null;
		//store the ThreadEntity
		List<ThreadEntity> threadList = new ArrayList<ThreadEntity>();
		try{
			DocumentBuilder dombuilder = domfac.newDocumentBuilder();
			is = Thread.currentThread().getContextClassLoader().getResourceAsStream("simple.xml");
			
			Document doc = dombuilder.parse(is);
			Element rootElt = doc.getDocumentElement();
			//get threadins nodes
			NodeList threadNodes = rootElt.getChildNodes();
			//store the node which has been acess
			Map<Node,ThreadEntity> threadMap = new HashMap<Node,ThreadEntity>();
			
			if(threadNodes != null)
			{
				//iterator the threadins
				for(int i = 0;i < threadNodes.getLength();i++){
					Node threadins = threadNodes.item(i);
					if(threadins.getNodeType() == Node.ELEMENT_NODE){
						threadList.add(parseSimpleNode(threadins, threadMap, threadNodes));
					}	
				}
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			if(is != null){
				try {
					is.close();
				} catch (IOException e) {
					System.out.println("close is 失败");
				}
			}
		}
		return threadList;
	}
	
	static ThreadEntity  parseSimpleNode(Node currNode,Map<Node,ThreadEntity> historyNodes,NodeList threadNodes){
		
		ThreadEntity currEntity = historyNodes.get(currNode);
		//is not exist these nodes
		if(currEntity == null){
			//create a new Instance
			currEntity = new ThreadEntity();
			//set this entity id
			currEntity.setThreadID(Integer.parseInt(currNode.getAttributes().getNamedItem("thread-id").getNodeValue()));
			//get the pre-threadID Nodes
			NodeList preNodes = currNode.getChildNodes();
			if(preNodes != null && preNodes.getLength() != 0){
				for(int i = 0;i<preNodes.getLength();i++){
					//get current preNode child
					Node preNode = preNodes.item(i);
					//if exit child element pre-threadID 
					if(preNode.getNodeType() == Node.ELEMENT_NODE){
						currEntity.setReady(false);
						Node threadNode = checkNode(preNode.getTextContent(),threadNodes);
						ThreadEntity preEntity = parseSimpleNode(threadNode, historyNodes, threadNodes);
						currEntity.addPreEntity(preEntity);
					}
				}
			}
			//put this entity to history
			historyNodes.put(currNode, currEntity);
		}
		return currEntity;
	}

	/**
	 *描述：
	 *2011-5-15
	 */
	private static Node checkNode(String  attrValue, NodeList threadNodes) {
		Node wishNode = null;

		for(int i = 0;i<threadNodes.getLength();i++){
			Node currNode = threadNodes.item(i);
			if(currNode != null &&currNode.getNodeType() == Node.ELEMENT_NODE && currNode.getAttributes().getNamedItem("thread-id").getNodeValue().equals(attrValue)){
				wishNode = currNode;
				break;
			}
		}
		if(wishNode == null){
			throw new RuntimeException();
		}

		return wishNode;
	}
}

  测试代码

package com.simple.test;


import java.lang.Thread.State;
import java.util.Map;

import org.junit.BeforeClass;
import org.junit.Test;

import com.simple.ThreadEntity;
import com.simple.ThreadList;
import com.support.SimpleParse;

public class SimpleThreadCase {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}
	//测试解析结果的代码
	@Test
	public void testParseSimpleXML(){
		ThreadList threadlist = new ThreadList();
		threadlist.setThreadlist(SimpleParse.parseSimpleXML());
		StringBuilder builder = new StringBuilder();
		builder.append("<threadlist>\r\n");
		for(ThreadEntity te : threadlist.getThreadlist()){
			builder.append("\t<threadins thread-id=\""+te.getThreadID()+"\">\r\n");
			for(Map.Entry<Integer, ThreadEntity> entity : te.getPreEntities().entrySet()){
				builder.append("\t\t<pre-threadID>" + entity.getKey() + "</pre-threadID>\r\n");
			}
			builder.append("\t</threadins>\r\n");
		}
		builder.append("</threadlist>");
		System.out.println(builder.toString());
	}
	//测试运行7线程的结果显示
	@Test
	public void testThreadCase(){
		ThreadList threadlist = new ThreadList();
		threadlist.setThreadlist(SimpleParse.parseSimpleXML());
		
		ThreadEntity target = getByID(threadlist, 7);
		runThread(target);
		
	}
	//运行7的算法
	private void runThread(ThreadEntity te){
		
		//如果没有准备好，先run pre的线程
		while(!te.isReady())
		{
			boolean Flag = true;
			for(Map.Entry<Integer, ThreadEntity> entry:te.getPreEntities().entrySet()){
				ThreadEntity preEntity = entry.getValue();
				Flag = preEntity.getState()==State.TERMINATED? (Flag && true):false;
				runThread(preEntity);
			}
			if(Flag){//preThread已经运行完毕
				te.setReady(true);
			}
		}
		te.runProcess();
	}
	
	private ThreadEntity getByID(ThreadList threadlist,int id){
		
		ThreadEntity entity = null;
		
		for(ThreadEntity aentity : threadlist.getThreadlist()){
			if(aentity.getThreadID() == id){
				entity = aentity;
				break;
			}
		}
		if(entity == null){
			throw new RuntimeException("can not found the EntityID" + id + ",in the threadList");
		}
		return entity;
	}
}

  运行结果，testThreadCase 的结果

this ThreadEntity ID:1
this ThreadEntity ID:2
this ThreadEntity ID:3
this ThreadEntity ID:4
this ThreadEntity ID:5
this ThreadEntity ID:6
this ThreadEntity ID:7