Home Php C# Sql C C++ Javascript Python Java Go Android Git Linux Asp.net Django .net Node.js Ios Xcode Cocoa Iphone Mysql Tomcat Mongodb Bash Objective-c Scala Visual-studio Apache Elasticsearch Jar Eclipse Jquery Ruby-on-rails Ruby Rubygems Android-studio Spring Lua Sqlite Emacs Ubuntu Perl Docker Swift Amazon-web-services Svn Html Ajax Xml Java-ee Maven Intellij-idea Rvm Macos Unix Css Ipad Postgresql Css3 Json Windows-server Vue.js Typescript Oracle Hibernate Internet-explorer Github Tensorflow Laravel Symfony Redis Html5 Google-app-engine Nginx Firefox Sqlalchemy Lucene Erlang Flask Vim Solr Webview Facebook Zend-framework Virtualenv Nosql Ide Twitter Safari Flutter Bundle Phonegap Centos Sphinx Actionscript Tornado Register | Login | Edit Tags | New Questions | 繁体 | 简体


10 questions online user: 17

0
votes
answers
46 views
+10

火花流:映射點到隊列

-1

我是新的火花流,我不明白地圖如何工作。我想從一個流排隊一些問題後,我從一個構造函數,因此我寫它傳遞的是:火花流:映射點到隊列

val data = inp.flatMap(_.split(",")) 
val points = data.map(_.toDouble) 
val queue: Queue[Point] = new Queue[Point] 
points.foreachRDD(rdd => { 
rdd.map(x => queue.enqueue(new Point(x,1))) 
}) 

當我打印隊列的大小始終爲零。

沙发
0
0

Spark中的所有轉換都是懶惰的,它們不會馬上計算結果。相反,他們只記得應用於某些基礎數據集的轉換。轉換僅在動作需要將結果返回給驅動程序時計算。

既然你在這裏申請地圖功能,它是一種懶洋洋地評估並不會computed.Instead,DAG的建立。只有在調用某個動作時纔會評估這一點。你可能想嘗試收集或任何其他行動來實現這一點。

你可以在這裏閱讀更多關於這個。它有點老,但內容豐富。 https://training.databricks.com/visualapi.pdf

0
votes
answers
85 views
+10

替代加特林

2

我最近一直有問題,因爲我的依賴項已更新爲使用netty 4.1,而Gatling尚未更新一段時間,並且仍然只能在Netty 4.0上運行。替代加特林

任何人都知道Gatling的任何替代方法來創建類似的性能測試的模擬和場景,以便在我的Maven生命週期中自動運行嗎?

沙发
0
3

如果你尋找基於代碼的東西那就是:

對於UI和/或基於XML腳本定義,你可以檢查出:

退房Open Source Load Testing Tools: Which One Should You Use?瞭解更多有關上述工具,並決定哪一個適合你最。

板凳
0
2

Apache JMeter是加特林的一個已知替代品。

它經常更新(每年至少發佈2個主要版本),並且擁有強大的用戶羣和大量的商業優惠。

有一個最近更頻繁更新的Maven插件,在2個月內已經有4個版本。

查看更多細節的代碼覆蓋率。

+0

是的,它是可能的運行它在一個Maven的生命週期?我一直使用手動 – paul

+0

是的,JMeter Maven插件旨在做到這一點。 https://github.com/jmeter-maven-plugin/jmeter-maven-plugin – cezarykluczynski

+0

30%的代碼覆蓋率?嗯,謝謝,但讓我們看看它有任何其他的替代 – paul

地板
0
1

這裏還有一個不同工具的benchmark comparison

如果你是JavaScript/Ecma熟悉k6做這項工作。

4楼
0
1

作爲一個很好的替代加特林,我會建議你檢查蝗蟲。 Locust專門爲您提供的好處是,它是基於代碼的性能測試工具,不會強制您僅使用特定的編程語言(如Python)編寫測試。因爲如果你之前使用過Scala,那麼在編寫測試時,使用Locust框架進行測試比使用Locust框架更有可能更適合切換到Java甚至Kotlin之類的東西。您可以通過以下鏈接找到得心應手教程:

https://www.blazemeter.com/blog/locust-performance-testing-using-java-and-kotlin

+0

看起來很有趣,我一直在尋找碰Kotlin。謝謝! – paul

5楼
0
1

兩個最好的開源替代品磨牀是JMeter的和蝗蟲。 JMeter擁有優秀的用戶羣和支持社區,並提供直觀的界面。它還提供了很多第三方插件,並支持大多數協議(如HTTP,FTP,JDBC,SOAP,LDAP等)。儘管Locust是一個相對較新的工具,但它提供了很大的靈活性,因爲您可以使用純Python編寫測試。 Locust主要是爲HTTP協議而構建的,所以如果你正在使用基於HTTP的應用程序,你可以嘗試一下。在使用leading software testing company進行工作時,我對這兩種工具在不同的性能測試項目上都有實際操作經驗。

希望這些信息能夠幫助您根據您的測試要求爲Gatling選擇正確的替代方案。

感謝

維沙爾

75
votes
answers
22 views
+10

Restart elasticsearch node

What is the proper way to restart node in elasticsearch? (preferably via the REST API, java API might be ok too)

up vote 61 down vote accepted favorite
沙发
+610
+50

重啟節點的正確方法是使用shutdown API或向TERM進程發送信號(例如with kill $PID將其關閉

關閉後,您可以使用您用於運行elasticsearch的任何內容啟動新節點,例如服務包裝器,或者只是從命令行啟動它。

如果您正在使用服務包裝器,則可以通過向其傳遞restart命令來重新啟動節點:例如,/etc/init.d/elasticsearch restart但這只是上述的便利包裝器。

restart自版本0.11以來API已被禁用,因為它存在問題。

使用通常的linux服務重啟工具重新啟動會導致分片重新分配過程(我使用elasticsearch-head插件觀察)。在我的環境中,我看到分配給重新啟動的節點的所有分片都進入UNASSIGNED狀態並逐漸重新分配。是否有更簡潔的方式重新啟動服務,以便可以減少完整分片重新分配過程的命中? - 拉里西爾弗曼2014年8月19日16:26

+70

有一個類似於shutdown API的重啟API只需將“shutdown”替換為“restart”即可。另請參閱github上問題

我只是讀了你的答案,我想 - 太糟糕了,沒有記錄在任何地方..然後我打開鏈接,我看到你只是寫在那裡:)謝謝! - 用戶1768906 2013年1月2日8:59

@tzofia你是否成功使用_restart API?您是否從服務層運行ES實例?我問,因為在Windows下,我收到以下錯誤:ElasticSearchIllegalStateException [重啟已禁用(現在)....] - dadoonet 2013年1月2日在17:36

@dadoonet其實我看到它是由Shay Banon寫的所以我依靠它並且還沒有檢查它。我剛才檢查了一下,我得到了和你一樣的錯誤(在ubuntu上)....任何建議? - 用戶1768906 2013年1月2日18:42

我在這個問題上添加了評論:github.com/elasticsearch/elasticsearch/issues / ...等等看Shay的回答。;-) - dadoonet 2013年1月2日22:31

+70

每次節點出現故障和/或新節點出現時,集群都會重新分配分片,這在您只需要重新啟動節點時可能不需要,因此您可以使用Rolling restart:

  1. 首先禁用分片分配:

    PUT / _cluster / settings {“transient”:{“cluster.routing.allocation.enable”:“none”}}

  2. 重啟節點 service elasticsearch restart

  3. 啟用分片分配:

    PUT / _cluster / settings {“transient”:{“cluster.routing.allocation.enable”:“all”}}

更多相關內容:這裡

9
votes
answers
4 views
+10

Decoding JSON values in circe where the key is not known at compile time

Suppose I've been working with some JSON like this:

{ "id": 123, "name": "aubergine" }

By decoding it into a Scala case class like this:

case class Item(id: Long, name: String)

This works just fine with circe's generic derivation:

scala> import io.circe.generic.auto._, io.circe.jawn.decode
import io.circe.generic.auto._
import io.circe.jawn.decode

scala> decode[Item]("""{ "id": 123, "name": "aubergine" }""")
res1: Either[io.circe.Error,Item] = Right(Item(123,aubergine))

