문법 안내

리소스 로딩... 로딩...

가닥

FMZ 퀀트 트레이딩 플랫폼은 실제로JavaScript언어 전략은 시스템 밑바닥에서 시작하여 다음과 같은 목표를 구현합니다.

물체	방향	언급
스레딩	멀티 스레드 글로벌 오브젝트	위원들의 역할:`Thread`, `getThread`, `mainThread`, 등등
스라인	스레드 객체	위원들의 역할:`peekMessage`, `postMessage`, `join`, 등등
스레드 잠금	스레드 잠금 객체	위원들의 역할:`acquire`, `release`그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다.
스레드 이벤트	이벤트 객체	위원들의 역할:`set`, `clear`, `wait`, `isSet`그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다.
스레드 조건	조건 객체	위원들의 역할:`notify`, `notifyAll`, `wait`, `acquire`, `release`그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다.
ThreadDict	사전 객체	위원들의 역할:`get`, `set`그들은 스레드 실행 함수의 매개 변수로 스레드 환경에 전달될 수 있습니다.

스레딩

이threadingobject는 동시 스레드, 스레드 잠금 및 조건 객체를 생성하는 등의 기능을 제공하는 글로벌 멀티 스레드 관리 도구입니다. 이 섹션에서는 스레드 관리의 구성원 기능을 소개합니다.threading이 객체는JavaScript언어 전략

스라인

이Thread()함수는 동시 스레드를 생성하는 데 사용됩니다.

이Thread()함수는 a를 반환합니다Thread생성된 동시 스레드, 스레드 통신 등을 관리하는 데 사용되는 객체

Thread물체

Thread ((func,...args) 스레드 (... 항목)

매개 변수func동시에 실행되는 함수입니다 (리퍼런스에 의해 전달됩니다) 그리고 익명의 함수를 전달하는 것을 지원합니다.func여러 매개 변수를 받아들일 수 있습니다....args동시 실행 중입니다. 따라서,func이 모든 것이...args.

함수 사실 기능 매개 변수arg실제 매개 변수가func(즉 동시 스레드 실행 함수) 콜백이 실행될 때, 여러 매개 변수가 있을 수 있습니다.arg, 그리고 매개 변수 목록func이 모든 것이...args.

아그 거짓 문자열, 숫자, bool, 객체, 배열, 함수, null 값 및 시스템에서 지원되는 다른 유형 매개 변수item함수 참조와 동시에 실행되는 그들의 매개 변수를 포함하는 배열입니다.item매개 변수를 호출 할 때 전달 할 수 있습니다Thread function.

항목 사실 배열

function test1(a, b, c) {
    Log("test1:", a, b, c)
}

function main() {
    var t1 = threading.Thread(test1, 1, 2, 3)
    var t2 = threading.Thread(function (msg) {
        Log("msg:", msg)
    }, "Hello thread2")

    t1.join()
    t2.join()
}

사용자 지정 함수와 익명 함수 모두에 동시 스레드를 생성합니다.

function test1(msg) {
    Log("msg:", msg)
    test2("Hello test2")
}

function main() {
    var t1 = threading.Thread(
        [function(a, b, c) {Log(a, b, c)}, 1, 2, 3], 
        [test1, "Hello test1"], 
        [`function test2(msg) {Log("msg:", msg)}`])

    t1.join()
}

사용Thread(...items)동시에 스레드를 만들고 여러 기능을 연속적으로 실행하는 형태입니다.

function testFunc1(p) {
    Log("testFunc1 p:", p)
}

function main() {
    threading.Thread(function(pfn) {
        var threadName = threading.currentThread().name()
        var threadId = threading.currentThread().id()
        pfn(`in thread threadName: ${threadName}, threadId: ${threadId}`)
    }, testFunc1).join()
}

동시에 실행되는 함수들에 매개 변수를 전달하는 것을 지원합니다.

function ml(input) {
    const net = new brain.NeuralNetwork()
    net.train([
        { input: [0, 0], output: [0] },
        { input: [0, 1], output: [1] },
        { input: [1, 0], output: [1] },
        { input: [1, 1], output: [0] },
    ])
    return net.run(input)
}

function main() {
    var ret = threading.Thread([ml, [1, 0]], [HttpQuery("https://unpkg.com/brain.js")]).join()

    // ret: {"id":1,"terminated":false,"elapsed":337636000,"ret":{"0":0.9339330196380615}}
    Log(ret)
}

함수 문자열을 전달하는 것을 지원하고 동시 컴퓨팅을 위해 외부 라이브러리를 동적으로 가져올 수 있습니다.

스레드 함수func이산화탄소Thread()동시 실행을 위한 함수는 격리된 환경에서 실행되므로 스레드 외부의 변수는 직접 참조할 수 없으며, 스레드 내에서 다른 클로저 함수에 대한 참조가 지원되지 않습니다. 플랫폼에서 제공하는 모든 API는 스레드 내에서 호출 될 수 있지만 다른 사용자 정의 함수는 호출 될 수 없습니다.

백테스팅 시스템 및 라이브 거래 환경을 지원합니다. 모든 동시 스레드 관련 기능은 백테스팅 시스템에서 코드 호환성으로만 지원되며 실제로 동시 스레드에서 실행되지 않으므로이 장에서 반복되지 않습니다.

{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}

getThread

이getThread()함수는 지정된 스레드 ID를 기반으로 스레드 객체를 얻기 위해 사용됩니다.

이getThread()함수는Thread매개 변수에 의해 지정된 스레드Id를 가진 객체

Thread물체

getThread (threadId) 를 입력합니다.

매개 변수threadId스레드 객체 ID입니다. 파라미터를 지정하여 해당 스레드 객체를 얻습니다.

스레드 사실 번호

function main() {
    var t1 = threading.Thread(function () {
        Log("Hello thread1")
    })
    // The Thread object has a method: id(), which is used to get the thread ID. You can view the section of the document corresponding to the Thread object.
    var threadId = t1.id()
    var threadName = t1.name()
    Log("threadId:", threadId, ", threadName:", threadName)
    
    var t2 = threading.getThread(threadId)
    Log(`threadId == t2.id():`, threadId == t2.id(), `, threadName == t2.name():`, threadName == t2.name())
}

지정된 스레드 객체를 통해threadId.

백테스팅 시스템과 라이브 거래 환경을 지원합니다.

만약 당신이 얻고 싶은 스레드가 실행되고 풀려났다면, 당신은 사용할 수 없습니다threading.getThread(threadId)가닥의 가닥 대상을 얻으려면

{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/Dict Dict}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/threading/Lock Lock}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}

