Scala provides powerful support for concurrency and parallelism through its support for threads and synchronization primitives. In Scala, threads are represented by the `Thread` class, which can be used to execute a block of code concurrently with the main program.
To create a new thread in Scala, you can extend the `Thread` class and override its `run()` method with the code that should be executed in the new thread. Alternatively, you can create a new `Thread` object and pass a `Runnable` object to its constructor. For example, consider the following code that creates a new thread and executes a block of code concurrently with the main program:
scala
val thread = new Thread {
override def run(): Unit = {
// code to execute in the new thread
}
}
thread.start() // start the new thread
In this example, a new `Thread` object is created by extending the `Thread` class with an anonymous inner class that overrides its `run()` method. The `start()` method is then called on the new thread to execute the block of code concurrently with the main program.
Scala also provides several synchronization primitives for coordinating access to shared resources between threads. For example, consider the following code that creates a shared `Counter` object and two threads that increment the counter:
scala
class Counter {
private var count = 0
def increment(): Unit = synchronized {
count += 1
}
def getCount(): Int = synchronized{
count
}
}
val counter = new Counter()
val thread1 = new Thread {
override def run(): Unit = {
for (i <- 1 to 10000) {
counter.increment()
}
}
}
val thread2 = new Thread {
override def run(): Unit = {
for (i <- 1 to 10000) {
counter.increment()
}
}
}
thread1.start()
thread2.start()
thread1.join()
thread2.join()
println(counter.getCount()) // prints 20000
In this example, a `Counter` class is defined with a private `count` variable and two methods `increment()` and `getCount()` that increment and return the value of the counter, respectively. The `increment()` method is marked as `synchronized` to ensure that only one thread can access the counter at a time.
Two new threads are then created that each increment the counter 10000 times. The `start()` method is called on each thread to execute their respective blocks of code concurrently with the main program. The `join()` method is then called on each thread to wait for them to finish executing, and the final value of the counter is printed to the console.
Overall, Scala's support for threads and synchronization primitives provides a powerful and flexible way to implement concurrent and parallel programs. However, it is important to be careful when using threads to avoid issues like race conditions and deadlocks, and to usehigher-level abstractions like futures and actors when appropriate. Scala provides several libraries and frameworks, such as Akka and Cats, that provide higher-level abstractions for concurrency and parallelism.