Pour que les stratégies s'exécutent en parallèle, ajouter une prise en charge multi-threads au niveau inférieur du système pour les stratégies JavaScript.

Pour que les stratégies s'exécutent en parallèle, ajouter une prise en charge multi-threads au niveau inférieur du système pour les stratégies JavaScript.

Lorsque vous développez des stratégies sur FMZ en utilisant le langage JavaScript, la structure des stratégies est consultée.exchange.GoLes fonctions utilisées pour effectuer des appels simultanés à certaines interfaces permettent de réaliser des scénarios simultanés.threadingIl y a aussi des sites web qui sont utilisés par les blogueurs pour créer des blogs.

Sur la base de ces besoins, la plateforme FMZ a mis à niveau la base du système.

• Créer des threads en même temps pour exécuter des fonctions personnalisées
• La communication entre les fils.
• Les variables stockées entre les threads sont partagées.
• Attendez que le fil d'exécution termine les ressources récupérées et renvoyez le résultat de l'exécution.
• Les réseaux sociaux ont été détruits, les réseaux sociaux ont été détruits, les réseaux sociaux ont été détruits, les réseaux sociaux ont été détruits.
• Obtenir l'ID du fil en cours dans une fonction d'exécution de fil en parallèle.

Les articles suivants vous aideront à comprendre chacune de ces fonctions.

Créer des fonctionnalités personnalisées en même temps que des fils

fonction 1 (sommeil) { la somme de variation est égale à 0 pour (var i = 0 ; i < 10 ; i++) { somme += i Le sommeil (le sommeil) Log ((sum:, somme) Je ne sais pas.

return sum

}

fonction main (() { // Utilisez la fonction__Thread pour créer simultanément un fil avec le paramètre 200 de la fonction func1 // Si la fonction func1 a plusieurs paramètres, voici le paramètre correspondant spécifique var thread1Id = __Thread ((func1, 200) est le nombre de fils

// 这里需要等待线程Id为thread1Id的线程执行结果，否则main函数执行完就直接释放所有线程
var ret = __threadJoin(thread1Id)
Log("ret:", ret)

}

实际应用场景中，我们可以这样并发进行http请求：

fonction principale laissez les fils = [ https://www.baidu.com”, “https://www.163.com”].carte fonction url retourLe fil de l'action Log ((GET, url) retourner HttpQuery (URL) {, url) Je ne sais pas. Pour chaque fonction, Le journalJe ne peux pas vous aider. Je ne sais pas. Je ne sais pas.

### 等待线程执行结束回收资源并返回执行结果

以上例子中我们在main函数中最后使用了```__threadJoin```函数来等待并发的线程执行完毕，变量```ret```接收```__threadJoin```函数的返回值，我们打印了这个返回值，可以观察这个并发的线程执行的具体结果。

// id: ID du thread, terminated: si elle est forcée d'arrêter, elapsed: temps écoulé ((na secondes), ret: la valeur de retour de la fonction d'exécution du thread Ret: {id:1,terminated:false,elapsed:2004884301,ret:45}

### 强制结束线程，并回收资源

fonction 1 (sommeil) { la somme de variation est égale à 0 pour (var i = 0 ; i < 10 ; i++) { somme += i Le sommeil (le sommeil) Log ((sum:, somme) Je ne sais pas.

return sum

}

fonction principale le nombre de fois où le fichier est modifié. Le sommeil ((1000) RetreadTerminate = __threadTerminate ((thread1Id) Log ((retThreadTerminate) // vrai Je ne sais pas.

还是以刚才的例子，在创建线程后，可以在等待1秒之后就强制终止线程执行。

### 线程间通信

线程间通信主要使用```__threadPostMessage```函数和```__threadPeekMessage```函数。我们来看以下简单例子：

fonction 1 (() { Var id = __threadId ()) pendant (true) { var post Msg = le message de la barre de référencement de la fonction func1 du fil de chaîne de référencement: __threadPostMessage ((0, postMsg) // envoie un message au fil de thread principal var peekMsg = __threadPeekMessage() // recevoir des messages provenant d'autres fils Log ((peekMsg) est un fichier Sleep (en anglais seulement) Je ne sais pas. Je ne sais pas.

fonction principale Var threadId = __Thread(func1)

while (true) {
    var postMsg = "来自主线程的main函数的消息"
    __threadPostMessage(threadId, postMsg)
    var peekMsg = __threadPeekMessage()
    Log(peekMsg, "#FF0000")                     // #FF0000 ， 设置日志为红色用于区分
    Sleep(5000)
}

}

```__threadPostMessage```函数用于向某个线程发送消息，第一个参数是具体发送到哪个线程的ID，第二个参数是发送的消息，可以是字符串、数值、数组、JSON对象等。可以在并发的线程函数中向主线程发送消息，主线程的ID定义为0。

```__threadPeekMessage```函数用于监听某个线程发送来的消息, 可以设置超时时间（毫秒数），也可以设置为0表示阻塞，一直监听到有消息才返回。

当然，除了并发的线程和主线程通信。并发的线程之间也可以直接相互通信。

### 在并发的线程执行函数中获取当前线程ID

在上面的例子中，使用了```var id = __threadId()```，```__threadId()```函数可以获取当前线程的ID。

### 共享线程间储存的变量

除了线程间的通信，还可以使用共享变量进行交互。

fonction testFunc (() { __threadSetData ((0, testFunc, 100) // Stocke l'environnement du thread actuel avec une valeur de clé pour testFunc: 100 Log ((testFunc exécuté par la barre de finition) Je ne sais pas.

fonction main (() { // threadId est 1, le threadId créé est exécuté en premier, et les variables stockées localement sont valides tant que les ressources du thread n'ont pas été récupérées Var testThread = __Thread (testFunc) est un thème de test qui a été testé par un autre thème.

Sleep(1000)

// 输出 in main, get testFunc: 100
Log("in main, get testFunc:", __threadGetData(testThread, "testFunc"))   // 取出键名为testFunc的值

} “`

C'est une simple démonstration de toutes les fonctionnalités.