VPM (Все сообщения пользователя)

function main()
    threads[1] = coroutine.create(function() worker("A", 2) end)
    threads[2] = coroutine.create(function() worker("B", 5) end)

    while is_run do
        for _, co in ipairs(threads) do
            if coroutine.status(co) ~= "dead" then
                coroutine.resume(co)
            end
        end
        sleep(200)
    end
end

-- "Лёгкий поток" для фоновой задачиlocal function background_task()
    local count = 0
    while is_run do
        count = count + 1
        message("Фоновая задача: шаг " .. count)
        coroutine.yield()  -- уступаем управление
    end
end

local co = coroutine.create(function()
    for i = 1, 5 do
        print("Работаю...", i)
        coroutine.yield() -- приостанавливаем "поток"
    end
end)

while coroutine.status(co) ~= "dead" do
    coroutine.resume(co) -- возобновляем
    sleep(100)
end

--- Пример «лёгкого фонового потока» в QUIK

local is_run = true

-- "Лёгкий поток" для фоновой задачи
local function background_task()
    local count = 0
    while is_run do
        count = count + 1
        message("Фоновая задача: шаг " .. count)
        coroutine.yield()  -- уступаем управление
    end
end

function main()
    local co = coroutine.create(background_task)
    message("Запуск фонового лёгкого потока...")
    while is_run do
        coroutine.resume(co)  -- возобновляем поток
        sleep(1000)           -- имитация "асинхронного" поведения
    end
end

function OnStop()
    is_run = false
    message("Остановка фонового потока.")
end


-- * Корутину можно считать лёгким потоком Lua — она живёт, имеет собственный контекст и исполняется пошагово.

--- Рабочий пример фонового скрипта QUIK с корутиной
local is_run = true  -- глобальный флаг для остановки фоновой задачи

function main()
    message("Скрипт запущен. Идёт фоновое измерение производительности...")

    -- создаём корутину (фоновую задачу)
    local co = coroutine.create(worker)

    -- основной цикл QUIK
    while is_run do
        local ok, err = coroutine.resume(co)
        if not ok then
            message("Ошибка в корутине: " .. tostring(err))
            break
        end
        sleep(1000) -- основной поток спит 1 сек между циклами
    end

    message("Скрипт остановлен.")
end

-- фоновая функция
function worker()
    local N = 100000
    local c, f = 0, 0

    local function foo()
        f = f + 1
    end

    local co_task = coroutine.create(function()
        while true do
            c = c + 1
            coroutine.yield()
        end
    end)

    while is_run do
        local TT1 = os.clock()
        for i = 1, N do
            local ok, err = coroutine.resume(co_task)
            if not ok then
                message("Ошибка в co_task: " .. tostring(err))
                break
            end
        end
        TT1 = (os.clock() - TT1) * 1000

        local TT2 = os.clock()
        for i = 1, N do
            foo()
        end
        TT2 = (os.clock() - TT2) * 1000

        local out = string.format(
            "Фон: N=%d, coroutine=%.3f мс (c=%d), func=%.3f мс (f=%d), T1/T2=%.2f",
            N, TT1, c, TT2, f, TT1 / TT2
        )
        message(out)

        sleep(3000) -- измерение каждые 3 секунды
    end
end

function OnStop()
    is_run = false
    message("Останавливаем фоновую задачу...")
end

Вывод:
   TYPE   DATE   TIME   MESSAGE