Now suppose I want to add localization information to the representation:

{ "id": 123, "name": { "localized": { "en_US": "eggplant" } } }

I can't use a case class like this directly via generic derivation:

case class LocalizedString(lang: String, value: String)

…because the language tag is a key, not a field. How can I do this, preferably without too much boilerplate?

沙发
+90

您可以通过几种不同的方式将单例JSON对象解码为案例类,如 LocalizedString 最简单的是这样的:

  import io.circe.Decoder implicit val decodeLocalizedString:Decoder [LocalizedString] = Decoder [Map [String,String]]。map {kvs => LocalizedString(kvs.head._1,kvs.head._2)}   

这样做的缺点是在空的JSON对象上抛出一个异常,并且在行为未定义的情况下不止一个领域。您可以修复这样的问题:

  implicit val decodeLocalizedString:Decoder [LocalizedString] = Decoder [Map [String,String]]。map(_。toList).emap {case List(( k,v))=> 右(LocalizedString(K,v))案例Nil => 左(“空对象,预期单身”)案例_ => 左(“Multiply-fielding object,expected singleton”)}   

这可能是低效的,特别是如果你有可能最终试图解码真正大的JSON对象(这会转换成地图,然后是对的列表,只是为了失败。)。

如果你关心性能,你可以这样写:

  import io.circe.DecodingFailure implicit val decodeLocalizedString:Decoder [LocalizedString] = {c => c.value.asObject match {case Some(obj)if obj.size == 1 => val(k,v)= obj.toIterable.head v.as [String] .map(LocalizedString(k,_))case None => Left(DecodingFailure(“LocalizedString; expect singleton object”,c.history))}}   

然而,这解码了单例对象本身,并且在我们想要的表示中,我们有一个 {“localized”:{...}} 包装器。我们可以在最后用一个额外的行来容纳它:

  implicit val decodeLocalizedString:Decoder [LocalizedString] = Decoder.instance {c =&gt; c.value.asObject match {case Some(obj)if obj.size == 1 =&gt; val(k,v)= obj.toIterable.head v.as [String] .map(LocalizedString(k,_))case None =&gt; Left(DecodingFailure(“LocalizedString; expect singleton object”,c.history))}} .prepare(_。downField(“localized”))< / code>  

这适用于我们更新的 Item 类的一般派生实例:

  import io.circe.generic。 auto._,io.circe.jawn.decode case class Item(id:Long,name:LocalizedString)  

然后:

  scala&gt; val doc =“”“{”id“:123,”name“:{”localized“:{”en_US“:”eggplant“}}}”“”doc:String = {“id”:123,“name” :{“localized”:{“en_US”:“eggplant”}}} scala&gt; val Right(result)= decode [Item](doc)result:Item = Item(123,LocalizedString(en_US,eggplant))  

自定义编码器更直接: < pre> import io.circe。{Encoder,Json,JsonObject},io.circe.syntax._ implicit val encodeLocalizedString:Encoder.AsObject [LocalizedString] = {case LocalizedString(k,v)=&gt; JsonObject(“localized”:= Json.obj(k:= v))}

然后:

  scala&gt; result.asJson res11:io.circe.Json = {“id”:123,“name”:{“localized”:{“en_US”:“eggplant”}}}   

这方法适用于任何数量的“动态”字段 - 您可以将输入转换为 Map [String,Json] JsonObject ,并使用密钥 - 值对直接。 {Encoder,Json,JsonObject},io.circe.syntax._ implicit val encodeLocalizedString:Encoder.AsObject [LocalizedString] = {case LocalizedString(k,v)=&gt; JsonObject(“localized”:= Json.obj(k:= v))}

然后:

  scala&gt; result.asJson res11:io.circe.Json = {“id”:123,“name”:{“localized”:{“en_US”:“eggplant”}}}   

这方法适用于任何数量的“动态”字段 - 您可以将输入转换为 Map [String,Json] JsonObject ,并使用密钥 - 值对直接。 {Encoder,Json,JsonObject},io.circe.syntax._ implicit val encodeLocalizedString:Encoder.AsObject [LocalizedString] = {case LocalizedString(k,v)=&gt; JsonObject(“localized”:= Json.obj(k:= v))}

