分槽ALOHA协议仿真实验 中南大学Word格式.docx

分槽ALOHA协议仿真实验 中南大学Word格式.docx

《分槽ALOHA协议仿真实验 中南大学Word格式.docx》由会员分享，可在线阅读，更多相关《分槽ALOHA协议仿真实验 中南大学Word格式.docx（11页珍藏版）》请在冰豆网上搜索。

本次实验写的是分槽aloha，就是将时间分成离散的间隔，每个数据包只能在时间槽的起点发送。

本次实验的目的是1.掌握VB、VC++、VS或JAVA等集成开发环境编写仿真程序的方法；

2.理解并掌握分槽ALOHA协议原理。

二、实验内容与实现原理

实验内容：

编写仿真程序，对一定网络环境下MAC层的多路访问协议的分槽ALOHA协议进行实现。

通过仿真，学习协议采取的介质访问管理，包括介质分配和冲突解决机制，并对协议的性能与理论结果进行比较分析。

实验原理：

分槽Aloha的基本思想是把信道时间分成离散的时间槽，槽长为一个帧所需的发送时间。

每个站点只能在时槽开始时才允许发送。

其他过程与纯ALOHA协议相同。

分槽Aloha的信道效率比纯Aloha要高。

分槽Aloha的易受冲突区比纯Aloha小了一半。

它的重发策略是等待一段随机的时间，然后重发；

如再次冲突，则再等待一段随机的时间，直到重发成功为止，但是发送的时间也是在每个时间槽的开始。

三、实验具体设计

代码包括六个类：

AlohaThread.java,jsp_1.java,jsq.java,SendPot.java,time.java,Main.java。

Main.java是主类。

主要是负责时间槽的初始化，以及多个线程的启动。

SendPot.java是发送站类。

里面包含了开始发送数据的时间，时间的间隔，以及成功发送完所有数据包的发送次数。

AlohaThread.java是实现了Thread接口的类。

他是Aloha的线程，run方法里面写了判断冲突的方法和数据包发送的计数方法。

每一个线程都是一个SendPot的发送过程。

sq.java也是实现了Thread接口的类。

他是一个计数器，每隔20秒加一，是用来计算现在已经到了第几个时间槽的。

关键代码说明

a、时间槽的计数，每隔20ms加一

while（true）{

try{

N=N+1;

Thread.sleep（20）;

}catch（InterruptedExceptione）{

e.printStackTrace（）;

}

}

b、发送时间以及间隔时间归并到时间槽的开始

publiclonggetStartT（）{

returnstart/20+1;

}

publiclonggetDt（）{

returnd/20+1;

四、实验结果

……

因实验结果过长，只选取部分内容。

五、实验设备与实验环境

Windows操作系统，JDK1.7，使用的软件为eclipse。

六、实验总结

在本次实验的过程中，我觉得我不仅学到了关于Aloha的知识，也学到了对数据的处理以及测试程序的知识。

这次的实验让我对分槽Aloha有了更加深刻的了解，同时也更加熟练掌握了JAVA程序设计语言的运用。

七、源代码：

packageAloha;

importjava.util.ArrayList;

publicclassMain{

publicstaticvoidmain（String[]args）{

int[]a=newint[10000];

for（inti=0;

i<

100000;

i++）{

timet=newtime（）;

t.setN（i）;

t.setCount（0）;

a.length;

a[i]=0;

SendPotsp1=newSendPot

（1）;

SendPotsp2=newSendPot

（2）;

SendPotsp3=newSendPot（3）;

SendPotsp4=newSendPot（4）;

SendPotsp5=newSendPot（5）;

SendPotsp6=newSendPot（6）;

jsp_1j=newjsp_1（）;

j.start（）;

AlohaThreadat1=newAlohaThread（sp1,j,a）;

AlohaThreadat2=newAlohaThread（sp2,j,a）;

AlohaThreadat3=newAlohaThread（sp3,j,a）;

AlohaThreadat4=newAlohaThread（sp4,j,a）;

AlohaThreadat5=newAlohaThread（sp5,j,a）;

AlohaThreadat6=newAlohaThread（sp6,j,a）;

at1.start（）;

at2.start（）;

at3.start（）;

at4.start（）;

at5.start（）;

at6.start（）;

}

importjava.util.Random;

publicclassAlohaThreadextendsThread{

privateSendPotsp;

privateRandomr=newRandom（）;

privatelongtemp;

privatejsp_1j;

privateint[]a;

publicAlohaThread（SendPotsp,jsp_1j,int[]a）{

this.sp=sp;

this.j=j;

this.a=a;

publicvoidrun（）{

try{

Thread.sleep（sp.getStart（））;

}catch（InterruptedExceptione1）{

e1.printStackTrace（）;

100;

a[j.getN（）]=a[j.getN（）]+1;

Thread.sleep

（1）;

//冲突

while（a[j.getN（）]>

1）{

temp=r.nextInt（5）+1;

Thread.sleep（temp*20）;

System.out.println（sp.getNum（）+"

冲突"

）;

System.out.println（"

发送成功:

第"

+sp.getNum（）+"

号第"

+i+"

个数据包~"

Thread.sleep（sp.getD（））;

}catch（Exceptione）{

publicclassjsp_1extendsThread{

privateintN;

while（true）{

}

publicintgetN（）{

returnN;

publicclassjsqextendsThread{

privatelongt;

t=t+1;

publiclonggetT（）{

returnt;

publicclassSendPot{

privateintNum;

//开始发送时间

privatelongstart;

//时间间隔

privatelongd;

publicSendPot（intNum）{

this.Num=Num;

start=r.nextInt（1000）;

d=r.nextInt（30）+20;

publicintgetNum（）{

returnNum;

publiclonggetStart（）{

return（start/20+1）*20;

publiclonggetD（）{

return（d/20+1）*20;

publicclasstime{

//第N个时槽

//需要发送的数目

privateintcount;

publicintgetN（）{

publicvoidsetN（intn）{

N=n;

publicintgetCount（）{

returncount;

publicvoidsetCount（intcount）{

this.count=count;