1   1   29.10.2025   10:31:19   Скрипт запущен. Идёт фоновое измерение производительности...
2   1   29.10.2025   10:31:20   Фон: N=100000, coroutine=584.000 мс (c=100000), func=6.000 мс (f=100000), T1/T2=97.33
3   1   29.10.2025   10:31:23   Фон: N=100000, coroutine=604.000 мс (c=200000), func=7.000 мс (f=200000), T1/T2=86.29
4   1   29.10.2025   10:31:27   Фон: N=100000, coroutine=586.000 мс (c=300000), func=7.000 мс (f=300000), T1/T2=83.71
5   1   29.10.2025   10:31:30   Фон: N=100000, coroutine=553.000 мс (c=400000), func=7.000 мс (f=400000), T1/T2=79.00
6   1   29.10.2025   10:31:34   Фон: N=100000, coroutine=614.000 мс (c=500000), func=7.000 мс (f=500000), T1/T2=87.71
7   1   29.10.2025   10:31:38   Фон: N=100000, coroutine=550.000 мс (c=600000), func=7.000 мс (f=600000), T1/T2=78.57
8   1   29.10.2025   10:31:41   Фон: N=100000, coroutine=555.000 мс (c=700000), func=7.000 мс (f=700000), T1/T2=79.29
9   1   29.10.2025   10:31:45   Фон: N=100000, coroutine=544.000 мс (c=800000), func=6.000 мс (f=800000), T1/T2=90.67
10   1   29.10.2025   10:31:45   Останавливаем фоновую задачу...
11   1   29.10.2025   10:31:49   Скрипт остановлен.

--[[Помним!
Время работы корутин в QUIK может зависеть от множества факторов: 
* нагрузки платформы, 
* количества исполняющихся скриптов, 
* задержек в сети
 и так далее.
--]]

-- Переписанный пример с использованием корутин и пустой функции в QUIK в формате кода Lua:

--local message = message or print;
local run = true

function main()

   local N = 100000
   local c,f = 0,0
   -- создаем корутину, которая будет выполнять асинхронную задачу
   local co = coroutine.create(function()
      local yield = coroutine.yield
      while true do
         -- можно выполнять любую логику
       c = c + 1
         yield()  -- здесь задача будет приостанавливаться
      end
   end)

   -- простая функция, которая ничего не делает
   local function foo1() 
        f = f + 1
        return f
   end

   local out = 'Результат теста: количество вызовов = ' .. N .. ', время вызова сопрограммы '
   while true do
        
      -- замер времени для корутины
        local TT1 = os.clock()
        for i = 1, N do
            local ok, err = coroutine.resume(co)  -- возобновляем выполнение корутины
            if not ok then
                message("Ошибка при выполнении корутины: " .. err)
                break
            end
        end
        TT1 = (os.clock() - TT1) * 1000
      message("TT1: " .. TT1 .."; c = " .. c)

        -- замер времени для обычной функции
        local TT2 = os.clock()
        for i = 1, N do
            foo1()
        end
      TT2 = (os.clock() - TT2) * 1000
      message("TT2: " .. TT2 .."; f = " .. f)

        -- вывод результата
        out = out .. string.format("%.3f мс, функции %.3f мс, T1/T2 = %.2f", TT1, TT2, TT1 / TT2)
        message(out)
         return
   end
   run = false

end

Результаты у одного брокера:
   TYPE   DATE   TIME   MESSAGE
1   1   29.10.2025   9:47:15   TT1: 555.00000000029; c = 100000
2   1   29.10.2025   9:47:15   TT2: 7.9999999998108; f = 100000
3   1   29.10.2025   9:47:15   Результат теста: количество вызовов = 100000, время вызова сопрограммы 555.000 мс, функции 8.000 мс, T1/T2 = 69.38

