Apache spark Spark，Graphx程序不使用cpu和内存

我有一个函数，它取一个节点的邻居，对于邻居，我使用广播变量和节点本身的id，它计算该节点的贴近度中心。我用该函数的结果映射图中的每个节点。当我打开任务管理器时，cpu根本没有被利用，就好像它没有并行工作一样，内存也是如此，但每个节点都并行执行函数，而且数据量大，需要时间才能完成，这并不意味着它不需要资源。非常感谢您的帮助，谢谢。 对于加载图形，我使用

val graph=GraphLoader.edgeListFile（sc，path.cache）

object ClosenessCentrality {

  case class Vertex(id: VertexId)

  def run(graph: Graph[Int, Float],sc: SparkContext): Unit = {
    //Have to reverse edges and make graph undirected because is bipartite
    val neighbors = CollectNeighbors.collectWeightedNeighbors(graph).collectAsMap()
    val bNeighbors = sc.broadcast(neighbors)

    val result = graph.vertices.map(f => shortestPaths(f._1,bNeighbors.value))
    //result.coalesce(1)
    result.count()

  }

  def shortestPaths(source: VertexId,  neighbors: Map[VertexId, Map[VertexId, Float]]): Double ={
    val predecessors = new mutable.HashMap[VertexId, ListBuffer[VertexId]]()
    val distances = new mutable.HashMap[VertexId, Double]()
    val q = new FibonacciHeap[Vertex]
    val nodes = new mutable.HashMap[VertexId, FibonacciHeap.Node[Vertex]]()

    distances.put(source, 0)

    for (w <- neighbors) {
      if (w._1 != source)
        distances.put(w._1, Int.MaxValue)

      predecessors.put(w._1, ListBuffer[VertexId]())
      val node = q.insert(Vertex(w._1), distances(w._1))
      nodes.put(w._1, node)
    }

    while (!q.isEmpty) {
      val u = q.minNode
      val node = u.data.id
      q.removeMin()
      //discover paths
      //println("Current node is:"+node+" "+neighbors(node).size)
      for (w <- neighbors(node).keys) {
        //print("Neighbor is"+w)
        val alt = distances(node) + neighbors(node)(w)
//        if (distances(w) > alt) {
//          distances(w) = alt
//          q.decreaseKey(nodes(w), alt)
//        }
//        if (distances(w) == alt)
//          predecessors(w).+=(node)
         if(alt< distances(w)){
           distances(w) = alt
           predecessors(w).+=(node)
           q.decreaseKey(nodes(w), alt)
         }

      }//For
    }
    val sum = distances.values.sum
    sum
  }

对象贴近度中心度{
案例类顶点（id:VertexId）
def运行（图形：图形[Int，Float]，sc:SparkContext）：单位={
//必须反转边并使图无向，因为它是二部的
val Neights=CollectNeights.CollectWeightedNeights（图形）.collectAsMap（）
val bNeighbors=sc.broadcast（邻居）
val result=graph.vertices.map（f=>shortestpath（f._1，bNeighbors.value））
//结果：合并（1）
result.count（）
}
def最短路径（来源：VertexId，邻居：Map[VertexId，Map[VertexId，Float]]）：Double={
val preventors=new mutable.HashMap[VertexId，ListBuffer[VertexId]]（）
val distances=new mutable.HashMap[VertexId，Double]（）
val q=新的FibonacciHeap[顶点]
val nodes=new mutable.HashMap[VertexId，FibonacciHeap.Node[Vertex]]（）
距离。放置（源，0）
为了（w在某种程度上回答您最初的问题，我怀疑您的RDD只有一个分区，因此使用一个内核进行处理

edgeListFile
方法有一个参数，用于指定所需的最小分区数。
此外，您还可以使用
重新分区
获得更多分区

您提到了
coalesce
，但默认情况下这只会减少分区的数量，请参见以下问题：
您是在群集上还是本地启动程序？如果是本地主机，您是否指定了要使用的内核数量，如下图所示：
--master=local[8]
。或者，您的数据集有多少个分区？如果它只有一个分区，则使用单个核心。是的，我使用其他程序时，它使用了更多的资源。对于分区，我保留了从边缘列表文件加载图形时的默认分区，但我想到了这一点，我使用了coalesce with 10 For 8 cores t我应该使用更多还是我做错了；你能提供一些代码吗？谢谢你的代码。奇怪的是你没有使用GraphX中的任何方法来处理图形。像计算最短路径这样的事情应该使用Pregel API来完成。另外，在你的第一条指令中，你似乎正在收集g的整个邻接raoh盯上了司机这是一股很大的“代码气味”对于spark，我知道这并不能真正回答这个问题，但您可能希望改变您的问题方法，以便更好地利用spark的分布式特性。Graphx提供Pregel API来计算图中某个节点的SSSP，这对我来说是一样的，但您不能使用它选择的图并行地为每个节点计算SSSPf表示并行的每个节点。我还没有想到更好的方法。起初我也这么认为，因为找到所有的邻居几乎和图一样大，这不好，但我不知道如何并行。谢谢你，现在它可以工作了，但是分区的数量我如何根据cpu的核心数量来选择它；至少，你应该有和核心一样多的分区。但我强烈建议你有更多的分区，以确保每个分区足够小（特别是如果你想让每个顶点跟踪整个图形）。我的建议是：测试，测试和更多测试，看看你是否能找到一个最佳点。就像一个边节点那样：减少每个分区的大小（从而增加分区的数量）在100%的情况下，这似乎不是正确的方法。每个分区的开销太大，不可忽略，因此请确保在这两者之间取得平衡。无论如何，测试（和测试更多）建议对于中小型作业来说已经足够好了。