两个问题，一个树，一个线程?

Question

1.线程：如果你线程类的run方法没有循环，运行完run方法线程也自动结束了，不用调用destroy。如果可能产生多个线程实例，最好把它们保存内存中（向量或数组），线程的结束与否最好还是用个标志位来实现。
2.树：不大明白，你的树是序列化的保存到数据库了吗？还是?

Answer 1

1.有循环的，sleep(3000)后又重新开始的
2.树： 树节点数据按照父、子方法保存在数据库中
       树编号按子节点顺序编号
       现在求解是当前选择节点在数据库中的编号及节点数目。

Answer 2

jtree生成的树，不过节点的数据是在数据库中。

Answer 3

GJA106(中文字符) (  )想你所说的，用各向量或数组来保存，设个标志位，以前我也问过这方面的问题，没人可以说清楚，你能否给个具体的实例看看。谢谢！

Answer 4

是这样的，不过我用了一个很笨的方法差不多解决了。
 数据库
   父节点标号 子节点标号 子节点
    100         0              a
    101          100        b
取数据并生成树线程
  1.本线程担当取产品结构管理树模型数据
  2.每隔一定时间取产品模型树数据并生成树显示视图中
  3.功能：提数据，生成树 显示
  */
public class dbTreeThread extends Thread {
    protected  Workbench wb=null;
     String modename=null;
     Vector qry=new Vector();
     Vector ModTreedata=new Vector();//设置一个向量保存数据
      int curr_level=1;
     Stack node_stack = new Stack();
    public dbTreeThread() {
                 }
 public dbTreeThread(Workbench wobe,String modname)throws IOException
    {
     //建立连接，取回数据
     try{
      wb=wobe;
      modename=modname;
      node_stack.push(wb.dbTreeModel.getRoot() );
      }catch(Exception e)
      {System.out.println(e.toString() );}
      }
    public void run()
      {
      while(true)
        {
        Vector tempdata=new Vector();
        tempdata=loadtreeData(modename);
        if(!ModTreedata.equals(tempdata))
           {
             ModTreedata.removeAllElements() ;
           for(int i=0;i<tempdata.size() ;i++)
               ModTreedata.addElement(tempdata.elementAt(i));
          DefaultMutableTreeNode root=(DefaultMutableTreeNode)wb.dbTreeModel .getRoot() ;
          root.removeAllChildren();
          wb.dbTreeModel.setRoot(root);
          createtree(ModTreedata , "trNodeName","trNodepID");
          }
      try{
       dbTreeThread.sleep(3000);
           }catch(InterruptedException e)
                  {
                       System.out.println(e.toString() );
                   }
        }
      }
//提出产品结构树数据,返回产品结构树数据**************************************************************
      public Vector loadtreeData(String modname)
     {
          Vector treedata=new Vector();
           qry.removeAllElements() ;
           String qryCom="modtree";
           qry.add(qryCom);
           qry.add(modname);
         try{
           URLConnection uc=wb.url.openConnection() ;
           uc.setDoInput(true);
           uc.setDoOutput(true);
           uc.setUseCaches(false);
           uc.setRequestProperty("Content-type","application/octet-stream");
          ObjectOutputStream oos=new ObjectOutputStream(uc.getOutputStream());
           oos.writeObject(qry);
           oos.flush() ;
           oos.close() ;
         ObjectInputStream ois=new ObjectInputStream(uc.getInputStream() );
         treedata=(Vector)ois.readObject();
          ois.close() ;
          return treedata;
        }catch( MalformedURLException ee )
         {
         System.err.println( "MalformedURLException caught!" );
         System.err.println( ee.getMessage() );
         ee.printStackTrace( System.err );
         return null;
         }
      catch( IOException eee )
      {
         System.err.println( "IOException caught!" );
         System.err.println( eee.getMessage() );
         eee.printStackTrace( System.err );
       return null;
      }catch( ClassNotFoundException eeee )
      {
         System.err.println( "ClassNotFoundException caught!" );
         System.err.println( eeee.getMessage() );
         eeee.printStackTrace( System.err );
        return null;
       }
     }
//生成产品结构树******************************************************************
  public void createtree(Vector treedata, String lbl,String parcol)
   {
          Hashtable rs_cached=new Hashtable();
          rs_cached=(Hashtable)treedata.elementAt(0);
          //将vector tree还原成hashtable
          //以下将层数据进行整理
         int level = 1;
          int current=100;
      Hashtable elem = new Hashtable();
      elem.put(new Integer(current), new Integer(1));
      while ( level > 0 ) {
        boolean levelFound = false;
        Enumeration keys = elem.keys();
        while (keys.hasMoreElements()) {
          Integer hashkey = (Integer) keys.nextElement();
          int currLevel  = ((Integer) elem.get(hashkey)).intValue();
          if (currLevel == level) {
            current = hashkey.intValue(); levelFound = true; break;
          }
        }
        if (levelFound)
              {
                 Hashtable currow = ((Hashtable) rs_cached.get(new Integer(current)));
                  String label = (String) currow.get(lbl);
                  elem.remove(new Integer(current));
                 int children = 0;
                  Enumeration rskeys = rs_cached.keys();
               while (rskeys.hasMoreElements())
                         {
                       Integer currKey = (Integer) rskeys.nextElement();
                         Hashtable testRow = (Hashtable) rs_cached.get(currKey);
                        int parent_id = ((Integer) testRow.get(parcol)).intValue();
                      if (parent_id == current)
                                {
                              elem.put(currKey, new Integer(level + 1));
                               children++;
                                   }
                           }
                  addNode(level,children,label.trim() );
                  level++;
                 }
                else{
                    level--;
                    }
       }    }
     void addNode (int level, int children, String label) {
    for (int i = curr_level; i > level; i--) {
            node_stack.pop();
    }
   DefaultMutableTreeNode new_node = new DefaultMutableTreeNode(
label);
    DefaultMutableTreeNode current =
        (DefaultMutableTreeNode) node_stack.peek();
    current.add(new_node);
    if (children != 0) {
        node_stack.push(new_node);
    }
    curr_level = level;
  }
  }