--[[ КОНФИГУРАЦИЯ ]]--
local Config = {
        --Config.Trading.account  Config.Trading.client_code
    Trading = {
        market = "TQBR",
        ticker = "SBER",
        account = "L01+00000F00",
        client_code = "21045400",
        firmid = "MC0031400000",
        order_type = "LIMIT",
        time_in_force = "GTC",
        volatility_period = 20,
        regime_detection = true,
        
        max_order_retries = 3,      -- максимум 3 попытки перевыставления
        retry_delay = 5,            -- задержка 5 секунд между попытками
        order_timeout = 30          -- таймаут ордера 30 секунд
    },

    Grid = {
        levels = 5,
        base_lot = 1,
        step_type = "ADAPTIVE",
        step_ticks = 5,
        min_ticks = 3,
        max_ticks = 8,
        grid_levels = 5, 
        lots_per_level = 1,
        grid_step = 0.1,
        --account = "L01+00000F00",    -- ДУБЛИРУЕМ ДЛЯ GridManager
        --client = "21045400",         -- ДУБЛИРУЕМ ДЛЯ GridManager
        
        martingale = {
            enabled = true,
            type = "OPTIMAL",
            factor = 1.3,
            max_levels = 3,
        },
        
        take_profit = {
            type = "DYNAMIC", 
            ticks = 8,
            multiplier = 1.6,
        },
        
        hedge_enabled = true,
        auto_rebalance = true,
        rebalance_threshold = 0.7,
    },
    
    Risk = {
        total_capital = 1000000,
        risk_per_trade = 0.02,
        max_instrument_risk = 0.05,
        max_portfolio_risk = 0.15,
        reserve_ratio = 0.1,
        margin_safety = 1.5,
        max_position_value = 0.2,
        max_total_exposure = 0.4,
        stop_loss_individual = 0.05,
        stop_loss_portfolio = 0.08,
        daily_loss_limit = 0.05,
        max_drawdown_limit = 0.15,
        position_sizing = "KELLY",
        kelly_fraction = 0.5,
    },

    GUI = {
        enabled = true,
        update_interval = 2,
        show_detailed_stats = true,
        alert_on_limits = true,
    }
}

dofile("hacktrade.lua")
function Robot()

  feed = MarketData{
    market = "MCODE",
    ticker = "TCKR",
  }
  
  order = SmartOrder{
    market = "MCODE",
    ticker = "TCKR",
    account = "ACNT1234567890",
    client = "775533",
  }

  ind = Indicator{tag="MYIND"}

  while true do
    if feed.last > ind[-2] then
      order:update(feed.last, 1)
    elseif feed.last < ind[-2] then
      order:update(feed.last, -1)
    end
    Trade()
  end
end

function сложнаяЗадача()
    local data = загрузитьДанные("url") -- Здесь может быть yield
    local result = обработатьДанные(data) -- И здесь
    local success = сохранитьВБД(result) -- И здесь
    если success then
        обновитьИнтерфейс()
    end
end
-- Создаем сопрограмму и "опросом" управляем ее выполнением
local task = coroutine.create(сложная Задача)

-- Пул из нескольких "независимых задач", как вы и сказали
local tasks = {
    coroutine.create(function() ... end), -- Задача 1: загрузка контента
    coroutine.create(function() ... end), -- Задача 2: анимация UI
    coroutine.create(function() ... end), -- Задача 3: обработка ввода
}

-- Главный цикл "опросом" управляет всеми задачами
function главныйЦикл()
    while true do
        local всеЗавершены = true
        for i, co in ipairs(tasks) do
            if coroutine.status(co) ~= "dead" then
                всеЗавершены = false
                coroutine.resume(co) -- "Опрос" конкретной сопрограммы!
            end
        end
        если все Завершены then break end
    end
end

-- В движке: ждем 2 секунды перед загрузкой данных.
function ждать(секунды)
    local времяСтарта = os.clock()
    while os.clock() - времяСтарта < секунды do
        coroutine.yield() -- "Спим", не блокируя основной поток, отдавая управление другим задачам
    end
end

function бесконечнаяПоследовательность(старт, шаг)
    local текущее = старт
    while true do
        coroutine.yield(текущее)
        текущее = текущее + шаг
    end
end

-- Создаем генератор чисел, начиная с 10, с шагом 5
local генератор = coroutine.wrap(бесконечнаяПоследовательность)
local gen = генератор(10, 5)

print(gen()) --> 10
print(gen()) --> 15
print(gen()) --> 20
-- Можно получать значения по требованию, не вычисляя все сразу.

