并发编程之Phaser类多阶段任务(以遗传算法TSP问题为例)

目录

一、认识Phaser类

1、Phaser类特征

2、任务注册与注销

3、同步阶段变更

二、遗传算法

1、DataLoader类:加载数据

2、Individual类:问题所有可能解

3、GeneticOperators类:GA算法核心

三、GA应用:Phaser类解决旅行商问题(TSP)

2、GeneticPhaser类:Java并发Phaser类实现

3、ConcurrentGeneticTask类:GA算法阶段任务执行

 4、ConcurrentGeneticAlgorithm类:GA算法并发实现

5、主类main

四、实验结果

五、分析总结


一、认识Phaser类

学习Java并发有一段时间了,从基础开始,认识了许多同步机制API,这次学习了Phaser类这个同步机制,刷新了以前的认识,再添一项新知识。

下面先认识一下Phaser是什么,然后结合实际应用,通过遗传算法经典应用的旅行商问题(TSP)的案例,更好地学习一下Phaser类同步机制的使用方法。

1、Phaser类特征

Java7的并发API引入了Phaser类,提供了强大的同步机制——分段器,它将任务划分为多个阶段执行,处理过程定义了明确的步骤,完成每个阶段任务需要遵循先后顺序。

主要特点:

  1. 分段器必须知道要控制的任务数量,Java中成为参与者(任务)的注册机制。
  2. 任务完成一个阶段后告知分段器。完成此阶段之前,分段器使该任务处于休眠状态。
  3. 分段器保存了一个整数值,存储已经进行的阶段变更数目。
  4. 当分段器做出阶段变更时候,可以执行定制的代码。
  5. 控制phaser的终止。
  6. 可以通过方法获取参与者的数目和状态。

2、任务注册与注销

这里根据上面说到的第1个特点,介绍注册参与者的方法。注册可以在执行任务开始时,也可以随时注册。

Phaser对象创建,常用的2个构造函数:

  1. Phaser():创建一个有0个参与者的分段器。
  2. Phaser(int parties):创建一个给定数目参与者的分段器。

显式创建方法:

  1. bulkRegisterl(int parties) :注册给定数目的参与者。
  2. register():注册一个参与者。

分段器控制的任务完成之后必须注销,否则分段器会处于一直等待状态。

注销方法:

 arriveAndDeRegister():告知分段器该任务已完成当前阶段,而且不参与下一阶段。

3、同步阶段变更

分段器的主要目的是使那些可以分割为多阶段算法,以并发方式执行。任务只有完成当前阶段,才能进入下一个阶段。

Phaser类中有arrive,arriveAndDeRegister,arriveAndwaitAdvance三个方法来告知当前阶段已经完成,但是当一个任务完成阶段后未调用其中之一的方法,分段器可能对其余任务或阶段进行阻塞。

因此,进入下一阶段调用以下方法

  1. arriveAndwaitAdvance():告知分段器当前阶段已经完成,进入下一阶段。phaser阻塞该任务,直到所有参与的任务调用了其中一种同步方法。
  2. awaitAdvance(int phaser):告知分段器,若参数等于实际阶段数,则等待当前阶段结束;不等则返回。

二、遗传算法

上面其实都是一些理论知识,对Phaser有一定的了解之后,开始在实际案例中学习,更进一步理解,遗传算法就是一个很好的例子。

遗传算法耳熟能详,是基于自然选择原理的一种自适应启发式搜索算法,用于最优化问题和在搜索问题中寻找更好地方案。换言之,“优胜劣汰,适者生存”。这也是从生物学引申而来的有类似原理的算法,所以也使用了生物学的一些术语。

一些在遗传算法中使用的特定术语:

  1. 适应度函数:是主要目标,能够使函数最大化或者最小化的解决方案,来确定方案的优劣。
  2. 种群:问题的所有可能方案的集合。初始集合可以随机生成或使用启发函数获取初始解决方案。

初始种群之后,启动包含3个阶段的迭代过程:

  1. 选择:在种群中选择更好地个体,个体在适应度函数中有着较好的值。
  2. 交叉:上一步选择优质个体后进行交叉,生成新一代个体。具体操作:parent1 X parent2 ——>> child1 + child2 ,主要依赖于待解决问题。
  3. 突变:可以应用突变运算符更改某个体的值,只对极少个体执行此操作。

结束标准:

  • 固定代数
  • 适应度函数设定的阈值
  • 找到满足预定标准的方案
  • 时间限制
  • 手动停止

