Packages

•  package root

  Definition Classes

  root

•  package com

  Definition Classes

  root

•  package thoughtworks

  Definition Classes

  com

•  package raii

  Definition Classes

  thoughtworks

•  object AsynchronousPool extends Serializable

  The namespace that contains the implementation of the asynchronous resource pool.

  The namespace that contains the implementation of the asynchronous resource pool.

  Definition Classes

  raii

  Example:

  1. Given a factory that creates resources,

     import scalaz.Tags.Parallel
     import scalaz._
     import scalaz.syntax.tag._
     import scalaz.syntax.all._
     import com.thoughtworks.future._
     import com.thoughtworks.raii.asynchronous._
     import com.thoughtworks.raii.AsynchronousPool
     import java.lang.AutoCloseable
     
     trait MyResource extends AutoCloseable {
       def inUse(): Unit
     }
     
     val myResourceStub0 = stub[MyResource]
     val myResourceStub1 = stub[MyResource]
     val myResourceStub2 = stub[MyResource]
     
     val myResourceFactoryMock = mockFunction[MyResource]
     myResourceFactoryMock.expects().returns(myResourceStub0)
     myResourceFactoryMock.expects().returns(myResourceStub1)
     myResourceFactoryMock.expects().returns(myResourceStub2)

     then it can be converted to a resource pool, which holds some instances of MyResource.

     val myResourcePool: Do[Do[MyResource]] = AsynchronousPool.fixed(
       resourceFactory = Do.autoCloseable(myResourceFactoryMock()),
       poolSize = 3
     )

     When some clients are using the resource pool,

     def client(acquire: Do[MyResource], operationsPerClient: Int): Do[Unit] = {
       Do.nested[Unit](acquire.flatMap { myResource =>
         Do.execute {
             myResource.inUse
           }
           .replicateM_(operationsPerClient)
       })
     }
     def allClients(acquire: Do[MyResource], numberOfClients: Int, operationsPerClient: Int): ParallelDo[Unit] = {
       implicit def keepLastException = new Semigroup[Throwable] {
         override def append(f1: Throwable, f2: => Throwable) = f2
       }
       Applicative[ParallelDo].replicateM_(numberOfClients, Parallel(client(acquire, operationsPerClient)))
     }
     def usingPool(numberOfClients: Int, operationsPerClient: Int) = {
       myResourcePool.flatMap { acquire =>
         allClients(acquire, numberOfClients, operationsPerClient).unwrap
       }
     }

     then the operations from these clients should be distributed on those MyResources, and those MyResources should be closed after being used.

     usingPool(numberOfClients = 10, operationsPerClient = 10).run.map { _: Unit =>
       ((myResourceStub0.inUse _): () => Unit).verify().repeated(30 to 40)
       ((myResourceStub0.close _): () => Unit).verify().once()
     
       ((myResourceStub1.inUse _): () => Unit).verify().repeated(30 to 40)
       ((myResourceStub1.close _): () => Unit).verify().once()
     
       ((myResourceStub2.inUse _): () => Unit).verify().repeated(30 to 40)
       ((myResourceStub2.close _): () => Unit).verify().once()
     
       succeed
     }.toScalaFuture

• ClosedPoolException

com.thoughtworks.raii.AsynchronousPool

ClosedPoolException 