function OnMain()

    Log:trace("OnMain started")
    
    -- Создаем корутины Прверка пароля
    local coPassword   = coroutine.create(checkPassword)
    
    -- Прверка пароля при первом входе!(корутина с безопасным вызовом)
    safe_resume(coPassword, "coPassword")

    --[[GUI.initialize()

    -- Создание таблицы ордеров
    GUI.createTable({
        name = "orders",
        title = "Active Orders",
        width = 1000,
        height = 400,
        x = 10,
        y = 50,
        columns = {
            {
                iCode = 1,
                title = "Time",
                par_type = QTABLE_TIME_TYPE,
                width = 120
            },
            {
                iCode = 2,
                title = "Price",
                par_type = QTABLE_DOUBLE_TYPE,
                width = 100
            },
            {
                iCode = 3,
                title = "Volume",
                par_type = QTABLE_INT64_TYPE,
                width = 100
            }
        }
    })
    
    -- Создание информационной метки
    GUI.createLabel({
        id = "statusLabel",
        text = "System Status: OK",
        x = 10,
        y = 10,
        width = 300,
        color = "#00FF00",
        bgColor = "#333333"
    })
    --]]

    GUI.initialize()
    -- Создание таблицы ордеров
    GUI.createTable({
        name = "orders",
        title = "Активные ордера",
        columns = {
            {
                iCode = 1,
                title = "Время",
                type = QTABLE_TIME_TYPE,
                width = 120
            },
            {
                iCode = 2,
                title = "Операция",
                type = QTABLE_STRING_TYPE,
                width = 100
            },
            {
                iCode = 3,
                title = "Объем",
                type = QTABLE_INT_TYPE, -- Теперь правильно QTABLE_INT_TYPE = 1
                width = 80
            }
        }
    })

    -- Пример использования в главном цикле
    local hook = PerformanceHook()
    --local performanceHook = PerformanceHook()

    local fatal = nil

    AutoUpdateVersion()
    CreateWindowRobot()

    if Start ~= nil then
        Start()
    end

    AtExit(function()
        for _, so in pairs(SmartOrder.pool) do
            so:enough()
            so:process()
        end
    end)

    if Robot ~= nil then -- Провека на наличие основтой функции

        ---- функция для получения информации о классе 
        local ClassInfo = getClassInfo(class_names[1]);
        firmid = ClassInfo and ClassInfo.firmid or ''; Log:trace('firmid = ' .. tostring(firmid ) );
        
        -- Создаем корутину для функции Robot
        local routine = coroutine.create(Robot) 
        Log:trace("Robot started")
        
        -- Создаем корутины
        --local coPassword   = coroutine.create(checkPassword)
        local coConnection = coroutine.create(checkConnection)
        local coTradeDate  = coroutine.create(checkTradeDate)
        local coServerTime = coroutine.create(checkServerTime)
        local coWorkTime   = coroutine.create(checkWorkTime) -- Сопрограмма для отслеживания рабочего времени 
        --local coStopTimeTrading = coroutine.create(checkStopTimeTrading)

        -- Cоздание корутин для стратегий реального времени
        --if not rejime.test and event_co.connected == 1 and event_co.servertime[2] and flagTimeTrading then
            -- Cоздание корутины function 
            local coCapitalManager = coroutine.create(CapitalManagerCo--function() CapitalManagerCo(CONFIG) end
            )
            local coMoneyManagement = coroutine.create(function()
              --for _, class in ipairs(class_names) do
                --for n, symbol in ipairs(symbol_names) do  
                    --if mm[class][symbol] ~= nil then
                        --MoneyManagementCo( mm[class][symbol] )
                        MoneyManagementCo( firmid, account, class_names, symbol_names )
                    --else
                        --Log:error("MoneyManagement instance 'mm[n]' is nil. Cannot start MoneyManagementCoroutine.")
                    --end
                --end
              --end
            end)

        --if not rejime.test and event_co.connected == 1 and event_co.servertime[2] and flagTimeTrading then
            local co_alltrade = coroutine.create(alltrade_processor)
            local co_order_book = coroutine.create(order_book_processor)
            --local co_tt_parametrs = coroutine.create(trade_data_processor)
            
            local futuresCoroutine = coroutine.create(futures_position_processor)
            local futuresLimitCoroutine = coroutine.create(futures_limit_processor)
        --end
        
           
        while WORKING_FLAG do

            --------------------------
            local sek = os.clock();
            --------------------------

            --[[-- Обновление данных
            --GUI.update_connection_status(isConnected())
            --GUI.update_last_activity(os.time())
            --GUI.update_uptime(getUptime())

            -- Добавление новых ордеров
            --while hasNewOrders() do
            --    GUI.add_order(getNextOrder())
            --end

            -- Обновление торговой панели
            GUI.updateComponent("trading_panel", {
                {"BUY", 100.50, 10},
                {"SELL", 101.00, 5}
            })

            -- Добавление метки на график
            GUI.Chart.addLabel("MAIN_CHART", "Support Level", {
            YVALUE = 98.50,
            COLOR = RGB(46, 204, 113)
            })--]]

            -- Обновление данных
            GUI.updateTable("orders", {
                {os.date("%H:%M:%S"), "BUY", 10},
                {os.date("%H:%M:%S"), "SELL", 5}
            })

            -- Запуск корутин с безопасным вызовом
            if not rejime.test then

                safe_resume(coConnection, "coConnection")
                SetCell(table_id, 1, 1, tostring(event_co.connected == 1 and 'Connect' or 'NoConnect'))

                if event_co.connected == 1 then

                    safe_resume(coTradeDate,  "coTradeDate")
                    safe_resume(coServerTime, "coServerTime")
                    safe_resume(coWorkTime,   "coWorkTime")
                    --safe_resume(coStopTimeTrading, "coStopTimeTrading")

                    --if event_co.connected == 1 then
                    -- Запуск корутины MoneyManagement
                    --safe_resume( MoneyManagementRoutine, "MoneyManagementRoutine")
                    safe_resume( coCapitalManager, "coCapitalManager")
                    --end

                    -- Запускаем корутину (История сделок и стакан)
                    --Log:info('tradedate[1] =' ..tostring(event_co.tradedate[1]) ..'; worktime =' ..tostring(event_co.worktime[2]) ..'; servertime[2] =' ..tostring(event_co.servertime[2]) --..'; flagTimeTrading =' ..tostring(flagTimeTrading) )
                    
                    if event_co.tradedate[1] 
                    and event_co.worktime[2]
                    and event_co.servertime[2] 
                    then
                        safe_resume(co_alltrade, 'co_alltrade')
                        safe_resume(co_order_book, 'co_order_book')
                    end

                    --coroutine.resume(co_tt_parametrs)
                    -- Функция для запуска корутины
                    --start_futures_position_processing(futuresCoroutine)
                    --start_futures_limit_processing(futuresLimitCoroutine)

                    safe_resume(futuresCoroutine, 'futuresCoroutine')
                    --safe_resume(futuresLimitCoroutine, 'futuresLimitCoroutine')
                end

                -- Формирем модуль СМ
                --safe_resume( coCapitalManager, "coCapitalManager")
                --safe_resume( coMoneyManagement, "coMoneyManagement")
            end

            -- co Robot Затем используйте его методы
            local res, errmsg = coroutine.resume(routine)
            
            if not res then
                fatal = "Broken coroutine (Robot): " .. errmsg
                -- Вариант 1: Использование глобального обработчика (рекомендуется)
                _G.global_error_handler:handle_error(fatal, "Robot")
    
                -- Вариант 2: Статический вызов
                -- ErrorHandler.handle_error_static(fatal, "Robot")
                break
            end

            if coroutine.status(routine) == "dead" then
                Log:trace("Robot routine finished")
                break
            end
           
            ProcessRegistered()

            --local elapsed_ms = performanceHook(sek) -- sleep(1000)
            hook(sek)  -- Обновляем метрики

            sleep(spinner.config.interval * 1000)  -- Контроль частоты

            --if rejime.test then 
            --    sleep(100)
            --else
            --    Log:trace(math.floor(1000 - tonumber(elapsed_ms)))
                --sleep(  )
            --    sleep(1000)
            --end
        end
    end

    if Stop ~= nil then Stop() end
    ProcessAtExit()  -- Вызов ProcessAtExit
    ErrorCollector.log_all_errors()  -- Логирование всех ошибок при завершении
    Log:trace("Robot stopped")
    
    if fatal ~= nil then
        error(fatal)
    end
