Java Future使用，顺便求算丑数问题

简述：

最近，在熟悉Java多线程，但是光写个多线程输出个string什么的，似乎又太简单无趣了，所以在熟悉Java特性的同时实现了一个丑数的求算

知识点：

1. Java 的Future接口可以存放交给线程处理并得到的输出，如Future<String> 就是交给一个线程去处理，但处理完了后得给我返回一个String

以此类推，Future<List<Integer>>就是的给我返回一个List<integer>的list

2. implements Callable<?> 和 implements Runnable的区别在于，前者开辟的线程处理完后有返回值，比如Callable<String> 就是在

override Call之后需要有一个返回值

@Override
public String call() throws Exception {
return "Callable<String> ";
}

上面就是返回了一个String，

相对于Callable， Runnable的run方法就不需要返回值

@Override
public void run() {
System.out.println("Runnbale");
Thread.yield(); // now the CPU could transfer the thread to a new Thread
}

3. 这里要实现一个算法, 给了2, 3, 5 三个质数，此外给一个LimitNum， 要求输出小于等于LimitNum的自然数中，质因数只包含2,3,5的数字

例如 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20

这个算法就在于给2,3,5不同的标记multiplyX 分别记录当前【2,3,5】三个指针在list中指向元素的位置，例如，multiply2为2时，则指向list[2] 即值为4的位置，

通过比较函数Min(int a, int b, int c), 确保每次都是在上一次新添加值之后，新增的为最小的那个符合要求的自然数

int min = Min(list.get(multiply2) * 2, list.get(multiply3) * 3
, list.get(multiply5) * 5);

随机给不同线程不同的limitNum让他们去算，好了之后的每个线程得到的存放，丑数列结果的list输出

代码：

TestFuture.java

package test.multithread.future_and_callable;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestFuture {
private static ArrayList<Future<List<Integer>>> results
= new ArrayList<Future<List<Integer>>>();
private static ExecutorService exec = Executors.newCachedThreadPool();
public static void main(String[] args) {
for(int i = 0;i < 10;i++){
Random random = new Random();
Integer x = random.nextInt(50);
results.add(exec.submit(new ThreadA(x)));
}
int count = 0;
for(Future<List<Integer>> futureList : results){
if(futureList.isDone()){
try {
System.out.println(futureList.get().toString());
count++;
} catch (InterruptedException e) {
System.out.println(e.toString());
} catch (ExecutionException e) {
System.out.println(e.toString());
}
}
else
System.out.println("Future List didn't finished");
}
exec.shutdown();
}
}

ThreadA.java

package test.multithread.future_and_callable;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;

public class ThreadA implements Callable<List<Integer>>{
private int limitNum;
private List<Integer> list = new ArrayList<Integer>();

public ThreadA(int limitNum) {
this.limitNum = limitNum;
}

//Get List of Integers which are no more than limitNum
//and their prime factors only include {2, 3, 5}
@Override
public List<Integer> call() throws Exception {
return GetUglyNumberlist();
}

private List<Integer> GetUglyNumberlist(){
//all mutiply from index 0 , where list.get(0) equals 1
int multiply2 = 0;
int multiply3 = 0;
int multiply5 = 0;
list.add(1);
int uglyNumberIndex = 0;
while(list.get(uglyNumberIndex) <= limitNum){
int min = Min(list.get(multiply2) * 2, list.get(multiply3) * 3
, list.get(multiply5) * 5);
if(min > limitNum)
break;
//insert the new ugly number to list
list.add(min);
while(list.get(multiply2) * 2 <= min)
multiply2++;
while(list.get(multiply3) * 3 <= min)
multiply3++;
while(list.get(multiply5) * 5 <= min)
multiply5++;
uglyNumberIndex++;
}
list.remove(0);
return list;
}

private int Min(int a, int b, int c){
int result = a < b ? a : b;
return result < c ? result : c;
}

}

输出：