Apache Spark Streaming is an extension of the core Spark API that enables scalable, high-throughput, fault-tolerant stream processing of live data streams. Data can be ingested from many sources like Kafka, Flume, Kinesis, or TCP sockets, and can be processed using complex algorithms expressed with high-level functions like map, reduce, join and window. Finally, processed data can be pushed out to file systems, databases, and live dashboards. It's designed to handle a wide variety of data sources by dividing the streaming data into batches.

Key Features of Spark-Streaming:

1. Unified Data Processing Framework: Spark Streaming is part of the Apache Spark platform which allows developers to use a single framework for both batch processing and stream processing.
2. Fault Tolerance & High Availability: Spark Streaming achieves fault tolerance through Spark's inherent fault tolerance of data operations.
3. Ease of Use: Like Apache Spark, the streaming component also provides a powerful and easy-to-use API.

How Does Spark Streaming Work?

Apache Spark Streaming processes live streams as a series of mini-batches. Each mini-batch of data is treated as a small static dataset on which RDD (Resilient Distributed Dataset) transformations can be applied. The Spark Engine processes these RDDs using complex algorithms defined by the user.

Key Components:

• DStreams: The basic abstraction in Spark Streaming is a Discretized Stream or DStream, which represents a continuous stream of data. DStreams can be created from various input sources like Kafka, Flume, and Kinesis.
• Transformations: Spark Streaming provides various transformation functions which can be performed on the DStream like map, reduceByKey, join, window, and more.
• Output Operations: At the end of processing, the results can be pushed to databases, Kafka, live dashboards, or even HDFS for further analysis.

Example of a Simple Streaming Application

Here is how a simple Spark Streaming application looks in Scala:

1import org.apache.spark._
2import org.apache.spark.streaming._
3
4// Create a local StreamingContext with two working thread and batch interval of 1 second
5val conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")
6val ssc = new StreamingContext(conf, Seconds(1))
7
8// Create a DStream that connects to localhost:9999
9val lines = ssc.socketTextStream("localhost", 9999)
10
11// Split each line into words
12val words = lines.flatMap(_.split(" "))
13
14// Count each word in each batch
15val pairs = words.map(word => (word, 1))
16val wordCounts = pairs.reduceByKey(_ + _)
17
18// Print the first ten elements of each RDD generated in this DStream
19wordCounts.print()
20
21ssc.start()             // Start the computation
22ssc.awaitTermination()  // Wait for the computation to terminate

Performance Optimization Techniques:

To maximize the efficiency and performance of Spark-Streaming applications, following optimization techniques can be employed:

1. Tuning the batch size: Adjust the batch intervals according to the workload and latency requirements.
2. Caching / Persisting: RDDs can be cached across the batches for faster access in case of operations that use the same RDD multiple times.
3. Parallelism: Increase the level of parallelism in receiving data, by increasing the number of receiver tasks.

Challenges with Spark Streaming:

Like any streaming processing system, Spark Streaming has its limitations such as handling late data, stateful computation, and ensuring at-least or exactly-once processing semantics. Advanced features like Structured Streaming, which evolved from Spark Streaming, address many of these challenges.

Summary Table:

In essence, Spark Streaming has become an indispensable player in the field of real-time analytics, enabling developers to write scalable, fault-tolerant streaming applications quickly.