nodetimer.java

java B++树 一个很好的算法来实现这些问题 推荐！

package mddb.client;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import mddb.packets.*;
import java.io.*;
import mddb.client.components.*;

//用于保存节点的全部定时器
public class NodeTimer
    implements ActionListener {
    long times = 0;

    ClientNode node;

    javax.swing.Timer updatePositionTimer, //位置更新定时器
        delayTimer,
        rmTimer,
        helloBroadcastTimer; //广播定时器
    int updatePositionTime, delayTime, rmTime, helloBroadcastTime;

    public NodeTimer( Properties timerSettings, ClientNode node ) {
        this.node = node;
        //从属性文件中得到各个计时器的时延
        updatePositionTime = Integer.parseInt( timerSettings.getProperty(
            "updatePositionTime" ) );
        delayTime = Integer.parseInt( timerSettings.getProperty( "delayTime" ) );
        rmTime = Integer.parseInt( timerSettings.getProperty( "rmTime" ) );
        helloBroadcastTime = Integer.parseInt( timerSettings.getProperty(
            "helloBroadcastTime" ) );
    }

    //--------------------------------------------------------------------------
    public void OnOverUpdatePositionTime() {
        node.updateLocalPosition(); //节点更新自己的位置,实际的更新过程由DemoManger控制
        node.timeStamp = System.currentTimeMillis();
        node.nodeState = ParentNode.HELLO_STATUS;
        try {
            ArrayList temp = new ArrayList();
            temp.add( node.position ); //包的起始地址
            temp.add( new Point( -1, -1 ) ); //包的终止地址
            MddbPacket mp = new MddbPacket( new Point( node.position ),
                                            node.ID,
                                            new Point( -1, -1 ),
                                            ParentNode.ANY_DISTANCE,
                                            temp,
                                            MddbPacket.NET_HELLO );
            mp.setData( String.valueOf( node.masterId ) ); //必须要先进行SetData才行
            node.pkgSender.sendNetPacket( mp, MddbPacket.FRAME_GROUP_PKG );
        }
        catch( IOException ioe ) {
            ioe.printStackTrace();
            return;
        }
        startHelloBroadcastTimer();
        System.out.println( "UpdatePositionTimer已经结束,BroadcastTimer重新开始" );
    }

    //--------------------------------------------------------------------------
    public void OnOverHelloBroadcastTime() {
        //结束HelloBoradcastTimer定时器
        if( helloBroadcastTimer != null ) {
            if( helloBroadcastTimer.isRunning() ) {
                helloBroadcastTimer.stop();
            }
            helloBroadcastTimer = null;
        }
        node.nodeState = ParentNode.RM_STATUS;
        //让m_RHELLOList中所有节点成为自己的邻居
        for( int i = 0; i < node.m_RHELLOList.size(); i++ ) {
            MddbPacket mp = ( MddbPacket )node.m_RHELLOList.get( i );
            //获得RHELLO包中的发送节点的Id,MasterId,与发送结点的距离
            long[] info = this.getInfo( mp );
            node.nebrList.add( info[0], info[1], mp.getSrcAddr() );
        }
        //如果自己的master不在邻居中就让自己成为孤点
        if( !node.isMaster() &&
            !node.getMemberList().contains( new Long( node.getMasterId() ) ) ) {
            node.mkAcnode();
            //删除成员表中既不是自己，又不在邻居表中的成员
        }
        if( node.isMaster() ) {
            ArrayList temp = new ArrayList();
            for( int i = 0; i < node.mbrList.getSize(); i++ ) {
                long memId = node.mbrList.getMbrId( i );
                if( !node.nebrList.contains( new Long( memId ) ) ) {
                    if( memId != node.ID ) {
                        temp.add( new Integer( i ) );
                    }
                }
            }
            for( int j = 0; j < temp.size(); j++ ) {
                node.mbrList.remove( ( ( Integer )temp.get( j ) ).intValue() );
            }
        }
        //如果是孤点
        if( node.isAcnode() ) {
            int theNodeIndex = getAppropriateGroup();
            if( theNodeIndex >= 0 ) { //如果存在--发送RM包,启动RM计时器
                MddbPacket thePack = ( MddbPacket )node.m_RHELLOList.get(
                    theNodeIndex );
                sendRMPacket( thePack );
                startRMTimer();
                return;
            }
            else { //不存在距离在有效覆盖范围的，不是孤点的，成员数最多的组
                int acnodeIndex = getAcnodeInValidRangeMinId();
                if( acnodeIndex >= 0 ) {
                    MddbPacket thePack = ( MddbPacket )node.m_RHELLOList.get(
                        acnodeIndex );
                    sendRMPacket( thePack );
                    startRMTimer();
                    return;
                }
            }
        }
        startRMTimer();
        OnOverRMTime();
        System.out.println( "HelloBroadcastTimer已经结束,RMTimer启动后直接结束" );
    }

    //返回m_RHELLOList中与本节点的距离在有效覆盖范围的，不是孤点的，成员数最多的组
    //若有多个选择标识最小的不存在返回-1
    public int getAppropriateGroup() {
        if( node.m_RHELLOList.size() <= 0 ) {
            return -1;
        }
        long minMasterId = Long.MAX_VALUE, tempMasterId;
        int mxMemberAmount = -1, tempMemAmount; //成员数量
        int distance = -1, tempDis; //与Hello发送者之间的距离
        int index = -1;
        for( int i = 0; i < node.m_RHELLOList.size(); i++ ) {
            StringTokenizer data = new StringTokenizer(
                ( ( MddbPacket )node.m_RHELLOList.get( i ) ).getData(), "@" );
            tempMasterId = Long.parseLong( data.nextToken() );
            tempMemAmount = Integer.parseInt( data.nextToken() );
            tempDis = Integer.parseInt( data.nextToken() );
            if( tempDis <= node.validRange ) { //该节点在有效范围内
                if( tempMemAmount > 1 ) { //该节点不是孤点
                    if( tempMemAmount > mxMemberAmount ) { //成员最多
                        minMasterId = tempMasterId;
                        mxMemberAmount = tempMemAmount;
                        index = i;
                    }
                    else if( tempMemAmount == mxMemberAmount ) { //有成员数一样多的情况
                        if( tempMasterId < minMasterId ) { //选择ID小的那一个
                            minMasterId = tempMasterId;
                            index = i;
                        }
                    }
                }
            }
        }
        return index;
    }

    //发送RM包
    private void sendRMPacket( MddbPacket thePack ) {
        MddbPacket mp = new MddbPacket( new Point( node.position ),
                                        node.ID,
                                        new Point( thePack.getSrcAddr() ),
                                        thePack.getPathLength(),
                                        contraryRoutine( thePack ),
                                        MddbPacket.NET_RM,
                                        thePack.getTimeStamp()
                                        );
        mp.setData( "@" );
        try {
            node.pkgSender.sendNetPacket( mp,
                                          MddbPacket.FRAME_GROUP_PKG );
        }
        catch( IOException ioe ) {
            System.out.println( "发送RM失败--在NodeTimer中!" );
            ioe.printStackTrace();
            return;
        }
    }

    //返回在有效覆盖范围内的所有孤点，其中标识小于自己的节点的Index
    private int getAcnodeInValidRangeMinId() {
        long minId = Long.MAX_VALUE;
        int index = -1;
        long tempMasterId, tempMemAmount, tempDis;
        MddbPacket packet;
        synchronized( node.m_RHELLOList ){
            if( node.m_RHELLOList.size() == 0 ) {
                return index;
            }
            for( int i = 0; i < node.m_RHELLOList.size(); i++ ) {
                packet = ( MddbPacket )node.m_RHELLOList.get( i );
                StringTokenizer data = new StringTokenizer(
                    packet.getData(), "@" );
                tempMasterId = Long.parseLong( data.nextToken() );
                tempMemAmount = Integer.parseInt( data.nextToken() );
                tempDis = Integer.parseInt( data.nextToken() );
                if( tempDis <= node.validRange ) { //该节点在有效范围内
                    if( tempMemAmount == 1 && tempMasterId == packet.getSrcId() ) { //是孤点
                        if( packet.getSrcId() < node.ID &&
                            packet.getSrcId() < minId ) {
                            minId = packet.getSrcId();
                            index = i;
                        }
                    }
                }
            }
        }
        return index;
    }

    //对路由求逆
    private ArrayList contraryRoutine( MddbPacket packet ) {
        ArrayList rList = new ArrayList();
        for( int i = packet.getRoutineList().size() - 1; i >= 0; i-- ) {
            rList.add( packet.getRoutineList().get( i ) );
        }
        return rList;
    }

    //--------------------------------------------------------------------------
    public void OnOverRMTime() { //注意在此时节点应该已经成为孤点，所以状态和不是孤点有所区别
        if( rmTimer != null ) {
            if( rmTimer.isRunning() ) {
                rmTimer.stop();
            }
            rmTimer = null;
        }
        sendMIPackToAllNeighbour();
        if( node.isMaster() ) {
            if( node.isAcnode() )
                rebuildGroupAdjListSimple();
            else
                rebuildGroupAdjComplex();
        }