精华内容
下载资源
问答
  • 黑猴子的家:Scala 线程安全集合

    千次阅读 2019-06-01 21:53:00
    所有线程安全集合都是以Synchronized开头的集合,例如 SynchronizedBuffer SynchronizedMap SynchronizedPriorityQueue SynchronizedQueue SynchronizedSet SynchronizedStack 非线程安全集合,在多线程操作...

    所有线程安全的集合都是以Synchronized开头的集合,例如

    SynchronizedBuffer
    SynchronizedMap
    SynchronizedPriorityQueue
    SynchronizedQueue
    SynchronizedSet
    SynchronizedStack
    

    非线程安全的集合,在多线程操作中,可能会出现售票背论

    展开全文
  • scala并行化集合

    千次阅读 2017-10-06 15:39:44
    scala底层已经实现并行化集合 (但瓶颈会限制在单机上====> 所以 分布式 spark)reduce求和是采用... 且叠加时为单线程优化:使用并行化集合 scala.collection.parallel parallelscala> val lst0 = List(1,2,8,5,6,3,0

    scala底层已经实现并行化集合 (但瓶颈会限制在单机上====> 所以 分布式 spark)

    reduce求和是采用reduceLeft (从左叠加)
    缺点: 速度回随着元素的增加而增加!!!
    且叠加时为单线程

    优化:使用并行化集合 scala.collection.parallel
    parallel

    scala> val lst0 = List(1,2,8,5,6,3,0,7,9)
    lst0: List[Int] = List(1, 2, 8, 5, 6, 3, 0, 7, 9)
    
    scala> lst0.reduce(_+_)
    res17: Int = 41
    
    scala> lst0.par
    res18: scala.collection.parallel.immutable.ParSeq[Int] = ParVector(1, 2, 8, 5, 6, 3, 0, 7, 9)
    
    scala> lst0.par.reduce(_+_)
    res19: Int = 41

    par 调用的不再是reduceLeft 而是 放在线程池里 多个线程去计算

    这里写图片描述

    并行化集合 每个初始值100都会在每个线程内初始一次
    多核 每次分配的线程都不一样 所以结果每次不一定相等

    scala> lst0.par.reduce(_+_)
    res19: Int = 41
    
    scala> lst0.par.fold(0)(_+_)
    res20: Int = 41
    
    scala> lst0.par.fold(100)(_+_)
    res21: Int = 741
    
    scala> lst0.par.fold(100)(_+_)
    res22: Int = 441
    
    scala> lst0.par.fold(100)(_+_)
    res23: Int = 841
    
    scala> lst0.par.fold(100)(_+_)
    res24: Int = 841
    
    scala> lst0.par.fold(100)(_+_)
    res25: Int = 841
    scala> val arr = List(List(1,2,3), List(3,4,5), List(2), List(0))
    
    scala> arr.aggregate(100)(_+_.sum,_+_)
    res27: Int = 120
    
    scala> arr.aggregate(100)(_+_.sum,_+_)
    res28: Int = 120
    
    scala> arr.aggregate(100)(_+_.sum,_+_)
    res29: Int = 120
    //最大只会是420
    scala> arr.par.aggregate(100)(_+_.sum,_+_)
    res30: Int = 420
    //最大只会是420
    scala> arr.par.aggregate(100)(_+_.sum,_+_)
    res31: Int = 420
    scala> arr.par.aggregate(100)(_+_.sum,_+_)
    res45: Int = 420
    
    scala> arr.par.aggregate(100)(_+_.sum,_+_)
    res46: Int = 320
    
    scala> arr.par.aggregate(100)(_+_.sum,_+_)
    res47: Int = 420
    
    scala> arr.par.aggregate(100)(_+_.sum,_+_)
    展开全文
  • Scala中的集合

    2020-05-08 10:34:59
    集合从不改变,因此可以安全地共享其引用。 甚至是在一个多线程的应用程序当中也没问题。 集合的操作: 2、列表 (1)不可变列表(List) 不可变列表的相关操作: (2)可变列表(LinkedList):scala....

    1、可变集合和不可变集合

    (1)可变集合

    (2)不可变集合:

    集合从不改变,因此可以安全地共享其引用。
    甚至是在一个多线程的应用程序当中也没问题。

    在这里插入图片描述

    集合的操作:
    在这里插入图片描述

    2、列表

    (1)不可变列表(List
    在这里插入图片描述

    不可变列表的相关操作:
    在这里插入图片描述

    (2)可变列表(LinkedList):scala.collection.mutable
    在这里插入图片描述

    3、序列

    常用的序列有:VectorRange

    (1)Vector是ArrayBuffer的不可变版本,是一个带下标的序列
    在这里插入图片描述
    (2)Range表示一个整数序列
    在这里插入图片描述

    4、集(Set)和集的操作

    集Set是不重复元素的集合 和列表不同,集并不保留元素插入的顺序。默认以Hash集实现

    示例1:创建集
    在这里插入图片描述

    示例2:集的操作
    在这里插入图片描述

    5、模式匹配

    Scala有一个强大的模式匹配机制,可以应用在很多场合:

    switch语句
    类型检查

    Scala还提供了样本类(case class),对模式匹配进行了优化

    模式匹配示例:
    更好的switch
    在这里插入图片描述

    Scala的守卫
    在这里插入图片描述

    模式匹配中的变量
    在这里插入图片描述
    类型模式
    在这里插入图片描述
    匹配数组和列表
    在这里插入图片描述
    在这里插入图片描述

    6、样本类(Case Class)

    简单的来说,Scala的case class就是在普通的类定义前加case这个关键字,然后你可以对这些类来模式匹配。

    case class带来的最大的好处是它们支持模式识别

    首先,回顾一下前面的模式匹配:
    在这里插入图片描述

    其次,如果我们想判断一个对象是否是某个类的对象,跟Java一样可以使用isInstanceOf
    在这里插入图片描述
    在这里插入图片描述

    最后,在Scala中有一种更简单的方式来判断,就是case class
    在这里插入图片描述

    注意:需要在class前面使用case关键字。

    展开全文
  • JavaConversions对象提供了用于在Scala和Java集合之间来回转换的一组方法。 给目标值显式地指定一个类型来触发转换 例如: import scala col lec ti JavaConversions._ val props: scala.collection.mutable.Map...

    JavaConversions对象提供了用于在Scala和Java集合之间来回转换的一组方法。
    给目标值显式地指定一个类型来触发转换 例如:

    import scala col lec ti JavaConversions._
    val props: scala.collection.mutable.Map[String, String] = System .getProperties()
    

    如果你担心那些不需要的隐式转换也被引人的话,只引入需要的即可 例如:

    import scala.collection.JavaConversions.propertiesAsScalaMap
    

    注意这些转换产出的是包装器,让你可以使用目标接口来访问原本的值。举例来说,如果你用

    val props: scala.collection.mutable.Map[String, String] = System.getProperties()
    

    那么props就是一个包装器,其方法将调用底层的Java对象。如果你调用

    props ("com.horstmann.scala")= "impatient"
    

    那么包装器将调用底层Properties对象的put("com.horstmann.scala", "impatient")
    从Scala集合到Java集合的转换:

    隐式函数从scala.collection的类型到java.util的类型
    asJavaCollectionIterableCollection
    asJavaIterableIterableIterable
    asJavaIteratorIteratorIterator
    asJavaEnumerationIteratorEnumeration
    seqAsJavaListSeqList
    mutableSeqAsJavaListmutable.SeqList
    bufferAsJavaListmutable.BufferList
    setAsJavaSetSetSet
    mutableSetAsJavaSetmutable.SetSet
    mapAsJavaMapMapMap
    mutableMapAsJavaMapmutable.MapMap
    asJavaDictionaryMapDictionary
    asJavaConcurrentMapmutable.ConcurrentMapconcurrent.ConcurrentMap

    从Java集合到Scala集合的转换:

    隐式函数从java.util的类型到scala.collection的类型
    collectionAsScalaIterableCollectionIterable
    iterableAsScalaIterableIterableIterable
    asScalaIteratorIteratorIterator
    enumerationAsScalaIteratorEnumerationIterator
    asScalaBufferListmutable.Buffer
    asScalaSetSetmutable.Set
    mapAsScalaMapMapmutable.Map
    dictionaryAsScalaMapDictionarymutable.Map
    propertiesAsScalaMapPropertiesmutable.Map
    asScalaConcurrentMapconcurrent.ConcurrentMapmutable.ConcurrentMap

    并行集合

    Scala提供的用于操纵大型集合的解决方案十分诱人。这些任务通常可以很自然地并行操作。举例来说,要计算所有元素之和,多个线程可以并发地计算不同分区的和;最后这些部分的结果被汇总到一起。要对这样的并发任务进行排程是很伤脑筋的,但若用Scala ,则你无须担心这个问题。如果coll是个大型集合,那么

    val coll = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(coll.par.sum)
    

    上述代码会并发地对它求和。par方法产出当前集合的一个并行实现。该实现会尽可能并行地执行集合方法。例如:

    coll.par.count(_ % 2 == 0)
    

    将会并行地对偶集合求前提表达式的值,然后将结果组合在一起,得出coll中所有偶数的数量。
    你可以通过对要遍历的集合应用.par并行化for循环,就像这样:

    for (i <- ((0 until 10)).par) {
          print(s"$i ")
        }
    // 输出: 7 9 3 2 1 8 5 4 0 6
    

    数字是按照作用于该任务的线程产出的顺序输出的。而在for/yield循环中,结果是依次组装的。如下:

    (for(i<- (0 until 100000).par) yield i) == (0 until 100000)
    

    注意:如果并行运算修改了共享的变量,则结果无法预知。举例来说, 不要更新个共享的计数器:

        var count = 0
        for (c <- coll.par) {
          if (c % 2 == 0) {
            count += 1
          }
        }
    

    par方法返回的并行集合属于扩展自ParSeq、ParSet或ParMap特质的类型。这些并不是Seq、Set、Map 的子类型,你不能向一个预期顺序集合( sequential collection ) 的方法传入并行集合。
    你可以用seq方法将并行集合转换回顺序集合:

    val result= coll.par.filter(_ % 2 == 0).seq
    

    并非所有方法都能被并行化。例如,reduceLeft和reduceRight要求每个操作符都要按顺序应用。有另一个方法reduce,对集合的部分进行操作然后组合出结果。为了让这个方案可行,操作符必须是结合的( associative ),它必须满足 ( a   o p   b )   o p   c = a   o p   ( b   o p   c ) (a\ op\ b)\ op\ c = a\ op\ (b\ op\ c) (a op b) op c=a op (b op c)的要求。例如,加法是结合的而减法不是: ( a − b ) − c ≠ a − ( b − c ) (a - b) - c \neq a - (b - c) (ab)c=a(bc)
    同理,还有一个fold方法对集合的部分进行操作。可惜它并不像foldLeft和foldRight那么灵活,操作符的两个参数都必须是元素。也就是说,你可以执行coll.par.fold(0)(_ + _),但不能执行更复杂的折叠。
    要解决这个问题,有个更一般的aggregate方法,将操作符应用到集合的部分,然后用另一个操作符来组合出结果。例如,str.par.aggregate(Set[Char]())(_ + _, _ ++ _)等效于str.foldLeft(Set[Char]())(_ + _),得到str中所有不同字符的集。
    说明: 默认情况下,并行集合使用全局的fork-join线程池,该线程池非常适用于高处理器开销的计算。如果你执行的并行步骤包含阻塞调用,就应该另选一种“执行上下文(execution context)”。

    参考:快学scala(第二版)

    展开全文
  • scala数组、集合函数大全
  • scala使用并行集合 导入依赖 在scala 2.13.x版本中,使用并行集合需要引用依赖。 在这里,你可以查询到需要引入的文件和对应的代码 找到合适的版本后,复制代码: 网站中给出的xml应当包含在dependencies标签中: &...
  • Scala--集合操作

    2020-05-22 15:34:17
    ** 集合元素的映射 – map 映射操作** 问题抛出: 将 List(3,5,7) 中所有元素都 * 2,将其结果放到一个新的集合中返回,即返回 List(6,10,14) 传统方法: map 映射操作是一个操作,针对所有集合,并不是只针对 Map ...
  • 这个集合,可以用于存放无穷多个元素,但是这无穷个元素并不会一次性生产出来,而是需要用到多大的区间,就会动态的生产,末尾元素遵循lazy规则(即:要使用结果才进行计算的) 。 创建Stream对象 def numsForm(n: ...
  • Scala 自学笔记 集合

    万次阅读 2015-03-11 17:15:21
    Scala集合的主要特质 Iterator,用来访问集合中所有元素 val coll = ... // 某种Iterable val iter = col.iterator while(iter.hasNext) iter.next() Seq是一个有先后次序的值得序列,比如数组或列表。 ...
  • Scala集合总结

    2019-09-26 19:55:59
    Scala集合总结 最近有时间看了一下Scala,总结了一下Scala集合,和大家分享一下。 1.基本概念 scala中的集合类可以分为三大类: 1.Seq,是一组有序的元素,比如List,Array 2.Set,是一组没有重复元素的集合。 3.Map...
  • 集合从不改变,因此可以安全地共享其引用。 甚至是在一个多线程的应用程序当中也没问题。 集合的操作: 二、列表 2.1不可变列表(List) 不可变列表的相关操作: 2.2 可变列表(LinkedList):scala....
  • 调用集合的 par 方法, 会将集合转换成并行化集合 object Day03 { def main(args: Array[String]): Unit = { val list0 = List(1,2,3,4,5) println(list0.par.fold(0)(_ + _))//15 println(list0.par.fold(10)(_ ...
  • MapOption理解空指针异常Option的一些方法TupleQueueKafka分区Queue并发和并行线程安全问题 Seq是个特质,不能直接创建对象;可以使用其下面的类;学习Seq,就是学习Seq下面的类 1. Seq Scala默认提供不可变集合,...
  • scala的collections在版本2.8之后有一个重要的改变,但也兼容2.8版本之前的大部分集合。2.8版本的集合提供了一个通用的,一致的,并且包含所有集合类型的框架。你在最初的变更中可能感觉不到太明显的变化,但是你会...
  • scala集合类型

    2021-08-03 11:54:45
    1. 不可变集合可以安全的并发访问。 2. 可变集合可以在适当的地⽅被更新或扩展。这意味着你可以修改,添加,移除⼀个集合的元素。 Scala集合有三大类:序列Seq、集Set、映射Map,所有的集合都扩展自Iterable...
  • Scala 集合类系统地区分了可变的和不可变的集合scala.collection 包中所有的集合scala.collection.mutable 中的所有集合类 可变集合,顾名思义,意味着你可以修改,移除或者添加一个元素。 scala.collection...
  • scala集合

    2016-05-30 14:20:00
    不可变集合适用于大多数情况,让程序易于理解和推断,因为它们是引用透明的( referentially transparent )因此缺省也是线程安全的。 使用可变集合时,明确地引用可变集合的命名空间。不要用使用import scala....
  • Scala 指南: 集合类型

    2014-05-22 16:53:53
    对于学习 Scala 的 Java™ 开发人员来说,对象是一个比较自然、简单的入口点。在 本系列 前几期文章中,我介绍了 Scala 中一些面向对象的编程方法,这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 ...
  • Scala数据集合操作

    千次阅读 2016-08-22 17:49:36
    大数据技术是数据的集合以及对数据集合的操作技术的统称,具体来说: ...Spark的框架实现语言是Scala,首选的应用程序开发语言也是Scala,所以Scala集合以及集合操作的支持就至关重要且必须异常强
  • Scala集合笔记

    2020-02-05 23:29:06
    不可变集合(可以安全地并发访问) 默认都是不可变集合Scala集合都提供了可变和不可变的版本 Scala集合有三大类:序列Seq(有序、线性)、集Set、映射Map(Key->Value,都实现了iterable特质 Scala 数组和java ...
  • Scala集合归纳

    2020-09-08 21:53:38
    Scala集合归纳 1. 背景 2. 序列 3. Set 4. 元组 5. Map 6. Option 7.常见集合方法
  • scala并行集合

    千次阅读 2017-01-19 15:47:30
    将普通集合转化成为并行集合:arr(非并行) arr.par(并行集合) 1现在有一个集合,对它的每个元素进行处理,比如: scala> (1 to 5).foreach(println(_)) ...2以下代码获取到参与并行计算的线程scala> (0
  • Scala同时支持不可变集合和可变集合,不可变集合可以安全的并发访问。Scala默认采用不可变集合,对于几乎所有的集合类,Scala都同时提供了 可变(mutable)和不可变(immutable)的版本。Scala集合有三大类:序列Seq、...
  • 通过Scala对文件进行读写操作在实际业务中应用也比较多,这里介绍几种常用的方式,直接上代码: 1.从文件中读取内容 object Main { def loadData(): Array[String] = { var bs: BufferedSource = null var in: ...
  • Scala集合

    2021-08-03 20:43:10
    不可变集合可以安全的并发访问。 2. 可变集合可以在适当的地⽅被更新或扩展。这意味着你可以修改,添加,移除⼀个集合的元素。 不可变集合,相⽐之下,永远不会改变。不过,你仍然可以模拟添加,移除或更新操作。...
  • 场景 因为在工作的时候,不会去过度的考虑高并发的...集合安全问题代码展示 List 这里是一段代码 List<String> list = new ArrayList<>(); for (int i = 0; i < 300; i++) { new Thread(() -> {

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,279
精华内容 4,111
关键字:

scala线程安全集合