截断二进制指数退避算法（JAVA版）

之前在网上看到有关于这个算法的C++版本，自己动手写了个JAVA版本的，内容基本差不多，做了一些修改。下面是代码：

/*
 * 截断二进制指数退避算法：
 * （1）协议规定了基本退避时间为争用期2t,具体的争用期时间是51.2us。对于10Mb/s以太网
 * ，在争用期内可发送512bit，即64字节。也可以说争用期是512比特时间。1bit时间就是发送
 * 1bit所需的时间。所以这种时间单位与数据率密切相关。
 * （2）从离散的整数集合[0，1，...（2的k次方-1）]中随机取出一个数，记为r。重传应推后
 * 的时间就是r倍的争用期。上面的参数k = Min[重传次数，10]
 * （3）当重传达16次仍不能成功时（这表明同时打算发送数据的站太多，以致连续发生冲突），则
 * 丢弃该帧，并向上层报告。
 */
package com.fromjava;
import java.util.Random;


public class TheTruncatedBinaryExponentialBackoffAlgorithm {

	static final double contentionPeriod = 51.20;

	public static void main(String[] args) {
		
		System.out.println("***截断二进制退避指数算法演示***");
		int k = 0; // 用以表示重传的次数
		int p = 56; // 用于自己设置发生碰撞的概率
		if(args.length>0)
		{
			p= Integer.parseInt(args[0]);
		}
		System.out.println("每次传送发生碰撞的概率为p%,请输入p的值" + "(范围为0到100之间的整数）："+p);
		System.out.println();
		while (true) {
			if(getRand(1,100)<=p) //如果发生碰撞，其概率为p%
			{
				k++;
				if (k <= 16) // 最大重传送次数为16
				{
					System.out.println("***发生碰撞!" + "准备进行第" + k + "次重传！***");
				    resend(k);
					continue;
				}
				if (k > 16) {
					System.out.println("重传16次仍未成功，丢弃本帧，向高层报告！");
					break;
				}
			}
			if(getRand(1,100)>p) //如果没有发生碰撞，其概率为1-p%
			{
				System.out.println("本次未发生碰撞，传送成功！！共重传" + k + "次。");
				break;
			}
		}
	}

	static int getRand(int min, int max) // 得到min到max之间的一个随机数
	{
		int r ;
		Random random = new Random();
		r=random.nextInt(max-min+1)+min;	
		return r ;
	}

	static int twoPowerK(int k) // 二的k次幂
	{
		int a = 2;
		int f = 1;
		for(int i = k ; i>0 ;i --)
		{ f *= a; }
		return f;
	}

	static int resend(int i) { 
		// 第i次重传操作，计算重传退避时间，等待后重传(具休实现未定义，仅用于演示，显示退避时间)
		int r = 0 , max = 0;
		double backTime;
		System.out.println("开始退避操作！");
		if (i <= 10)
			max = twoPowerK(i) - 1;
		if (i > 10) 
		{
			System.out.println("重传次数超过10，从10截止。");
			max = twoPowerK(10) - 1;
		}
	    System.out.println("随机数范围:"+"0到"+max);
		r=getRand(0,max);
		System.out.println("得到的随机数r为:"+r);
		backTime = r * contentionPeriod;
		System.out.println("退避时间为:"+"51.2*"+r+"="+backTime+"微秒");
		try {
			Thread.sleep((long)(backTime/1000)); //暂停200毫秒
		} catch (InterruptedException e) {
			e.printStackTrace();
		} 
		System.out.println("退避完成，开始重传！");
		System.out.println();
		return 0;
	}
}

相信看了这个算法的特点，大家也应该明白为什么这么写了，我就不多说了！