메인 스레드

이mainThread()이 함수는 주 가닥의 가닥 객체를 얻기 위해 사용됩니다.main()전략의 기능이 위치합니다.

이mainThread()이 함수는 메인 스레드의 스레드 객체를 반환합니다.

Thread물체

mainThread()

function main() {
    Log("The threadId of the main thread:", threading.mainThread().id())
}

가져와Thread주요 스레드의 대상과 출력threadId주요 스레드입니다.

function test() {
    Log("Output the main thread ID in the test function:", threading.mainThread().id())
}

function main() {
    var t1 = threading.Thread(test)
    t1.join()
}

주요 스레드의 스레드 객체는 동시 스레드에서도 얻을 수 있습니다.

백테스팅 시스템과 라이브 거래 환경을 지원합니다.

{@fun/Threads/getThread getThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/threading/Lock Lock}, {@fun/Threads/threading/eventLoop}

현재 스레드

이currentThread()함수는 현재 스레드의 스레드 객체를 얻기 위해 사용됩니다.

이currentThread()함수는 현재 스레드의 스레드 객체를 반환합니다.

Thread물체

현재 스레드 ((()

function test() {
    Log("Id of the current thread:", threading.currentThread().id())
}

function main() {
    var t1 = threading.Thread(test)
    t1.join()
}

가져와Thread전류 스레드의 객체와 출력threadId현재 스레드.

백테스팅 시스템과 라이브 거래 환경을 지원합니다.

{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/event Loop}, {@fun/Threads/threads/threading/mainThread mainThread}, {@fun/Threads/threads/threading/threading/threading/thread Thread Lock}, {@fun/Threads/threads/threading/lock Lock}, {@fun/Threads/threading/eventLoop eventLoop}, {@fun/Threads/threads/eventLoop}

잠금

이Lock()이 함수는 스레드 잠금 객체를 생성하는 데 사용됩니다.

이Lock()함수는 스레드 잠금 객체를 반환합니다.

ThreadLock물체

잠금 (()

function consumer(productionQuantity, dict, lock) {
    for (var i = 0; i < productionQuantity; i++) {
        lock.acquire()
        var count = dict.get("count")        
        Log("consumer:", count)
        Sleep(1000)
        lock.release()
    }
}

function producer(productionQuantity, dict, lock) {
    for (var i = 0; i < productionQuantity; i++) {
        lock.acquire()
        dict.set("count", i)
        Log("producer:", i)
        Sleep(1000)
        lock.release()
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("count", -1)
    var lock = threading.Lock()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, lock)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, lock)

    consumerThread.join()
    producerThread.join()
}

두 개의 동시 스레드가 공통 리소스에 접속합니다.

백테스팅 시스템과 라이브 거래 환경을 지원합니다.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threads/threading/Thread Thread}, {@fun/Threads/threads/threading/condition Condition}, {@fun/Threads/threads/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threads/threading/pending pending}, {@fun/Threads/threads/threading/threading/eventLoop}, {@fun/Threads/threads/threads/eventLoop}

조건

이Condition()함수는 조건 변수 객체를 생성하는 데 사용되며, 이는 다중 스레드 동시 환경에서 스레드 간의 동기화 및 통신을 달성하는 데 사용됩니다.Condition(), 특정 조건이 충족되지 않을 때 다른 스레드가 조건이 충족되었다는 것을 알릴 때까지 스레드가 기다릴 수 있습니다.

이Condition()함수는 a를 반환합니다ThreadCondition object.

ThreadCondition물체

상태 (()

function consumer(productionQuantity, dict, condition) {
    for (var i = 0; i < productionQuantity; i++) {
        condition.acquire()
        while (dict.get("array").length == 0) {
            condition.wait()
        }
        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        condition.release()
        Sleep(1000)
    }
}

function producer(productionQuantity, dict, condition) {
    for (var i = 0; i < productionQuantity; i++) {
        condition.acquire()
        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)
        condition.notify()
        condition.release()
        Sleep(1000)
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("array", [])
    var condition = threading.Condition()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, condition)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, condition)
    consumerThread.join()
    producerThread.join()
}