得到当前节点在数据库中编号，我是找到路径后进行查找的。
TreeNode pathNode[]=selectedNode.getPath() ;
//处理从模型库中查到所要结点的号***************************************************
public  int  pNodeID(Vector Treedata,Vector pathdata)
       {
       int col=pathdata.size() ;
       String pathNode[]=new String[col];
       for(int i=0;i<col;i++)
       pathNode[i]=String.valueOf(pathdata.elementAt(i));
       Vector tdata=new Vector();
       tdata=Treedata;
       Hashtable trdata=new Hashtable();
       trdata=(Hashtable)tdata.elementAt(0);
       Enumeration trkeys =trdata.keys() ;
      int num=trdata.size() ;
       String Currlbl[]=new String[num];
         int   parent_id[]=new int[num];
          int currId[]=new int[num];
             int  n=0;
               while (trkeys.hasMoreElements())
                         {
                    Integer  currKey = (Integer) trkeys.nextElement();
                     currId[n]=currKey.intValue();
                         Hashtable testRow = (Hashtable) trdata.get(currKey);
                        Currlbl[n]=testRow.get("trNodeName").toString() ;
                        parent_id[n]=((Integer)testRow.get("trNodepID")).intValue() ;
                      n++;
                       }
                      //对数据进行查找到号
                      int newnodeparentid=0;
                       int tempid=0;
                         for(int m=0;m<pathNode.length;m++)
                            {
                           for(int  j=0;j<num;j++)
                                {
                          if  ((parent_id[j]==tempid)&&(Currlbl[j].equals(pathNode[m].toString() )))                                  {
                                  tempid=currId[j];                                  }
                             }
                             }                   /*for(int  i=0;i<num;i++)
                       {
                       if(Currlbl[i].equals(selectedNode.toString() ))
                          {
                          newnodeparentid=currId[i];
                          }
                      

Answer 5

树差不多我想就这样了，但是线程不是很有信心?谁给我详细说说java线程原理，与一个类的主要区别，就是上面的dbTreeThread这个线程，因为我要传一个数据后才启动它，所以我没办法在workbench初始化这个线程类，只是在某个打开它的地方进行创建实例，但是我另外的地方要关闭这个线程，我不知如何办?