将遗传算法应用于TSP问题,目标找到一条最优路线,经过每个城市有且仅有一次,同时旅行总距离最短。

数据有两份,包括15个城市和57个城市。二维矩阵中每个值表示城市之间的距离。

并发编程之Phaser类多阶段任务(以遗传算法TSP问题为例)_第1张图片

1、DataLoader类:加载数据

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;

public class DataLoader {

    /**
     * @param path
     * @return int[][]
     * @author Charzous
     * @date 2021/2/5 10:46
     *
     * 加载文件,转化为二维数组
     */
    public static int[][] load(Path path) throws IOException {
        InputStream in = Files.newInputStream(path);
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        String line = null;
        String[] row = null;
        int[][] a;
        ArrayList arrayList = new ArrayList<>();
        int rowNum = 0, colNum = 0, i = 0, j = 0;
        while ((line = reader.readLine()) != null) {
            arrayList.add(line);
            colNum = line.split(",").length;
        }
        rowNum = arrayList.size();
        a = new int[rowNum][colNum];
        int count = 0;

        for (String str : arrayList) {
            row = str.split(",");
            for (i = 0; i < colNum; i++) {
                a[count][i] = Integer.parseInt(row[i]);
            }
            count++;
        }
        return a;
    }
/**
 * @param args
 * @return void
 * @author Charzous
 * @date 2021/2/5 10:45
 *
 * 类内测试,加载文件
 */
//    public static void main(String[] args) throws IOException {
//        Path file = Paths.get("data/kn57_dist.txt");
//        int[][] a;
//        a = DataLoader.load(file);
//        for (int i = 0; i < a.length; i++) {
//            for (int j = 0; j < a[0].length; j++) {
//                System.out.print(a[i][j] + " ");
//            }
//            System.out.println();
//        }
//    }
}

2、Individual类:问题所有可能解

/**
 * 存放访问不同城市的顺序,TSP问题的所有可能解
 *
 * @author Charzous
 * @date 2021/2/5 10:53
 */
public class Individual implements Comparable {

    private Integer[] chromosomes;
    private int value;

    public Integer[] getChromosomes() {
        return chromosomes;
    }