두 개의 동시 스레드가 공통 리소스에 접속합니다.

백테스팅 시스템은 이 기능을 구현하지 않고 정의만 합니다.

{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/threading/eventLoop}

이벤트

이Event()함수를 생성하는 데 사용됩니다스레드 이벤트스레드 간의 동기화를 위해 사용되는 객체, 하나의 스레드가 다른 스레드로부터의 알림이나 신호를 기다리는 것을 허용합니다.

이Event()함수는 a를 반환합니다ThreadEvent object.

ThreadEvent물체

이벤트

function consumer(productionQuantity, dict, pEvent, cEvent) {
    for (var i = 0; i < productionQuantity; i++) {
        while (dict.get("array").length == 0) {
            pEvent.wait()
        }
        if (pEvent.isSet()) {
            pEvent.clear()
        }

        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        cEvent.set()
        Sleep(1000)
    }
}

function producer(productionQuantity, dict, pEvent, cEvent) {
    for (var i = 0; i < productionQuantity; i++) {
        while (dict.get("array").length != 0) {
            cEvent.wait()
        }
        if (cEvent.isSet()) {
            cEvent.clear()
        }

        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)        
        pEvent.set()       
        Sleep(1000)
    }
}

function main() {    
    var dict = threading.Dict()
    dict.set("array", [])
    var pEvent = threading.Event()
    var cEvent = threading.Event()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, pEvent, cEvent)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, pEvent, cEvent)

    consumerThread.join()
    producerThread.join()
}

두 개의 동시 스레드가 공통 리소스에 접속합니다.

백테스팅 시스템과 라이브 거래 환경을 지원합니다.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/condition Condition}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/threading/eventLoop eventop},

독서

이Dict()함수는 동시 스레드에 전달하기 위해 사전 객체를 생성하는 데 사용됩니다.

이Dict()함수는 a를 반환합니다ThreadDict object.

ThreadDict물체

딕트 (Dict)

function threadFun1(obj) {
    obj["age"] = 100
    while (true) {
        Log("threadFun1 obj:", obj)
        Sleep(5000)
    }
}

function threadFun2(obj) {
    while (true) {
        Log("threadFun2 obj:", obj)
        Sleep(5000)
    }
}

function main() {
    var obj = {"age": 10}
    var t1 = threading.Thread(threadFun1, obj)
    var t2 = threading.Thread(threadFun2, obj)
    t1.join()
    t2.join()    
}

