独立的scala程序会利用分布式/并行处理吗？还是spark Scala需要单独的代码？

首先，很抱歉在这里提出了基本的疑问，但是下面的解释还是可以理解的

我对scala和spark非常陌生，所以我的疑问是，如果我编写一个独立的scala程序，并在spark（1主3辅）上执行它，scala程序会利用干扰/并行处理，还是我需要编写一个单独的程序来利用分布式处理

例如，我们有一个scala代码，它将一个特定的格式化文件处理为逗号分隔的文件，它将一个目录作为输入，解析所有文件，并将输出写入单个文件（每个文件通常为100-200MB）。这是代码

import scala.io.Source
import java.io.File
import java.io.PrintWriter
import scala.collection.mutable.ListBuffer
import java.util.Calendar

//import scala.io.Source
//import org.apache.spark.SparkContext
//import org.apache.spark.SparkContext._
//import org.apache.spark.SparkConf


object Parser {

  def main(args:Array[String]) {

    //val conf = new SparkConf().setAppName("fileParsing").setMaster("local[*]")
    //val sc = new SparkContext(conf)

  var inp = new File(args(0))
  var ext: String = ""
  if(args.length == 1)
  { ext = "log" } else { ext = args(1) }

   var files: List[String] = List("")

   if (inp.exists && inp.isDirectory) {
        files = getListOfFiles(inp,ext)
        }
    else if(inp.exists ) {
         files = List(inp.toString)
    }
else
{
    println("Enter the correct Directory/File name");
    System.exit(0);
}

    if(files.length <=0 )
    {
    println(s"No file found with extention '.$ext'")
    }
    else{
            var out_file_name = "output_"+Calendar.getInstance().getTime.toString.replace(" ","-").replace(":","-")+".log"
            var data = getHeader(files(0))
            var writer=new PrintWriter(new File(out_file_name))
            var record_count = 0

            //var allrecords = data.mkString(",")+("\n")
            //writer.write(allrecords)
            for(eachFile <- files)
                {
                    record_count += parseFile(writer,data,eachFile)
                }
            writer.close()
            println(record_count +s" processed into $out_file_name")

    }
//all func are defined here.
}

导入scala.io.Source
导入java.io.xml文件
导入java.io.PrintWriter
导入scala.collection.mutable.ListBuffer
导入java.util.Calendar
//导入scala.io.Source
//导入org.apache.spark.SparkContext
//导入org.apache.spark.SparkContext_
//导入org.apache.spark.SparkConf
对象解析器{
def main（参数：数组[字符串]）{
//val conf=new SparkConf（）.setAppName（“文件解析”）.setMaster（“本地[*]”）
//val sc=新的SparkContext（配置）
var inp=新文件（args（0））
var ext:String=“”
如果（args.length==1）
{ext=“log”}否则{ext=args（1）}
变量文件：列表[字符串]=列表（“”）
if（inp.exists&&inp.isDirectory）{
files=getListOfFiles（inp，ext）
}
否则，如果（inp.exists）{
文件=列表（inp.toString）
}
其他的
{
println（“输入正确的目录/文件名”）；
系统出口（0）；
}
如果（files.length如果您使用
spark submit
运行您提供的应用程序，您将根本不使用spark群集。您必须重写它才能使用
SparkContext
。请通读。
如果您使用
spark submit
运行您提供的应用程序，您将not根本不用Spark群集。你必须重写它才能使用
SparkContext
。请通读。
不会。要使用Spark进行分布式计算，你需要使用SparkContext。
不会。要使用Spark进行分布式计算，你需要使用SparkContext。
它是ext在Youtube上观看一些介绍性视频对于了解ApacheSpark的总体工作原理非常有帮助

例如，这些：

了解它对于使用Spark非常重要

“分布式处理的优势”

使用Spark可以在多个服务器集群上分配处理，因此，如果以后要将应用程序移动到集群，使用Spark模型和相应的API开发应用程序是有意义的

您可以在本地计算机上本地运行Spark应用程序，但在这种情况下，您无法获得Spark所能提供的所有优势

无论如何，正如前面所说，Spark是一个特殊的框架，有自己的开发库。因此，您必须使用Spark上下文和Spark API重写您的应用程序，即RDD或Dataframes等特殊对象以及相应的方法。
在Youtube上观看一些介绍性视频非常有助于了解如何使用Spark上下文和Spark APIapachespark一般都可以工作

例如，这些：

了解它对于使用Spark非常重要

“分布式处理的优势”

使用Spark可以在多个服务器集群上分配处理，因此，如果以后要将应用程序移动到集群，使用Spark模型和相应的API开发应用程序是有意义的

您可以在本地计算机上本地运行Spark应用程序，但在这种情况下，您无法获得Spark所能提供的所有优势

无论如何，正如前面所说，Spark是一个特殊的框架，它有自己的开发库。因此，您必须使用Spark上下文和Spark API重写您的应用程序，即RDD或Dataframes等特殊对象以及相应的方法。
谢谢，如果我使用SC读取文件，那么，程序是否会使用Spark处理功能？？如果您按照编程指南建议的方式使用SC，那么是的，它将使用Spark。谢谢您，因此如果我使用SC读取文件，那么程序将使用Spark处理功能？？如果您按照编程指南建议的方式使用SC，那么是的，它将使用Spark。
val conf = new SparkConf().setAppName("fileParsing").setMaster("local[*]")
val sc = new SparkContext(conf)
...
...
for(eachFile <- files)
                {
                    record_count += parseFile(sc,writer,data,eachFile)
                }

------------------------------------
def parseFile(......)
sc.textFile(file).getLines