0%

Scala并发编程实战 2:Lock 锁

synchronized作为内置锁,使用简单,不易出错,然鹅确有相当的局限性,例如,无法从等待获取锁的阻塞中中断,无法设置获取锁的超时。
所以JUC提供了另一种更灵活的加锁方式,即Lock。

Lock

Lock接口定义如下

public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}

从接口的定义不难发现,Lock不仅提供了常规的lock()阻塞式加锁,也提供了tryLock使得线程能在获取不到锁时,马上返回,
甚至可以等待锁一段时间后,再返回。lockInterruptibly则提供了可中断的阻塞式获取锁方式。

Lock的锁需要显示释放,通常要与try...finally语句一起使用,避免死锁。

lock.lock(); 
try {
// update object state
// catch exceptions and restore invariants if necessary
} finally {
lock.unlock();
}

ReentrantLock

Lock最常用的实现类是ReentrantLock,这是一个可重入锁(synchronized也是)。

ReentrantLock默认和内置锁一样,是非公平锁,但是支持公平锁模式,可以用ReentrantLock(true)创建公平锁。

可重入锁

所谓可重入锁,也就是说一个线程可以在持有该锁的时候,再次获取该锁。可重入锁通常与一个计数器关联,第一次获取锁的时候,计数器从0变为1,再次获取锁,变为2,以此类推。释放锁的时候,计数器每次减1,直至减为0,该锁才真正释放给其他线程。
为啥需要可重入锁
举个例子(JCP书上的)

public class Widget {     
public synchronized void doSomething() {
...
}
}
public class LoggingWidget extends Widget {
public synchronized void doSomething() {
System.out.println(toString() + ": calling doSomething");
super.doSomething();
}
}

子类覆盖了父类方法,并再次调用了父类的同步方法,如果锁不支持重入,则会导致死锁。

公平锁

所谓公平锁,其实就是指锁的等待队列执行先进先出,等待最久的线程优先获得锁。
但是内置锁和ReentrantLock默认都是非公平的,为啥?
因为非公平锁的性能更好。一个事实是,一个线程从被唤醒到真正运行中间有不可忽视的延迟,这个延迟时间很可能长到足够一个运行中的线程获取锁,并完成操作,然后释放锁。也即是说,把锁给’等待最久的线程‘的过程中,可以让其他线程插队获取锁,并归还锁,还不会影响’等待最久的线程‘的运行。这样一来吞吐量就得到了提升。

Scala栗子

package io.github.liam8.con

import java.util.concurrent.TimeUnit
import java.util.concurrent.locks.{Lock, ReentrantLock}

object LockDemo {

private val rtl: Lock = new ReentrantLock()

var inc: Int = 0

def get(): Int = {
rtl.lock()
try {
inc
} finally {
rtl.unlock()
}
}

def addOne(): Unit = {
rtl.lock()
try {
TimeUnit.SECONDS.sleep(1)
inc = 1 + get()
} finally {
rtl.unlock()
}
}

def main(args: Array[String]): Unit = {
for (i <- 1 to 10) {
new Thread {
override def run(): Unit = {
println(s"run thread $i")
addOne()
}
}.start()
}
while (true) {
println(s"inc=$inc")
TimeUnit.SECONDS.sleep(1)
}
}
}

output

run thread 3
run thread 8
run thread 1
run thread 9
run thread 7
run thread 4
run thread 5
run thread 2
run thread 10
run thread 6
inc=0
inc=0
inc=2
inc=3
inc=4
inc=5
inc=6
inc=7
inc=8
inc=8
inc=10
inc=10
inc=10

本文代码

Github仓库

转载请注明原文地址:https://liam-blog.ml/2019/07/21/Scala-Concurrency-in-Practice-2/