일반 객체를 동시 스레드 실행 함수로 전달하여 객체의 키 값을 수정하면 다른 스레드에서 객체의 키 값을 변경하는지 테스트합니다.

function threadFun1(threadDict) {
    threadDict.set("age", 100)
    while (true) {
        Log(`threadFun1 threadDict.get("age"):`, threadDict.get("age"))
        Sleep(5000)
    }
}

function threadFun2(threadDict) {
    while (true) {
        Log(`threadFun2 threadDict.get("age"):`, threadDict.get("age"))
        Sleep(5000)
    }
}

function main() {
    var threadDict = threading.Dict()
    threadDict.set("age", 10)
    var t1 = threading.Thread(threadFun1, threadDict)
    var t2 = threading.Thread(threadFun2, threadDict)

    t1.join()
    t2.join()    
}

놔줘ThreadDict이 객체에 의해 만들어진Dict()동시 스레드 실행 함수와 함수를 연결하고, 객체의 키 값을 수정하면 다른 스레드에서 객체의 키 값을 변경할 수 있는지 테스트합니다.

공통 객체가 동시 스레드 함수로 전달되면, 그것은 딥 코피로 전달됩니다. 동시 스레드에서 키 값을 수정하면 다른 스레드의 사전에 영향을 미치지 않습니다.

백테스팅 시스템과 라이브 거래 환경을 지원합니다.

{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop}

미뤄지고 있습니다

이pending함수는 현재 전략 프로그램에서 실행되는 동시 스레드의 수를 얻기 위해 사용됩니다.

이pending()이 함수는 현재 전략 프로그램이 실행 중인 동시 스레드의 수를 반환합니다.

번호

미뤄지고 있습니다.

function threadFun1() {
    Log("threadFun1")
    Sleep(3000)
}

function threadFun2() {
    for (var i = 0; i < 3; i++) {
        LogStatus(_D(), "print from threadFun2")
        Sleep(3000)
    }
}

function main() {
    Log(`begin -- threading.pending():`, threading.pending())

    var t1 = threading.Thread(threadFun1)
    var t2 = threading.Thread(threadFun2)
    Log(`after threading.Thread -- threading.pending():`, threading.pending())

    t1.join()
    t2.join()
    Log(`after thread.join -- threading.pending():`, threading.pending())
}

동시에 실행되는 두 개의 스레드를 만들고pending()서로 다른 시간 노드에서 작동합니다.

이 전략이main()함수가 실행되기 시작하면 함수를 호출합니다pending()바로 1을 반환합니다. 왜냐하면 전략이 있는 주요 스레드이기 때문입니다.main()함수가 위치하는 것은 또한 대기 스레드입니다.

백테스팅 시스템과 라이브 거래 환경을 지원합니다.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/eventLoop}

스라인

Thread객체를 생성하거나 반환할 수 있습니다threading.Thread(), threading.getThread(), threading.mainThread(), 그리고threading.currentThread().

peek메세지

이peekMessage()함수는 스레드에서 메시지를 얻기 위해 사용됩니다.

이peekMessage()function는 현재 스레드 객체와 연관된 스레드에 의해 수신된 메시지를 반환합니다.

문자열, 숫자, bool, 객체, 배열, null 값 및 시스템에서 지원되는 다른 유형

peekMessage() peekMessage (시간 정지)

매개 변수timeouttimeout 설정입니다. 매개 변수에서 설정한 밀리초 수를 차단하고 대기하여 데이터를 반환합니다. 데이터가 없으면 타임아웃이 한계를 초과하면 null 값이 반환됩니다.timeout0으로 설정되거나timeout매개 변수가 전달되지 않는 경우, 그것은 프로세스가 차단하고 채널에서 데이터가 수신 될 때까지 기다린다는 것을 의미합니다.timeout-1로 설정되면 프로세스가 즉시 데이터를 차단하고 반환하지 않는다는 것을 의미합니다. 데이터가 없으면 null 값이 반환됩니다.

타임아웃 거짓 번호

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })

    while (true) {
        var msg = threading.currentThread().peekMessage()
        Log("main peekMessage():", msg)
        if (msg == 9) {
            break
        }
        Sleep(1000)
    }

    t1.join()
}

동시 스레드에서 메인 스레드에 메시지를 보내십시오.

프로그램을 작성할 때 스레드 막상 문제들에 주목해야 합니다.