end

require "iuplua"

-- Указываем глобальный атрибут для работы с корутинами
iup.SetGlobal("IUPLUA_THREADED", "YES")

-- Функция для создания диалога с текстовым полем
function create_input_dialog()
    local text = iup.text{expand = "HORIZONTAL", value = ""}
    local ok_btn = iup.button{title = "OK", size = "50"}
    local cancel_btn = iup.button{title = "Cancel", size = "50"}
    
    local dlg = iup.dialog{
        iup.vbox{
            iup.label{title = "Введите текст:"},
            text,
            iup.hbox{ok_btn, cancel_btn}
        },
        title = "Ввод данных",
        size = "300x100"
    }
    
    return dlg, text, ok_btn, cancel_btn
end

-- Функция для асинхронного ввода через корутину
function async_input(coroutine_fn)
    return function(...)
        local co = coroutine.create(coroutine_fn)
        local success, result = coroutine.resume(co, ...)
        return result
    end
end

-- Основная функция диалога как корутина
function input_dialog_coroutine()
    local dlg, text, ok_btn, cancel_btn = create_input_dialog()
    
    -- Создаем promise-like объект для синхронизации
    local result = { waiting = true, value = nil }
    
    -- Callback для OK
    ok_btn.action = function()
        result.value = text.value
        result.waiting = false
        return iup.CLOSE
    end
    
    -- Callback для Cancel
    cancel_btn.action = function()
        result.value = nil
        result.waiting = false
        return iup.CLOSE
    end
    
    -- Показываем диалог (не модальный!)
    dlg:show()
    
    -- Ждем завершения в цикле (можно заменить на более изящное решение)
    while result.waiting do
        coroutine.yield()  -- Отдаем управление обратно
        iup.LoopStep()     -- Обрабатываем события IUP
    end
    
    dlg:destroy()
    return result.value
