(计算机网络)JAVA实现分槽ALOHA协议仿真实验

用于在多路访问信道上确定下一个使用者的协议属于数据链路层的一个子层，称为介质访问控制（Medium Access Control，MAC）子层，许多局域网都使用多路访问信道作为它的通信基础。最简单的信道分配方案是FDM（为每个站专门分配一段频率）和TDM（为每个站分配一个时槽），当站的数量比较大而且可变，或者流量具有突发性变化的时候，就需要用到纯ALOHA协议或分槽ALOHA协议。如果信道的状态可以被检测到，可以用到1-坚持型CSMA、非坚持CSMA和P-坚持CSMA等协议。

设置各站点初始产生包的时间点及产生包的时间间隔（均为随机值），得到所有站点成功发送10000个数据包的总时间以及这段时间内所有数据包的个数（包括各站点每次新产生的包以及由于冲突而重发的包），从而计算出每包时内尝试次数及其对应的吞吐量。针对不同的包产生间隔，得到不同的每包时内尝试次数及其对应的吞吐量，将其画成一条曲线。

一、 实现原理

实现原理：分槽Aloha的基本思想是把信道时间分成离散的时间槽，槽长为一个帧所需的发送时间。每个站点只能在时槽开始时才允许发送。其他过程与纯ALOHA协议相同。分槽Aloha的信道效率比纯Aloha要高。分槽Aloha的易受冲突区比纯Aloha小了一半。它的重发策略是等待一段随机的时间，然后重发；如再次冲突，则再等待一段随机的时间，直到重发成功为止，但是发送的时间也是在每个时间槽的开始。

二、 具体设计

代码包括五个类：
AlohaThread.java, CountslotNum.java, SendPot.java,time.java, Main.java。
Main.java是主类。主要是负责时间槽的初始化，以及多个线程的启动。
SendPot.java是发送站类。负责初始化每个站点发送的时间、时间间隔，其中包括槽时间间隔以及真正的时间间隔。
AlohaThread.java是实现了Thread接口的类。他是Aloha的线程，run方法里面写了判断冲突的方法和数据包发送的计数方法。每一个线程都是一个SendPot的发送过程。
CountslotNum.java同样实现了Thread接口的类。它的功能是用来记录时间槽进行的时间。
1.Main.java

package Aloha;

import java.util.ArrayList;

public class Main {

public static void main(String[] args){

int[] a = new int[10000];

for (int i = 0; i < 100000; i++) {
time t = new time();
t.setN(i);
t.setCount(0);
}
for (int i = 0; i < a.length; i++) {
a[i] = 0;
}

SendPot sp1 = new SendPot(1);
SendPot sp2 = new SendPot(2);
SendPot sp3 = new SendPot(3);
SendPot sp4 = new SendPot(4);
SendPot sp5 = new SendPot(5);
SendPot sp6 = new SendPot(6);

CountslotNum c = new CountslotNum();
c.start();

AlohaThread at1 = new AlohaThread(sp1,c,a,100);
AlohaThread at2 = new AlohaThread(sp2,c,a,100);
AlohaThread at3 = new AlohaThread(sp3,c,a,100);
AlohaThread at4 = new AlohaThread(sp4,c,a,100);
AlohaThread at5 = new AlohaThread(sp5,c,a,100);
AlohaThread at6 = new AlohaThread(sp6,c,a,100);

at1.start();
at2.start();
at3.start();
at4.start();
at5.start();
at6.start();

}
}

2.AlohaThread.java

package Aloha;
import java.util.Random;

public class AlohaThread extends Thread{

private SendPot sp;
private Random r = new Random();
private long temp;
private CountslotNum c;
private int[] a;
private int num;
private int count=0;
public AlohaThread(SendPot sp,CountslotNum c,int[] a,int num){
this.sp = sp;
this.c = c;
this.a = a;
this.num=num;
}

public void run(){

try {
Thread.sleep(sp.mtime());
} catch (InterruptedException e1) {
e1.printStackTrace();
}

for (int idx = 0; idx < num; idx++) {

a[c.getN()] = a[c.getN()]+1;//冲突

try {
Thread.sleep(1);

//冲突回退
while(a[c.getN()]>1) {
temp = r.nextInt(5)+1;
long next_time=temp+c.getN();
count++;
System.out.println(sp.getNum()+"冲突,下一次发送的时间点为:"+next_time);
System.out.println(sp.getNum()+"的第"+count+"冲突");
Thread.sleep(temp*20);
}

long next_time=c.getN()+sp.getDT();
System.out.println("发送成功:第"+sp.getNum()+"号第"+idx+"个数据包~"+"下一次发送的时间点为:"+next_time);
Thread.sleep(sp.getD());

if(idx==num-1){
count=count+num;
double t1=count*sp.getDT();
double traffic=t1/c.getN();

System.out.println("第"+sp.getNum()+"号每包时内传输次数:"+traffic);
double t2=num*sp.getDT();
double thoughput=t2/c.getN();
System.out.println("第"+sp.getNum()+"号吞吐量:"+thoughput);

}
} catch (Exception e) {
}

}

}
}

3.SendPot.java

package Aloha;
import java.util.Random;

public class SendPot {

private Random r = new Random();
private int Num;
//开始发送时间
private long mgtime;
//时间间隔
private long d;
private long slot=20;//槽时间间隔

public SendPot(int Num){
this.Num = Num;
mgtime = r.nextInt(1000);
d = r.nextInt(30)+20;
}

public int getNum() {
return Num;
}

public long mtime() {
return (mgtime/slot+1)*slot;//各站点数据包发送时间点，归并到时槽的开始处
}

public long getD() {//真正间隔时间
return (d/slot+1)*slot;
}
public long getDT() {//间隔槽片段
return (d/slot+1);
}

}

4.CountslotNum.java

package Aloha;
public class CountslotNum extends Thread{
private int N;
public static int timecount=20;
public static void main(String[] args){
CountslotNum j=new CountslotNum();
j.start();

}
public void run(){//时间槽的计数，在这里时间槽按照线性事件递增，为一独立进程

while(true){
try {
N = N+1;
System.out.println("时间槽计数:"+N);
Thread.sleep(timecount);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

public int getN(){

return N;
}

}

5.time.java

package Aloha;

public class time {

//第N个时槽
private int N;
//需要发送的数目
private int count;
public int getN() {
return N;
}
public void setN(int n) {
N = n;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}

}