{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/thread/join name}, {@Threads/Threads/eventLoop eventLoop}

포스트메세지

이postMessage()함수는 스레드에 메시지를 보내는데 사용됩니다.

postMessage ((msg)

매개 변수msg이 메시지가 전달되어야 합니다.

msg 사실 문자열, 숫자, bool, 객체, 배열, 함수, null 값 등과 같은 시스템에서 지원되는 모든 유형

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })
    for (var i = 0; i < 10; i++) {
        var event = threading.mainThread().eventLoop()
        Log("main event:", event)
        Sleep(500)
    }
    t1.join()
}

동시 스레드에서 메시지를 전송하고 사용eventLoop()메시지의 알림을 수신하기 위해

function main() {
    threading.mainThread().postMessage(function(msg) {
        Log("func from mainThread, msg:", msg)
    })
    
    threading.Thread(function() {
        var func = threading.mainThread().peekMessage()
        func("in " + threading.currentThread().name())
    }).join()
}

함수 전송을 지원합니다.

스레드의 실행 함수가postMessage()신호나 데이터를 보내기 위한 기능, 메시지 이벤트도 생성됩니다.eventLoop()메시지 알림을 수신하는 기능.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Threads/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

합시다

이join()이 함수는 스레드가 종료되고 시스템 리소스를 검색할 때까지 기다리기 위해 사용됩니다.

이ThreadRet물체실행 결과에 대한 데이터를 포함합니다. 속성은 다음을 포함합니다:

id: 스레드 ID
종료: 스레드가 종료될 수 있는지 여부.
elapsed: 나노초로 나선의 실행시간.
ret: 스레드 함수의 반환 값.

ThreadRet물체

합시다. join (타임오웃)

이timeout패러미터는 스레드가 끝날 때까지 기다리는 밀리 초에 타임아웃을 설정하는 데 사용됩니다.timeout매개 변수가 0으로 설정되거나timeout매개 변수가 설정되지 않은 경우,join()이 함수는 스레드가 실행을 마칠 때까지 기다립니다.timeout매개 변수가 -1로 설정되면,join()기능이 즉시 회복됩니다.

타임아웃 거짓 번호

function main() {
    var t1 = threading.Thread(function() {
        Log("Hello thread1")
        Sleep(5000)
    })

    var ret = t1.join(1000)
    Log("ret:", ret)   // ret: undefined

    ret = t1.join()
    Log("ret:", ret)   // ret: {"id":1,"terminated":false,"elapsed":5003252000}
}

테스트join()타임아웃 함수와 반환 값을 출력합니다.

이join()함수 출구 및 반환 시간undefined.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

종료

이terminate()이 함수는 스레드를 강제로 종료하고 생성된 스레드가 사용하는 하드웨어 자원을 풀어주는 데 사용됩니다.

종료 (()

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 i:", i)
            Sleep(1000)
        }
    })

    Sleep(3000)
    t1.terminate()
    Log("after t1.terminate()")

    while (true) {
        LogStatus(_D())
        Sleep(1000)
    }
}

스레드의 실행을 강제로 종료합니다. 스레드를 강제로 종료한 후에는 이 스레드의 출력이 로그에 없을 것입니다.

가닥에 의해 강제로 종료되는 가닥에 대한terminate()기능, 우리는 더 이상 사용할 수 없습니다join()그 기능이 종료될 때까지 기다립니다.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

getData

이getData()이 함수는 스레드 환경에서 기록된 변수에 액세스하는 데 사용됩니다. 스레드가 스레드를 실행하지 않았을 때 데이터가 유효합니다.join()기능 (출출 성공을 기다리고) 를 실행하지 않았습니다terminate()함수 (강력으로 스레드를 끝내는 것)

이getData()함수는key현재 스레드 컨텍스트에 저장된 키-값 쌍의 매개 변수

문자열, 숫자, bool, 객체, 배열, null 값 및 시스템에서 지원되는 다른 유형

getData (데이터) getData (키)

이key매개 변수는 저장된 키값 쌍의 키 이름입니다.

키 사실 문자열

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 5; i++) {
            threading.currentThread().setData("count", i)
            Log(`setData("count"):`, i)
            Sleep(1000)
        }
    })
    for (var i = 0; i < 5; i++) {
        var count = threading.getThread(t1.id()).getData("count")
        Log(`getData("count"):`, count)
        Sleep(1000)
    }
    t1.join()
}