end

-- Пример использования в основном потоке Quik
function main()
    print("Начало работы скрипта")
    
    -- Запускаем диалог в корутине
    local co = coroutine.create(input_dialog_coroutine)
    
    -- Основной цикл обработки
    local timer = os.clock()
    while coroutine.status(co) ~= "dead" do
        -- Периодически возобновляем корутину
        if os.clock() - timer > 0.1 then  -- каждые 100 мс
            local success, input_text = coroutine.resume(co)
            if success and input_text then
                print("Пользователь ввел: " .. input_text)
                break
            elseif not success then
                print("Ошибка в корутине:", input_text)
                break
            end
            timer = os.clock()
        end
        
        -- Здесь может выполняться другой код
        -- Например, обработка данных из Quik
        process_quik_data()
        
        -- Небольшая пауза чтобы не грузить CPU
        os.execute("ping -n 1 127.0.0.1 > nul")  -- для Windows
        -- os.execute("sleep 0.1")  -- для Linux
    end
    
    print("Скрипт продолжает работу после диалога")
end

function process_quik_data()
    -- Здесь может быть код для работы с данными Quik
    -- который выполняется параллельно с открытым диалогом
end

-- Запуск основной функции
main()

RingBufferClassOPP.lua"  1  
Функциональный стиль:
Последнее значение:   100
Предпоследнее:   90
Первое в буфере:   30

Все элементы (новые сначала):
100
90
80
70
60
50
40
30

ООП стиль:
RSI   1   период назад:   45
RSI   2   период назад:   36
RSI   3   период назад:   50
RSI   4   период назад:   46
RSI   5   период назад:   54
Среднее RSI:   46.2

Анализ ADX:   Слабый тренд или флэт
Функциональный стиль:   0.43   сек
ООП стиль:   0.631   сек
>Exit code: 0    Time: 1.483