1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

package com.fluffy.test_concurrent

import java.util.concurrent.{CountDownLatch, TimeUnit}


object Demo_blocking extends App {

  import scala.concurrent.{Future, blocking}
  import scala.concurrent.ExecutionContext.Implicits.global

  Future {
    var num = 66
    blocking {
      TimeUnit.SECONDS.sleep(1)
      num = 88
      println(s"blocking--in--code-- ${num}")
    }
    println(s"blocking--out--code-- ${num}")
  }
  TimeUnit.SECONDS.sleep(2)
  println("上面这个num 都是88 说明是阻塞的")


  def test1000() {
    val array1000 = new Array[String](1000)
    val latch01 = new CountDownLatch(1000)
    (0 until 1000) foreach { n =>
      Future {
        TimeUnit.MILLISECONDS.sleep(30)
        val str = Thread.currentThread.getName.intern()
        array1000.update(n, str)
        latch01.countDown()
      }
    }

    latch01.await()
    val distinct01: Array[String] = array1000.distinct
    distinct01.takeRight(5).foreach(println(_))
    println(s"不启用blocking--线程数 -- ${distinct01.size} ")
  }

  test1000()

  val arrayOut = new Array[String](1000)
  val arrayIn = new Array[String](1000)
  val latch02 = new CountDownLatch(1000)
  (0 until 1000) foreach { n =>
    Future {
      val strOut = Thread.currentThread.getName.intern()
      arrayOut.update(n, strOut)
      blocking { // 顾名思义，阻塞住当前线程，相当于一个新future 并且当线程池被用完了，还会创建新的线程去执行
        val strIn = Thread.currentThread.getName.intern()
        arrayIn.update(n, strIn)
        TimeUnit.MILLISECONDS.sleep(500)
        latch02.countDown()
      }
      TimeUnit.MILLISECONDS.sleep(100)
    }
  }

  println()
  latch02.await()
  val outCount: Array[String] = arrayOut.distinct
  outCount.takeRight(5).foreach(println(_))
  println("启用blocking--out-线程数 -- " + outCount.size)

  val inCount: Array[String] = arrayIn.distinct
  inCount.takeRight(5).foreach(println(_))
  println("启用blocking--in-线程数 -- " + inCount.size)
  println()

  test1000()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

blocking--in--code-- 88
blocking--out--code-- 88
上面这个num 都是88 说明是阻塞的
scala-execution-context-global-13
scala-execution-context-global-14
scala-execution-context-global-16
scala-execution-context-global-15
不启用blocking--线程数 -- 4 

scala-execution-context-global-265
scala-execution-context-global-266
scala-execution-context-global-267
scala-execution-context-global-268
scala-execution-context-global-269
启用blocking--out-线程数 -- 257
scala-execution-context-global-265
scala-execution-context-global-266
scala-execution-context-global-267
scala-execution-context-global-268
scala-execution-context-global-269
启用blocking--in-线程数 -- 257

scala-execution-context-global-238
scala-execution-context-global-237
scala-execution-context-global-241
scala-execution-context-global-240
scala-execution-context-global-239
不启用blocking--线程数 -- 229