然后:

  scala&gt; result.asJson res11:io.circe.Json = {“id”:123,“name”:{“localized”:{“en_US”:“eggplant”}}}   

这方法适用于任何数量的“动态”字段 - 您可以将输入转换为 Map [String,Json] JsonObject ,并使用密钥 - 值对直接。 _ implicit val encodeLocalizedString:Encoder.AsObject [LocalizedString] = {case LocalizedString(k,v)=&gt; JsonObject(“localized”:= Json.obj(k:= v))}

然后:

  scala&gt; result.asJson res11:io.circe.Json = {“id”:123,“name”:{“localized”:{“en_US”:“eggplant”}}}   

这方法适用于任何数量的“动态”字段 - 您可以将输入转换为 Map [String,Json] JsonObject ,并使用密钥 - 值对直接。 _ implicit val encodeLocalizedString:Encoder.AsObject [LocalizedString] = {case LocalizedString(k,v)=&gt; JsonObject(“localized”:= Json.obj(k:= v))}

然后:

  scala&gt; result.asJson res11:io.circe.Json = {“id”:123,“name”:{“localized”:{“en_US”:“eggplant”}}}   

这方法适用于任何数量的“动态”字段 - 您可以将输入转换为 Map [String,Json] JsonObject ,并使用密钥 - 值对直接。

0
votes
answers
39 views
+10

Spark可以直接將數據讀入嵌套的case類嗎?

0

假設您有一個包含三列的CSV:item,usernameuserid。它是利用星火的數據集API在讀這一個相當簡單的事情:Spark可以直接將數據讀入嵌套的case類嗎?

case class Flat(item: String, username: String, userid: String) 
ds = sparkSession.read.csv("path/to/data").toDF("item", "username", "userid").as[Flat] 

然後dsDataset[Flat]類型。

但是,假設你希望你的數據有地方Nested由下式給出形式Dataset[Nested]

case class User(name: String, id: String) 
case class Nested(item: String, user: User) 

一種方式做到這一點是將數據讀入Dataset[Flat],然後應用map改造它變成Dataset[Nested],但實際上案例類通常不需要其他任何東西,並且它使得代碼不必要地冗長。有沒有辦法跳過中間人並直接構造Dataset[Nested]

+0

您是否嘗試使用sparkContext而不是sqlContext讀取它,然後使用地圖將它轉換爲嵌套的case類? –

沙发
0
1

有什麼辦法可以跳過中間人,直接構造數據集[嵌套]?

有沒有 - Datasets匹配的結構和名稱。你不能只是重新設計名稱和數據。

如果你喜歡跳過Flat定義只是使用動態API

import org.apache.spark.sql.functions._ 

ds.select($"item", struct($"name", $"id") as "user").as[Nested] 

as[Flat]並沒有真正類型檢查,所以你不鬆任何事情。

+0

這是一個很好的妥協解決方案 - 謝謝! –

0
votes
answers
23 views
+10

使用無形的類型級別過濾

2

有沒有人知道如何使用無形的測試工作。使用無形的類型級別過濾

package net.jtownson.swakka.jsonschema 

import org.scalatest.FlatSpec 
import org.scalatest.Matchers._ 

class OptionalFieldSpec extends FlatSpec { 

    case class A(i: Int, j: Option[Int]) 

    "an extractor of some kind" should "get the (non)optional fields from a case class" in { 

    extractNonOptionalFieldNames[A] shouldBe List("i") 

    extractOptionalFieldNames[A] shouldBe List("j") 

    } 

    def extractNonOptionalFieldNames[T <: Product](/* implicit typeclass instances? */): List[String] = ??? 

    def extractOptionalFieldNames[T <: Product]: List[String] = ??? 

} 

我有一個不運行時實例或它的仿製藥,因爲我在對的情況下A類,它是獨立於任何特定實例的創建工作JsonSchema。該模式有一個所需的字段,該字段是非可選字段的列表。例如

{ 
    "type" -> "object", 
    "required" -> ["i"], 
    "properties" -> { 
    "i" -> { 
     "type" -> "integer", 
     "format" -> "int32" 
    } 
    } 
} 
+0

