【Java】深夜代码祭（2）

问题

描述

代码

import javafx.util.Pair;

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.IntStream;

public class Main {

private final static Random r = new Random(Calendar.getInstance().getTimeInMillis());

private static ArrayList<DistributeDataSet> ddss;

private static OriDataSet ods;

private static void initialize() {

ods = new OriDataSet().config(IntStream.rangeClosed(1, 1000000)
.mapToObj((i) -> r.nextInt(1000))
.collect(LinkedList<Integer>::new,
(LinkedList<Integer> l, Integer i) -> l.add(i),
(LinkedList<Integer> l1, LinkedList<Integer> l2) -> l1.addAll(l2)));

ddss = new ArrayList<DistributeDataSet>();

for(int i = 0; i < 5; ++i) ddss.add(new DistributeDataSet());
}

public static void main(String[] args) {

initialize();

ExecutorService e = Executors.newCachedThreadPool();

ArrayList<FutureTask<Pair<LinkedList<Integer>, LinkedList<Integer>>>> fas = new ArrayList<>();

for(int i = 0; i < 5; ++i) fas.add(getFutureTask(ods, i));

fas.forEach(e::submit);

fas.forEach((f) -> {

try {

Pair<LinkedList<Integer>, LinkedList<Integer>> p = f.get();

System.out.println(p.getKey().size() + " " + p.getValue().size());
}

catch (InterruptedException | ExecutionException ex) {

ex.printStackTrace();
}
});

System.out.println("Done");

e.shutdown();
}

private static FutureTask<Pair<LinkedList<Integer>,
LinkedList<Integer>>> getFutureTask(final OriDataSet ds, final int no) {

return new FutureTask<Pair<LinkedList<Integer>, LinkedList<Integer>>>(() -> {

while(ds.updateWithEffects(ddss.get(no))) { }

return ddss.get(no).getResult();
});
}
}

class OriDataSet {

private int cnt = 0;

private LinkedList<Integer> data;

public OriDataSet config(LinkedList<Integer> l) { data = l; return this; }

public synchronized boolean updateWithEffects(DistributeDataSet dds) {

if(!data.isEmpty() && dds.accept(data.getFirst()) && sideEffects());

return !data.isEmpty();
}

private boolean sideEffects() {

data.removeFirst();

if((cnt += 1) % 1000 == 0) { System.out.println("now :" + cnt); }

return true;
}
}

class DistributeDataSet {

protected int cnt;

protected DistributeCondition<Integer> d1, d2;

DistributeDataSet() {

d1 = new EvenDistributeDataSet();

d2 = new OddDistributeDataSet();
}

public Pair<LinkedList<Integer>, LinkedList<Integer>> getResult() {

return new Pair<>(d1.getResult(), d2.getResult());
}

public boolean accept(Integer i) {

return d1.accept(i) || d2.accept(i);
}
}

abstract class DistributeCondition<T> {

protected LinkedList<T> l;

DistributeCondition() {

l = new LinkedList<>();
}

abstract public boolean accept(T t);

public LinkedList<T> getResult() {

return l;
}
}

class EvenDistributeDataSet extends DistributeCondition<Integer> {

@Override
public boolean accept(Integer t) {

return t % 2 == 0 && sideEffect(t);
}

private boolean sideEffect(Integer t) {

l.add(t);

return true;
}
}

class OddDistributeDataSet extends DistributeCondition<Integer> {

@Override
public boolean accept(Integer t) {

return t % 2 != 0 && sideEffect(t);
}

private boolean sideEffect(Integer t) {

l.add(t);

return true;
}
}