权重选择算法Java实现

 我们有时候会遇到这种需求，那就是根据权重，按照比例去获取相应的信息，比如配置信息获取，负载均衡RS获取等。

 在此就举一个例子，然后简单的实现。

需求：后端有三台机器，信息分别为，

S1<ip:"10.0.0.1",port:8081,weight:20>,

S2<ip:"10.0.0.2",port:8082,weight:40>, 

S3<ip:"10.0.0.3",port:8083,weight:60>，

根据weight按照比例返回响应的机器信息。

   算法思路：将三个权重映射到一个一维空间中，那么S1对应区间[0, 20), S2对应区间[20, 60), [60, 120]，然后在[0,120]之间生成随机数，看此数落在哪个区间，那么就返回对应机器的信息。

talk is cheap, show me the code:

private int getServerByWeight(int[] weightArr) {
int[][] randArr = new int[weightArr.length][2];
int totalRank = 0;
int index = 0;
for(int i=0;i<weightArr.length;i++) {
if (weightArr[i] <= 0) {
continue;
}

totalRank += weightArr[i];
randArr[i][0] = i;
randArr[i][1] = totalRank;
}

int hitRank = new Random().nextInt(totalRank) + 1;//[1, totalRand]
for (int i = 0; i < randArr.length; i++) {
if (hitRank <= randArr[i][1]) {
return randArr[i][0];
}
}

return randArr[0][0];
}

public Server choose(List<Server> serverList) {
if (null == serverList) {
return null;
}

int[] weightArr = new int[serverList.size()];

for(int i = 0; i < serverList.size(); i++) {
if (serverList.get(i).getWeight() > 0) {
weightArr[i] = serverList.get(i).getWeight();
}
}

if (weightArr.length == 0) {
return null;
}

int chosenIndex = getServerByWeight(weightArr);
return serverList.get(chosenIndex);
}

主要有两个函数：choose和getServerByWeight。测试代码如下：

WeightAllocationAlg.java:

import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

/**
* Created by iqiyi on 2017/10/17.
*/

class Server {
private String ip;

private int port;

private int weight;

public Server(String ip, int port, int weight) {
this.ip = ip;
this.port = port;
this.weight = weight;
}

public String getIp() {
return ip;
}

public void setIp(String ip) {
this.ip = ip;
}

public int getPort() {
return port;
}

public void setPort(int port) {
this.port = port;
}

public int getWeight() {
return weight;
}

public void setWeight(int weight) {
this.weight = weight;
}

public String toString() {
return "ip : " + ip + ", port : " + port + ", weight : " + weight;
}
}

public class WeightAllocationAlg {

private AtomicInteger[] completedCount = new AtomicInteger[3];

public WeightAllocationAlg() {
completedCount[0] = new AtomicInteger(0);
completedCount[1] = new AtomicInteger(0);
completedCount[2] = new AtomicInteger(0);
}

private int getServerByWeight(int[] weightArr) {
int[][] randArr = new int[weightArr.length][2];
int totalRank = 0;
int index = 0;
for(int i=0;i<weightArr.length;i++) {
if (weightArr[i] <= 0) {
continue;
}

totalRank += weightArr[i];
randArr[i][0] = i;
randArr[i][1] = totalRank;
}

int hitRank = new Random().nextInt(totalRank) + 1;//[1, totalRand]
for (int i = 0; i < randArr.length; i++) {
if (hitRank <= randArr[i][1]) {
return randArr[i][0];
}
}

return randArr[0][0];
}

public Server choose(List<Server> serverList) {
if (null == serverList) {
return null;
}

int[] weightArr = new int[serverList.size()];

for(int i = 0; i < serverList.size(); i++) {
if (serverList.get(i).getWeight() > 0) {
weightArr[i] = serverList.get(i).getWeight();
}
}

if (weightArr.length == 0) {
return null;
}

int chosenIndex = getServerByWeight(weightArr);
return serverList.get(chosenIndex);
}

public void doTestConcurrently(final List<Server> servers, int threadCount) {

class MyRunnable implements Runnable {

public void run() {
Server svr  = choose(servers);
if (svr.getIp().equals("10.0.0.1")) {
completedCount[0].incrementAndGet();
} else if (svr.getIp().equals("10.0.0.2")) {
completedCount[1].incrementAndGet();
} else if(svr.getIp().equals("10.0.0.3")) {
completedCount[2].incrementAndGet();
}
}
}

try {
Thread [] ts = new Thread[threadCount];
for (int i=0; i<threadCount; i++) {
ts[i] = new Thread(new MyRunnable());
}

for (int i = 0; i < threadCount; i++) {
ts[i].start();
}

for (int i = 0; i < threadCount; i++) {
ts[i].join();
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
int totalCompleted = completedCount[0].get() + completedCount[1].get() + completedCount[2].get();
if (totalCompleted == threadCount) {
System.out.println((double)completedCount[0].get()/totalCompleted);
System.out.println((double)completedCount[1].get()/totalCompleted);
System.out.println((double)completedCount[2].get()/totalCompleted);
}
}
}

public static void main(String[] args) {
Server[] servers = {
new Server("10.0.0.1", 8081, 20),
new Server("10.0.0.2", 8082, 40),
new Server("10.0.0.3", 8083, 60)
};

WeightAllocationAlg weightAllocationAlg = new WeightAllocationAlg();

Server server = weightAllocationAlg.choose(Arrays.asList(servers));

System.out.println(server.toString());

int threadCount = 100;

weightAllocationAlg.doTestConcurrently(Arrays.asList(servers), threadCount);

}

}

结果如下：

ip : 10.0.0.2, port : 8082, weight : 40

0.18

0.34

0.48

可以看到基本上是按照1:2:3的比例返回的，跟预期的一致，当然略有偏差，如果在数据量大且随机函数分布较均匀的情况下结果应该就是按照1:2:3来的。

Author：忆之独秀

Email：leaguenew@qq.com

注明出处：http://blog.csdn.net/lavorange/article/details/78320349