你想'LabelledGeneric' - 這將使你的字段名的類型級證人,以及它們的類型。除此之外,似乎你只是想過濾這個HList。 – Alec

沙发
0
3

事情是這樣的:

trait FieldNameExtractor[T] extends Serializable { 
    import shapeless.ops.hlist.{RightFolder, ToTraversable} 
    import shapeless.ops.record.Keys 
    import shapeless.{HList, HNil, LabelledGeneric, Poly2} 

    /** 
    * Extracts filtered field names for type [[T]], 
    * given a polymorphic function that acts as the type filter 
    */ 
    def extract[L <: HList, R <: HList, O <: HList](op: Poly2)(
     implicit lgen: LabelledGeneric.Aux[T, L], 
     folder: RightFolder.Aux[L, HNil.type, op.type, R], 
     keys: Keys.Aux[R, O], 
     traversable: ToTraversable.Aux[O, List, Symbol] 
): List[String] = { 
    val result = keys().to[List] 
    result.map(_.name) 
    } 
} 

object FieldNameExtractor { 
    def apply[T] = new FieldNameExtractor[T] {} 
} 

用法:

import org.scalatest.FlatSpec 
import org.scalatest.Matchers._ 

class Test extends FlatSpec { 
    /* type filters */ 
    import shapeless.{HList, Poly2} 
    import shapeless.labelled.KeyTag, shapeless.tag.Tagged 

    type FilterO[A, T] = Option[A] with KeyTag[Symbol with Tagged[T], Option[A]] 

    trait Ignore extends Poly2 { 
    implicit def default[A, L <: HList] = at[A, L]((_, l) => l) 
    } 
    trait Accept extends Poly2 { 
    implicit def default[A, L <: HList] = at[A, L](_ :: _) 
    } 

    object allOptions extends Ignore { 
    implicit def option[A, T, L <: HList] = at[FilterO[A, T], L](_ :: _) 
    } 
    object noOptions extends Accept { 
    implicit def option[A, T, L <: HList] = at[FilterO[A, T], L]((_, l) => l) 
    } 

    "an extractor of some kind" should "get the (non)optional fields from a case class" in { 
    case class A(i: Int, j: Option[Int], k: String) 

    val fne = FieldNameExtractor[A] 
    fne.extract(noOptions) shouldBe List("i", "k") // extractNonOptionalFieldNames 
    fne.extract(allOptions) shouldBe List("j")  // extractOptionalFieldNames 
    } 
} 
+0

美麗。謝謝。其實,我認爲你發佈的第一個解決方案也很好。它的代碼少了幾行。 –

+0

我設法使它更加可重用和美觀。所有的「魔術」都發生在「提取」方法中;所以例如'extractOptionalFieldNames'實現只傳遞所需的參數:你自定義類型的值和作爲過濾器的多態函數('Poly' impl) –

+0

已修改,因此不需要'A'的運行時實例 –

板凳
0
2

這裏使用的一種方法類型類:

??3210

有可能需要幾件事情解釋:

  • 既然您提到您沒有運行時實例A。什麼是您想要回來的類型級別表示?在這個解決方案中,我只是返回了一個HList證人的選擇。我不認爲List[String]表示就足夠了,因爲過濾掉非可選值將具有與無所事事相同的類型。
  • 類型類有一個優先級,所以過濾選項與反向優先級相同。

它可以像這樣使用:

case class A(i: Int, j: Option[Int], k: Option[Long]) 
val x = LabelledGeneric[A] 
type filteredType = OptionExtractor[x.Repr] 
//type B = Symbol with shapeless.tag.Tagged[String("j")] :: Symbol with shapeless.tag.Tagged[String("k")] :: shapeless.HNil 
+0

乾杯,Jamborta。 (我提高了你的解決方案,但我沒有足夠的街道信譽來計算它,當我更高級時,我會回到它的位置:-) –

0
votes
answers
39 views
+10

優化數據庫操作Slick 3

0

我用Slick創建了一個數據庫。我試圖創建表格模式,選擇一些信息等等。這裏是我的架構創建代碼:優化數據庫操作Slick 3