키의 값을 기록합니다count동시 스레드 환경에서, 그리고 그 다음 키 값을 읽습니다count주요 내용입니다.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

setData

이setData()함수는 스레드 컨텍스트의 변수를 저장하는 데 사용됩니다.

setData (키, 값)

이key매개 변수는 저장된 키-값 쌍의 키 이름을 지정하는 데 사용됩니다.

키 사실 문자열 의value매개 변수는 저장된 키와 값 쌍의 키 값을 지정하는 데 사용됩니다.

가치 사실 문자열, 숫자, bool, 객체, 배열, 함수, null 값 등과 같은 시스템에서 지원되는 모든 유형

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Sleep(1000)
    Log(`t1.getData("data"):`, t1.getData("data"))
    t1.join()
}

동시 스레드에서 키-값 쌍을 설정하고 메인 스레드에서 키-값 쌍을 읽습니다.

function main() {
    threading.mainThread().setData("func2", function(p) {
        Log("func2 p:", p)
    })
    
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("func1", function(p) {
            Log("func1 p:", p)
        })
    
        var func2 = threading.mainThread().getData("func2")
        func2("test2")
    })
    
    Sleep(1000)
    var func1 = t1.getData("func1")
    func1("test1")
    t1.join()
}

키값을 함수로 전달하는 것을 지원합니다.

스레드가 실행되지 않은 경우 데이터가 유효합니다.join()기능 (출출 성공을 기다리고) 를 실행하지 않았습니다terminate()함수 (강제로 스레드를 종료). 매개 변수의 값value일련화 가능한 변수여야 합니다.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

id

이id()함수를 반환하는 데 사용됩니다threadId현재 멀티 스레드 객체 인스턴스

이 값의 반환 값은id()함수는threadId.

번호

id()

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.id():`, t1.id())
    t1.join()
}

동시 실행 스레드를 만들고 출력threadId이 동행 스레드의 주 스레드.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData set}, {@fun/Threads/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

이름

이name()이 함수는 현재 멀티 스레드 객체 인스턴스의 이름을 반환하는 데 사용됩니다.

이name()함수는 동시 스레드 이름을 반환합니다.

문자열

이름 (()

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.name():`, t1.name())  // t1.name(): Thread-1
    t1.join()
}

동시 스레드를 만들고 메인 스레드에서 동시 스레드의 이름을 출력합니다.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/thread/eventLoop eventLoop}

이벤트 루프

이eventLoop()이 함수는 스레드에서 수신되는 이벤트를 듣기 위해 사용됩니다.

이eventLoop()함수는 현재 스레드에 의해 수신된 이벤트 정보를 반환합니다. 참조이벤트 정보 구조.

객체, null 값

이벤트 루프 (eventLoop) 이벤트 루프 (타임아웃)

매개 변수timeout이 매개 변수에서timeout0으로 설정되면, 반환하기 전에 이벤트가 발생하기를 기다립니다. 0보다 크다면, 이벤트 대기 타임 아웃을 설정합니다. 0보다 작다면, 가장 최근의 이벤트를 즉시 반환합니다.

타임아웃 거짓 번호

function main() {
    var t1 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop()     // Blocking wait
            // 2024-11-14 10:14:18 thread1 eventMsg: {"Seq":1,"Event":"thread","ThreadId":0,"Index":1,"Queue":0,"Nano":1731550458699947000}
            Log(_D(), "thread1 eventMsg:", eventMsg)
        }
    })

    var t2 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(-1)   // Return immediately
            Log(_D(), "thread2 eventMsg:", eventMsg)
            Sleep(5000)
        }
    })

    var t3 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(3000) // Set a 3 second timeout
            Log(_D(), "thread3 eventMsg:", eventMsg)
        }
    })

    t1.postMessage("Hello ", t1.name())
    t2.postMessage("Hello ", t2.name())
    t3.postMessage("Hello ", t3.name())
    t1.join()
    t2.join()
    t3.join()
}

동시에 세 개의 스레드를 실행하고 수신된 이벤트 정보를 출력합니다. 타임 아웃이 발생하거나 함수가 즉시 반환되면 출력 값은 null입니다.

그 처리 메커니즘은eventLoop()함수는 전체 함수와 같습니다EventLoop().

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name},

스레드 잠금

스레드 잠금 객체, 멀티 스레드 동기화 처리용

획득

