如何在Scala中与共享对象进行线程交互？

在下面的代码中，首先我们可以通过调用

create

方法创建something，为了销毁它，我们可以调用

destroy

方法，每个方法首先更改对象的状态，然后异步等待，直到操作结束。假设创建时间为10秒，销毁时间为5秒。当我调用destroy方法时，它将

destroming

布尔值更改为true，然后等待创建持续时间的另一个线程将打破

waitUntil

方法中的循环。但它不能正常工作。当我调用create方法时，它会更改状态，然后创建一个线程以等待创建持续时间的延长。调用create方法后，我调用destroy方法如下：

    map(0, 0).create(....)
    map(0, 0).destroy(....)

但是，在destroy方法中更改

distroming

变量并不会使创建块中的另一个线程中断，它会一直持续到持续时间结束

@volatile
protected var status: UnitStatus = UnitStatus.NEED_TO_CREATE

@volatile
protected var destroying = false

def destroy(f: Int => Unit): Unit = status match {
    case UnitStatus.DESTROYED => {
        throw new UnitAlreadyDestroyedException
    }
    case UnitStatus.DESTROYING =>
    case UnitStatus.PREPARED_TO_DESTROY => {
        destroying = true
        status = UnitStatus.DESTROYING
        async {
            waitUntil(destroyDuration, UnitStatus.DESTROYED) {
                f
            }
        }

    }
}

def create(f: Int => Unit): Unit = status match {
    case UnitStatus.DESTROYED => throw new UnitAlreadyDestroyedException
    case UnitStatus.NEED_TO_CREATE => {
        ResourcesContainer -= creationCost
        status = UnitStatus.CONSTRUCTION
        async {
            waitUntil(creationDuration, UnitStatus.READY) {
                f
            }
        }
    }
    case _ => throw new UnitAlreadyCreatedException
}

def waitUntil(seconds: Int, finalState: UnitStatus)(f: Int => Unit): Unit = {
    var timeElapse = 0
    var percent: Int = 0

    breakable {
        while (timeElapse < seconds) {
            val destroyState = isInDestroyState
            if (destroying && !destroyState) {
                break() // **program does not enter to this part of code**
            }
            timeElapse += 1
            percent = ((timeElapse.asInstanceOf[Float] / seconds) * 100).toInt
            f(percent)
            Thread.sleep(1000)
        }
        if (status != null) {
            status = finalState
        }
    }

}

def async[T](fn: => Unit): Unit = scala.actors.Actor.actor {
    fn
}

def isInDestroyState: Boolean = {
    status == UnitStatus.DESTROYED ||
        status == UnitStatus.DESTROYING ||
        status == UnitStatus.PREPARED_TO_DESTROY
}

@volatile
受保护的var状态：UnitStatus=UnitStatus.NEED__创建
@易变的
受保护的var=false
def销毁（f:Int=>Unit）：Unit=状态匹配{
case UnitStatus.destromed=>{
抛出新的UnitalReadyDestroyeException
}
case UnitStatus.status=>
case UnitStatus.PREPARED_TO_DESTROY=>{
毁灭=真
status=UnitStatus.com
异步的{
waitUntil（销毁持续时间，UnitStatus.DESTROYED）{
F
}
}
}
}
def create（f:Int=>Unit）：Unit=状态匹配{
case UnitStatus.destromed=>抛出新的UnitAlreadyDestroyedException
case UnitStatus.NEED_TO_CREATE=>{
ResourcesContainer-=creationCost
status=UnitStatus.CONSTRUCTION
异步的{
等待（creationDuration，UnitStatus.READY）{
F
}
}
}
case=>抛出新的unitalReadyCreateException
}
def waitUntil（秒：Int，最终状态：UnitStatus）（f:Int=>Unit）：单位={
var时间间隔=0
变量百分比：Int=0
易碎的{
时（时间流逝<秒）{
val destroyState=isInDestroyState
if（销毁&！销毁状态）{
break（）//**程序不进入这部分代码**
}
时间流逝+=1
百分比=（（timeelase.asInstanceOf[Float]/秒）*100）.toInt
f（百分比）
线程。睡眠（1000）
}
如果（状态！=null）{
状态=最终状态
}
}
}
def async[T]（fn:=>Unit）：Unit=scala.actors.Actor.Actor{
fn
}
def isInDestroyState:布尔={
状态==单元状态。已销毁||
状态==UnitStatus.com||
status==UnitStatus.PREPARED\u TO\u DESTROY
}