val createUserTable = UserTable.table.schema.create 
val createTaskTable = TaskTable.table.schema.create 
Await.result(db.run(DBIO.seq(Queries.createUserTable, Queries.createTaskTable)), 2 seconds) 

此代碼工作得很好,但我不希望使用Await.result每查詢。我正在尋找的是至少按照目的(創建,選擇等)批量執行它們。我能我創造了這個方法傳遞不同的操作:

def executeAction[T](action: DBIO[T]) = 
    Await.result(db.run(action), 2 seconds) 

所以我很好奇,我能怎樣改變通過持有查詢序列的一些數據結構?例如,List(createUserTable, createTaskTable)

您的幫助表示感謝!

+1

請添加您正在使用的浮油版本。光滑2和光滑3差異很大 – pedrorijo91

+0

我編輯了這個問題。我使用Slick 3 – Cassie

沙发
0
2

兩種方法可以避免等待每一個DBIO行動

  1. 創建DBIO行動的列表,並使用DBIO.seq聚集他們和執行。

  2. 使用理解將所有DBIO動作組合成一個DBIO動作。

這將幫助您使用一次又一次地等待您的中間DBIO操作的結果。

在這兩種情況下,您都必須至少使用Await.result至少一次等待主線程中的結果(即停止主線程退出)。

+0

所以我的行''Await.result(db.run(DBIO.seq(Queries.createUserTable,Queries.createTaskTable)),2秒)''實際上可以嗎?我的意思是,我可以在這裏添加更多的動作。是對的嗎? – Cassie

+0

@Cassie是的。你是對的! – pamu

0
votes
answers
52 views
+10

Akka Streams KillSwitch在alpakka jms

1

我有一個場景,我開始使用alpakka多個jmsSource(對於不同的隊列)。我還需要在任何時候卸下隊列。所以我已經添加KillSwitch到jms阿卡流,如下所示: -Akka Streams KillSwitch在alpakka jms

trait MessageListener { 

    lazy val jmsPipeline = jmsSource 
    .map { x => log.info(s"Received message ${x} from ${queue}"); x } 
    .viaMat(KillSwitches.single)(Keep.right) 
    .toMat(Sink.foreach { x => pipelineActorRef ! PreProcessorMessage(x) }) 
    (Keep.both) 
    .run() 

    def start(): Unit = { 
      log.info("Invoking listener : {}", queue) 
      jmsPipeline 
      log.info("listener : {} started", queue) 
      } 
    def stop():Unit =  jmsPipeline._1.shutdown() 

    def queue: String 

} 

object ListenerA extends MessageListener { 
    override def queue: String = "Queue_A" 
} 

object ListenerB extends MessageListener { 
    override def queue: String = "Queue_B" 
} 

..等等。

啓動應用程序後,所有的隊列連接並正常工作。但是,當我嘗試使用停止方法分離隊列時,並非所有隊列都斷開連接並且行爲是隨機的。我還檢查了killSwitch對所有聽衆都不同。

有人可以告訴我這裏有什麼問題嗎?

沙发
0
0

您的日誌支持您連接到具有不同流的多個隊列的錯覺,但是您有多個可能連接到同一隊列的流。在這兩個監聽器對象中,記錄器都會記錄覆蓋的queue名稱,但該隊列名稱不用於配置jmsSource

您沒有顯示jmsSource的定義;顯然它是在MessageListener性狀之外的某處定義的,在這種情況下,ListenerAListenerB都使用相同的jmsSource。換言之,而ListenerAListenerB具有jmsPipeline不同實例(這就是爲什麼殺開關是不同的),這兩個jmsPipeline實例由相同jmsSource實例衍生(除非jmsSourcedef即在每次調用創建一個不同的Source ,但即使情況如此,基本問題仍然存在:queue未在配置中使用)。

在Alpakka,JMS隊列上JmsSourceSettings配置,所以jmsSource可能看起來像下面這樣:

val jmsSource: Source[String, NotUsed] = JmsSource.textSource(
    JmsSourceSettings(connectionFactory).withBufferSize(10).withQueue("MyQueue") 
)      // the queue is configured here^