이acquire()함수는 스레드 잠금 (lock) 을 요청하는 데 사용됩니다.

취득 (()

참고:threading.Lock()예제 섹션.

이acquire()스레드 로크를 요청하는 기능입니다. 스레드가 스레드 로크를 호출할 때acquire()스레드 잠금 객체의 함수, 그것은 잠금을 획득하려고합니다. 만약 잠금이 현재 다른 스레드에 의해 유지되지 않는다면, 호출 스레드는 잠금을 성공적으로 획득하고 실행을 계속합니다. 만약 잠금이 이미 다른 스레드에 의해 유지된다면, 스레드 호출acquire()잠금 장치가 풀리기 전까지 잠금됩니다.

{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/release release}

방출

이release()함수는 스레드 잠금 (불 잠금) 을 풀기 위해 사용됩니다.

방출

function consumer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        pLock.acquire()
        cLock.acquire()
        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        cLock.release()
        Sleep(1000)
        pLock.release()
    }
}

function producer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        cLock.acquire()   // cLock.acquire() placed after pLock.acquire() will not cause deadlock
        pLock.acquire()   
        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)
        pLock.release()
        Sleep(1000)
        cLock.release()
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("array", [])
    var pLock = threading.Lock()
    var cLock = threading.Lock()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, pLock, cLock)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, pLock, cLock)

    consumerThread.join()
    producerThread.join()
}

정착 시나리오 테스트

유선 잠금 장치 를 부적절 히 사용 하는 것 이 교착 상태 로 이어질 수 있다는 점 에 유의 해야 합니다.

{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/acquire acquire}

스레드 이벤트

이벤트 객체, 멀티 스레드 이벤트 알림 및 신호를 위해 사용.

세트

이set()이 함수는 이벤트를 알리기 위해 사용된다 (시트 신호).