    public void setChromosomes(Integer[] chromosomes) {
        this.chromosomes = chromosomes;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public Individual(int size) {
        chromosomes = new Integer[size];
    }

    public Individual(Individual other) {
        chromosomes = other.getChromosomes().clone();
    }

    @Override
    public int compareTo(Individual o) {
        return Integer.compare(this.getValue(), o.getValue());
    }

    @Override
    public String toString() {
        String ret = "";
        for (Integer number : chromosomes)
            ret += number + ",";
        return ret;
    }
}

3、GeneticOperators类:GA算法核心

遗传算法核心内部逻辑实现:选择、交叉、个体和种群评估,详见代码注释


import java.util.*;
/**
 * 实现遗传算法内部逻辑
 *
 * @author Charzous
 * @date 2021/2/5 11:21
 *
 */
public class GeneticOperators {
    /**
     * @param selected
     * @param numberOfIndividual
     * @param size
     * @return GeneticAlgorithm.Individual[]
     * @author Charzous
     * @date 2021/2/5 11:29
     *
     * 接收被选中的个体,交叉操作生成下一代种群
     */
    public static Individual[] crossover(Individual[] selected,int numberOfIndividual,int size){

        Individual population[] =new Individual[numberOfIndividual];
        Random random=new Random(System.nanoTime());
        for (int i=0;i individual1 , individual2
     */
    public static void crossover(final Individual parent1,final Individual parent2,final Individual individual1,final Individual individual2){
        List p1= Arrays.asList(parent1.getChromosomes());
        List p2= Arrays.asList(parent2.getChromosomes());
        List ch1=new ArrayList(p1.size());
        List ch2=new ArrayList(p2.size());//p1 ? p2
        int size=p1.size();
        Random random=new Random();
        int number1=random.nextInt(size-1);
        int number2;
        //1,14,6,2,3,5,7,0,12,4,11,13,9,8,10,
        do {
            number2=random.nextInt(size);
        }while (number1==number2);

        int start=Math.min(number1,number2);
        int end=Math.max(number1,number2);
        ch1.addAll(p1.subList(start,end));
        ch2.addAll(p2.subList(start,end));

        int currentCity=0;
        int currentCityParent1=0;
        int currentCityParent2=0;
        for (int i = 0; i < size; i++) {
            currentCity=(end+i)%size;
            currentCityParent1=p1.get(currentCity);
            currentCityParent2=p2.get(currentCity);

            if (!ch1.contains(currentCityParent2))
                ch1.add(currentCityParent2);
            if (!ch2.contains(currentCityParent1))
                ch2.add(currentCityParent1);
        }

        Collections.rotate(ch1,start);
        Collections.rotate(ch2,start);
        individual1.setChromosomes(ch1.toArray(individual1.getChromosomes()));
        individual2.setChromosomes(ch2.toArray(individual2.getChromosomes()));
    }
    /**
     * @param population
     * @return GeneticAlgorithm.Individual[]
     * @author Charzous
     * @date 2021/2/5 11:23
     *
     * 获取种群的最优个体,返回种群一半的个体,可使用最适合函数选择
     */
    public static Individual[] selection(Individual[] population){
        Individual selected[] =new Individual[population.length/2];

        for (int i = 0; i < selected.length; i++) {
            selected[i]=new Individual(population[i]);
        }
        return selected;
    }

    /**
     * @param numberOfIndividual
     * @param size
     * @return GeneticAlgorithm.Individual[]
     * @author Charzous
     * @date 2021/2/5 11:24
     *
     * 创建一个群,城市数目size
     */
    public static Individual[] initialize(int numberOfIndividual,int size){
        Individual population[] =new Individual[numberOfIndividual];
        for (int i = 0; i < numberOfIndividual; i++) {
            population[i]=new Individual(size);
            initialize(population[i].getChromosomes());
        }
        return population;
    }

    /**
     * @param chromosomes
     * @return void
     * @author Charzous
     * @date 2021/2/5 11:25
     *
     * 随机初始化某一个体的染色体,生成合法的个体(即每个城市只访问一次)
     */
    public static void initialize(Integer[] chromosomes){
        int size=chromosomes.length;
        List values=new ArrayList(size);

        for (int i = 0; i < size; i++) {
            values.add(i);
        }
        Collections.shuffle(values,new Random(System.nanoTime()));

        for (int i = 0; i < size; i++) {
            chromosomes[i]=values.get(i);
        }
    }
    /**
     * @param population
     * @param distanceMatrix
     * @return void
     * @author Charzous
     * @date 2021/2/5 11:33
     *
     * 接收距离矩阵,将适应函数应用到全部个体,对种群排序
     */
    public static void evaluate(Individual[] population,int[][] distanceMatrix){
        for (Individual individual:population) {
            evaluate(individual,distanceMatrix);
        }
        Arrays.sort(population);
    }
    /**
     * @param individual
     * @param distanceMatrix
     * @return void
     * @author Charzous
     * @date 2021/2/5 11:36
     *
     * 接将适应函数应用到一个个体,结果加入到个体集合,以供对种群所有进行排序
     */
    public static void evaluate(Individual individual,int[][] distanceMatrix){
        Integer chromosomes[]=individual.getChromosomes();
        int totalDistance=0;
        int source,destination;
        for (int i = 0; i < chromosomes.length-1; i++) {
            source=chromosomes[i];
            destination=chromosomes[i+1];
            totalDistance+=distanceMatrix[source][destination];
        }
        source=chromosomes[chromosomes.length-1];
        destination=chromosomes[0];
        totalDistance+=distanceMatrix[source][destination];

        individual.setValue(totalDistance);
    }
}

三、GA应用:Phaser类解决旅行商问题(TSP)

1、SharedData类:共享对象

import java.util.concurrent.atomic.AtomicInteger;
/**
 * 存放任务之间共享的对象
 *
 * @author Charzous
 * @date 2021/2/5 15:16
 *
 */
public class SharedData {
    private Individual[] population;
    private Individual[] selected;
    private AtomicInteger index;
    private Individual best;
    private int[][] distanceMatrix;

    public SharedData() {
        index=new AtomicInteger();
    }

    public Individual[] getPopulation() {
        return population;
    }

    public void setPopulation(Individual[] population) {
        this.population = population;
    }

    public Individual[] getSelected() {
        return selected;
    }

    public void setSelected(Individual[] selected) {
        this.selected = selected;
    }

    public AtomicInteger getIndex() {
        return index;
    }

    public void setIndex(AtomicInteger index) {
        this.index = index;
    }

    public Individual getBest() {
        return best;
    }

    public void setBest(Individual best) {
        this.best = best;
    }

    public int[][] getDistanceMatrix() {
        return distanceMatrix;
    }

    public void setDistanceMatrix(int[][] distanceMatrix) {
        this.distanceMatrix = distanceMatrix;
    }
}

2、GeneticPhaser类:Java并发Phaser类实现

import java.util.Arrays;
import java.util.concurrent.Phaser;

public class GeneticPhaser extends Phaser {
    private SharedData data;

    public GeneticPhaser(int parties, SharedData data) {
        super(parties);
        this.data=data;
    }
    /**
     * @param phase
     * @param registeredParties
     * @return boolean
     * @author Charzous
     * @date 2021/2/5 15:20
     *
     * 重载onAdvance方法,使所有任务完成第一阶段之后执行代码
     */
    @Override
    protected boolean onAdvance(int phase, int registeredParties) {
        int realPhase=phase%3;
        if (registeredParties>0) {
            switch (realPhase) {
                case 0:
                case 1:
                    data.getIndex().set(0);
                    break;
                case 2:
                    Arrays.sort(data.getPopulation());
                    if  (data.getPopulation()[0].getValue() < data.getBest().getValue()) {
                        data.setBest(data.getPopulation()[0]);
                    }
                    break;
            }
            return false;
        }
        return true;
    }

    public SharedData getData() {
        return data;
    }

    public void setData(SharedData data) {
        this.data = data;
    }
}

3、ConcurrentGeneticTask类:GA算法阶段任务执行

import JavaConcurrencyProgramming.chapter06.GeneticAlgorithm.GeneticOperators;
import JavaConcurrencyProgramming.chapter06.GeneticAlgorithm.Individual;

import java.util.Random;
/**
 * 执行遗传算法各个阶段的任务
 *
 * @author Charzous
 * @date 2021/2/5 15:28
 *
 */
public class ConcurrentGeneticTask implements Runnable {
    private GeneticPhaser phaser;
    private SharedData data;
    private int numberOfGenerations;
    private boolean main;

    public ConcurrentGeneticTask(GeneticPhaser phaser, int numberOfGenerations,
                                 boolean main) {
        this.phaser = phaser;
        this.numberOfGenerations = numberOfGenerations;
        this.main = main;
        this.data = phaser.getData();
    }

    @Override
    public void run() {
        Random random = new Random((System.nanoTime()));
        for (int i = 0; i < numberOfGenerations; i++) {
            if (main)
                data.setSelected(GeneticOperators.selection(data.getPopulation()));

            phaser.arriveAndAwaitAdvance();

            //交叉操作
            int individualIndex;
            do {
                individualIndex = data.getIndex().getAndAdd(2);
                if (individualIndex < data.getPopulation().length) {
                    int secondIndividual = individualIndex++;

                    int p1Index = random.nextInt(data.getSelected().length);
                    int p2Index;
                    do {
                        p2Index = random.nextInt(data.getSelected().length);
                    } while (p1Index == p2Index);

                    Individual parent1 = data.getSelected()[p1Index];
                    Individual parent2 = data.getSelected()[p2Index];
                    Individual individual1 = data.getPopulation()[individualIndex];
                    Individual individual2 = data.getPopulation()[secondIndividual];

                    GeneticOperators.crossover(parent1, parent2, individual1, individual2);
                }
            } while (individualIndex < data.getPopulation().length);
            phaser.arriveAndAwaitAdvance();

            do {
                individualIndex = data.getIndex().getAndIncrement();
                if (individualIndex < data.getPopulation().length) {
                    GeneticOperators.evaluate(data.getPopulation()[individualIndex], data.getDistanceMatrix());
                }
            } while (individualIndex < data.getPopulation().length);
            phaser.arriveAndAwaitAdvance();
        }
        phaser.arriveAndDeregister();
    }
}

 4、ConcurrentGeneticAlgorithm类:GA算法并发实现

/**
 * 遗传算法并发算法
 * @author Charzous
 * @date 2021/2/5 15:30
 *
 */
public class ConcurrentGeneticAlgorithm {
    private int numberOfGenerations;
    private int numberOfIndividuals;
    private int[][] distanceMatrix;
    private int size;

    public ConcurrentGeneticAlgorithm(int[][] distanceMatrix, int numberOfGenerations, int numberOfIndividuals) {
        this.distanceMatrix = distanceMatrix;
        this.numberOfGenerations = numberOfGenerations;
        this.numberOfIndividuals = numberOfIndividuals;
        size = distanceMatrix.length;
    }

    public Individual calculate() {

        Individual[] population = GeneticOperators.initialize(numberOfIndividuals, size);
        GeneticOperators.evaluate(population, distanceMatrix);

        SharedData data = new SharedData();
        data.setPopulation(population);
        data.setDistanceMatrix(distanceMatrix);
        data.setBest(population[0]);

        int numTasks = Runtime.getRuntime().availableProcessors();
        GeneticPhaser phaser = new GeneticPhaser(numTasks, data);

        ConcurrentGeneticTask[] tasks = new ConcurrentGeneticTask[numTasks];
        Thread[] threads = new Thread[numTasks];

        tasks[0] = new ConcurrentGeneticTask(phaser, numberOfGenerations, true);
        for (int i = 1; i < numTasks; i++) {
            tasks[i] = new ConcurrentGeneticTask(phaser, numberOfGenerations, false);
        }

        for (int i = 0; i < numTasks; i++) {
            threads[i] = new Thread(tasks[i]);
            threads[i].start();
        }

        for (int i = 0; i < numTasks; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        return data.getBest();
    }
}

5、主类main

import java.io.IOException;
import java.nio.file.Paths;

public class ConcurrentMain {
    public static void main(String[] args) throws IOException {

        long start, end;

        int generations = 1000;
        int individuals = 1000;

        String[] names={"kn57_dist"};//"lau15_dist" ,
        for (String name:names) {
            int[][] distanceMatrix = DataLoader.load(Paths.get("data", name + ".txt"));

            ConcurrentGeneticAlgorithm concurrentGeneticAlgorithm = new ConcurrentGeneticAlgorithm(distanceMatrix, generations,
                    individuals);
            start = System.currentTimeMillis();
            Individual result = concurrentGeneticAlgorithm.calculate();
            end = System.currentTimeMillis();
            System.out.println("=======================================");
            System.out.println("Example:"+name);
            System.out.println("Generations: " + generations);
            System.out.println("Population: " + individuals);
            System.out.println("Execution Time: " + (end - start)+"ms");
            System.out.println("Best Individual: " + result);
            System.out.println("Total Distance: " + result.getValue());
            System.out.println("=======================================");
        }

    }
}

 

四、实验结果

数据和实验参数设置:

generations = 1000;
individuals = 1000;

数据:lau15_dist.txt(15个城市)

测试执行10次,平均执行时间为500ms左右。

并发编程之Phaser类多阶段任务(以遗传算法TSP问题为例)_第2张图片

 

当然,种群数和代数可以设置其他值,数据集使用可以更换,进行实验。

为了比较并发版本执行表现的提升,简单实现了单线程版本,只需要将ConcurrentGeneticAlgorithm类里面的并发部分修改为单线程方法,结果如下:

并发编程之Phaser类多阶段任务(以遗传算法TSP问题为例)_第3张图片

测试执行10次,平均执行时间为690ms左右,对比之下可看出并发的性能提升。

五、总结

这篇记录Phaser类同步机制的原理和实践理解,学习Java并发有一段时间了,从基础开始,认识了许多同步机制API,这次学习了Phaser类这个同步机制,刷新了以前的认识,再添一项新知识。先认识一下Phaser是什么,然后结合实际应用,通过遗传算法经典应用的旅行商问题(TSP)的案例,更好地学习一下Phaser类同步机制的使用方法。对Phaser一些理论知识有一定的了解之后,开始在实际案例中学习,更进一步理解,遗传算法就是一个很好的例子,掌握了分段器在并发编程中的基础使用,也希望在之后的学习应用能够有所帮助。

如果觉得不错欢迎“一键三连”哦,点赞收藏关注,有问题直接评论,交流学习!

Java并发编程系列文章:

  1. 原创 Java并发API案例分析之并发设计原理[https://blog.csdn.net/Charzous/article/details/112603639]
  2. 原创 Java并发(Runnable+Thread)实现硬盘文件搜索[https://blog.csdn.net/Charzous/article/details/112853937]
  3. 原创 并发编程之Callable/Future接口(以单词最佳匹配算法为例)[https://blog.csdn.net/Charzous/article/details/113338669]
  4. 并发编程之Phaser类多阶段任务(以遗传算法TSP问题为例)[https://blog.csdn.net/Charzous/article/details/113698041]

我的CSDN博客:https://blog.csdn.net/Charzous/article/details/113698041

你可能感兴趣的:(Java宝藏,算法,java,Phaser分段器,java高并发api)