ListenerA.start(),例如,被調用時,以下記錄:

Invoking listener : Queue_A 
listener : Queue_A started 

再次,在以上日誌語句中的"Queue_A"ListenerA中被重寫的def queue: String成員的值;它不一定是在jmsSource(上例中的"MyQueue")中實際配置的隊列。與ListenerB以及您在map組合器中登錄的消息一樣。

一個簡單的解決方法是把的jmsSource及其JmsSourceSettings的定義MessageListener特質內部和這些設置實際使用queue

0
votes
answers
30 views
+10

在scala中使用或不使用泛型類型創建實例有什麼不同?

0

我有一個類定義和兩個函數定義在scala中使用或不使用泛型類型創建實例有什麼不同?

class Queue[T] (
    private val leading: List[T] 
    private val trailing: List[T] 
){} 

def a[T](xs: T*) = new Queue[T](xs.toList, Nil) 

def b[T](xs: T*) = new Queue(xs.toList, Nil) 

從這裏,類與泛型類型定義,以及兩個函數的作用。

但是在這裏,兩個函數的區別在於創建實例時。

工作都很好,沒有錯誤與下面的表達式創建:

a(1,2,3,4) 
b(1,2,3,4) 

a[Int](1,2,3,4) 
b[Int](1,2,3,4) 

但是,我想不出有什麼區別。

+0

如果您爲'Queue'和'b'的類型參數選擇了不同的名稱,談論這個會容易一些。 –

沙发
0
4

沒有。類別Queue的類型參數T將被推斷爲方法b的類型參數T

0
votes
answers
30 views
+10

斯卡拉期貨和多線程

0

我是新來斯卡拉,我試圖讓期貨的手柄和多線程斯卡拉期貨和多線程

我有一個程序的版本的SingleThreaded,使得在矩陣的一些計算

SingleThreadCalc { 
    def run(matrix : Seq[Seq[Double]]) : Future[Seq[Seq[Double]] = Future{doMath(matrix)} 
} 

我現在想要的是製作一個多線程版本。 是否足夠讓一個ExecutionContext傳遞一些線程?

MultiThreadCalc { 
    def run(matrix : Seq[Seq[Double]]) : Future[Seq[Seq[Double]] = 
Future{doMath(matrix)} (ExecutionContext.fromExecutor(Executors.newFixedThreadPool(10))) 

這將共享所有線程之間的計算負載還是根本沒有發生?

+0

我會給出的簡短答案是「顯然是如此」,但我認爲最好的答案將來自運行該事物並測量。 – stefanobaghino

+0

我認爲如果要將doMath分解爲可以並行執行的任務,那麼請考慮第一步。 – jamborta

+0

@jamborta現在它是迭代矩陣的元素的兩倍 我正在考慮重構到行處理 但我可以控制哪個線程結束處理每一行? – tiefizzy

沙发
0
1

簡短的回答:第

龍答:

object MultiThreadCalc { 
def run(matrix : Seq[Seq[Double]]) : Future[Seq[Seq[Double]] = 
    Future{doMath(matrix)}(ExecutionContext.fromExecutor(Executors.newFixedThreadPool(10))) 
} 

上面會的代碼,爲run每次調用時,將分配一個新的線程池,這將永遠不會被關閉,它會用於執行單個方法doMath(因此只能使用該池中的1個線程)。

現在,如果您想並行執行doMath本身,那麼您需要將ts定義修改爲可並行化,可能通過使參數爲implicit ec: ExecutionContext並在其定義中使用該參數。

但是,如果你不是想能夠運行並行doMath許多調用那麼你就可以做到以下幾點:

object MultiThreadCalc { 
    def run(matrix : Seq[Seq[Double]])(implicit ec: ExecutionContext) : Future[Seq[Seq[Double]] = Future{doMath(matrix)} 
} 

,然後可能創建一個ExecutionContext中對「外」 ExecutionContext.fromExecutor(Executors.newFixedThreadPool(10))並使用它時,你想執行它的邏輯。

+0

我懷疑... 我會重構我的doMath,然後嘗試更改ExecutionContext,以便可以並行執行 – tiefizzy