这个 例子是在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