세트 (()

참고:threading.Event()예제 섹션.

신호가set()다시 설정할 수 없습니다. 우리는 신호를 제거하고 다시 설정해야합니다.

{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

맑다

이clear()신호를 제거하는 기능입니다.

맑습니다.

참고:threading.Event()예제 섹션.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

잠깐만

이wait()함수는 이벤트 (신호) 대기 설정에 사용되며 이벤트 (신호) 설정 전에 차단됩니다. 타임 아웃 매개 변수를 설정하는 것을 지원합니다.

이wait()timeout가 발생했는지 여부를 반환합니다. 만약 그렇다면 true값을 반환합니다.

bool

잠깐만 기다려 (타임오웃)

이timeout이 매개 변수는 대기 시간을 밀리 초로 설정하는 데 사용됩니다.

타임아웃 거짓 번호

function main() {
    var event = threading.Event()
    var t1 = threading.Thread(function(event) {
        var ret = event.wait(100)
        Log(`event.wait(100):`, ret)
        ret = event.wait()
        Log(`event.wait():`, ret)
    }, event)

    Sleep(1000)
    event.set()
    t1.join()
}

이 값의 반환 값을 테스트wait() function.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}

isSet

이isSet()함수는 이벤트 (신호) 가 설정되었는지 여부를 결정하는 데 사용됩니다.

이isSet()함수는 이벤트 (신호) 가 설정되었는지 여부를 반환합니다. 이벤트 (신호) 가 설정되어 있다면 true 값을 반환합니다.

bool

isSet ((()

참고:threading.Event()예제 섹션.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}

스레드 조건

조건 객체, 멀티 스레드 동기화를 위해 사용된다.

통보

이notify()이 함수는 대기 스레드를 깨우기 위해 사용 됩니다.wait()이 방법은 깨어나게 될 것입니다.

통지합니다

function consumer(dict, condition) {
    while (true) {
        condition.acquire()
        while (dict.get("array").length == 0) {
            Log(threading.currentThread().name(), "wait()...", ", array:", dict.get("array"))
            condition.wait()
        }
        var arr = dict.get("array")
        var num = arr.shift()
        Log(threading.currentThread().name(), ", num:", num, ", array:", arr, "#FF0000")
        dict.set("array", arr)
        Sleep(1000)
        condition.release()
    }
}

function main() {
    var condition = threading.Condition()
    var dict = threading.Dict()
    dict.set("array", [])
    var t1 = threading.Thread(consumer, dict, condition)
    var t2 = threading.Thread(consumer, dict, condition)
    var t3 = threading.Thread(consumer, dict, condition)
    Sleep(1000)
    var i = 0
    while (true) {
        condition.acquire()
        var msg = ""
        var arr = dict.get("array")
        var randomNum = Math.floor(Math.random() * 5) + 1
        if (arr.length >= 3) {
            condition.notifyAll()
            msg = "notifyAll"
        } else {
            arr.push(i)
            dict.set("array", arr)
            if (randomNum > 3 && arr.length > 0) {
                condition.notify()
                msg = "notify"
            } else {
                msg = "pass"
            }
            i++
        }

        Log(_D(), "randomNum:", randomNum, ", array:", arr, ", msg:", msg)
        condition.release()
        Sleep(1000)
    }
}

사용notify()기다린 스레드를 깨우기 위한 기능입니다.

이notify()이 함수는 대기열의 스레드를 깨우게 합니다.

그 때notify()이 함수가 스레드를 깨우면 스레드는 스레드 잠금 장치를 다시 얻습니다.

{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

모든 사람에게 알려주세요.

이notifyAll()이 함수는 대기 중인 모든 스레드를 깨웁니다.

모든 것을 알려주세요.

참고:ThreadCondition.notify()예제 섹션.

이notifyAll()이 함수는 대기 중인 모든 스레드를 하나씩 깨우고, 깨진 스레드는 스레드 잠금을 다시 얻습니다.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

잠깐만

이wait()특정 설계 조건에서 스레드를 기다리게 하는 기능입니다.

잠깐만

참고:ThreadCondition.notify()예제 섹션.

이wait()기능은 스레드 잠금을 풀고 깨어나면 스레드 잠금을 다시 얻습니다.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

획득

이acquire()함수는 스레드 잠금 (lock) 을 요청하는 데 사용됩니다.

취득 (()

참고:ThreadCondition.notify()예제 섹션.

사용 전에wait(), 당신은 현재 상태 객체의 스레드 잠금 (lock) 를 요청해야 합니다.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}

방출

이release()함수는 스레드 잠금 (불 잠금) 을 풀기 위해 사용됩니다.

방출

참고:ThreadCondition.notify()예제 섹션.

사용 후wait(), 우리는 현재 조건 객체의 스레드 잠금 (불 잠금) 를 풀어야 합니다.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}

ThreadDict

데이터 공유에 사용되는 사전 객체

들어와

이get()함수는 사전 객체에 기록된 키 값을 얻기 위해 사용됩니다.

이get()함수는 키의 값을 반환key parameter.

문자열, 숫자, bool, 객체, 배열, null 값 및 시스템에서 지원되는 다른 유형

get (키)

이key이 매개 변수는 얻을 수 있는 키에 해당하는 키 이름을 지정하는 데 사용됩니다.

키 사실 문자열

function main() {
    var event = threading.Event()
    var dict = threading.Dict()
    dict.set("data", 100)
    
    var t1 = threading.Thread(function(dict, event) {
        Log(`thread1, dict.get("data"):`, dict.get("data"))
        
        event.set()
        event.clear()
        
        event.wait()
        Log(`after main change data, thread1 dict.get("data"):`, dict.get("data"))
    
        dict.set("data", 0)
    }, dict, event)
    
    event.wait()
    
    dict.set("data", 99)
    
    event.set()
    event.clear()
    
    t1.join()
    Log(`main thread, dict.get("data"):`, dict.get("data"))
}

이벤트 객체를 사용하여 스레드를 데이터 읽기 및 수정에 알립니다.

{@fun/Threads/ThreadDict/set set}

세트

이set()이 함수는 키와 값의 쌍을 설정하는 데 사용됩니다.

set (키, 값)

매개 변수key변경해야 하는 키 이름을 설정하는 데 사용됩니다.

키 사실 문자열 매개 변수value변경해야 하는 키 값을 설정하는 데 사용됩니다.

가치 사실 문자열, 숫자, bool, 객체, 배열, 함수, null 값 및 시스템에서 지원되는 다른 유형

function main() {
    var dict1 = threading.Dict()
    dict1.set("func1", function(p) {
        Log("func1 p:", p)
    })
    
    threading.Thread(function(dict1) {
        var func1 = dict1.get("func1")
        func1("test")
    }, dict1).join()
}

키값을 함수로 전달하는 것을 지원합니다.

###############################################################################################################################################################################################################################################################

네트워크 설정 웹3

2019 FMZ - 모든 권리 보호