Auch SAP kann Multitasking. Dazu muss mann einen RFC-fähigen Funktionsbaustein in einem neuen Task innerhalb einer sogenannten Taskgroup aufrufen. Die Abarbeitung erfolgt dann asynchron, dass Ergebnis wird in einer Handler-Funktion zurückgeliefert.
Im folgenden Funktionsbeispiel erzeugt das Rahmenprogramm “zparallel” Arbeitspakete (it_input) für die Tasks und ein Objekt der Klasse “lcl_task_manager”. Letzteres managed die Verteilung der Eingangsdaten (it_input) auf mehrere Tasks. Die Taskobjekte werden durch die Klasse “lcl_task” abgebildet. Die einzelnen Tasks rufen asynchron mit ihren Arbeitspaketen den RFC-fähigen Funktionsbaustein “BAPI_BILLINGDOC_GETLIST”.
Nach erfolgreichem Beenden aller Tasks werden die Ergebnisse der Arbeitspakete zusammengesetzt (it_result) und an das Rahmenprogramm zurückgegeben.
Weiterführende Informationen: Link, Link, Link und Link
Rahmenprogramm: REPORT zparallel (Aufruf der Parallelverarbeitung)
REPORT zparallel.
* Klassen für Taskmanagement
INCLUDE ztask_manager.
* iTabs für Eingabe- und Ausgabedaten
DATA: it_input TYPE lcl_task=>ty_it_input_data.
DATA: it_result TYPE lcl_task_manager=>ty_it_final_result.
DATA: it_statistic TYPE lcl_task_manager=>ty_it_statistic.
PARAMETERS: p_rows TYPE i DEFAULT 1000. " Test-Elemente
PARAMETERS: p_wait TYPE i DEFAULT 5. " Wartezeit in [s]
PARAMETERS: p_max_rt TYPE i DEFAULT 3. " max. Anzahl Versuche
PARAMETERS: p_size TYPE i DEFAULT 100. " Intervallgröße
START-OF-SELECTION.
DATA: it_vbelv TYPE STANDARD TABLE OF vbelv WITH DEFAULT KEY.
* Intervalle erzeugen
SELECT DISTINCT vbelv FROM vbfa INTO TABLE @it_vbelv UP TO @p_rows ROWS.
IF sy-subrc = 0.
SORT: it_vbelv BY table_line.
DATA(lv_lines) = lines( it_vbelv ).
DATA(lv_parts) = lv_lines DIV p_size.
DATA(lv_mod) = lv_lines MOD p_size.
IF lv_mod <> 0.
lv_parts = lv_parts + 1.
ENDIF.
DATA(lv_idx_l) = 0.
DATA(lv_idx_h) = 0.
DO lv_parts TIMES.
lv_idx_l = lv_idx_h + 1.
lv_idx_h = lv_idx_l - 1 + p_size.
IF lv_idx_h > lv_lines.
lv_idx_h = lv_lines.
ENDIF.
APPEND VALUE #( sign = 'I'
option = 'BT'
ref_doc_low = it_vbelv[ lv_idx_l ]
ref_doc_high = it_vbelv[ lv_idx_h ] ) TO it_input.
ENDDO.
* Referenz auf Tastmanager für Parallelverarbeitung
DATA(o_task_manager) = lcl_task_manager=>get_instance( i_task_group = lcl_task_manager=>co_default_task_group ).
DATA: lv_started TYPE i.
DATA: lv_ended TYPE i.
DATA: lv_missed TYPE i.
* Timer starten
DATA(o_timer) = cl_abap_runtime=>create_hr_timer( ).
DATA(usec_start) = o_timer->get_runtime( ).
* Parallele Verarbeitung der Eingabedaten starten
IF abap_true = o_task_manager->start_parallel_working( EXPORTING
i_it_input_data = it_input
i_wait_time_sec = p_wait
i_max_retries = p_max_rt
IMPORTING
e_it_final_result = it_result
e_it_statistic = it_statistic
e_tasks_started = lv_started
e_tasks_ended = lv_ended
e_tasks_missed = lv_missed ).
* Timer stoppen
DATA(usec_end) = o_timer->get_runtime( ).
DATA(usec) = CONV decfloat16( usec_end - usec_start ).
DATA(sec) = usec / 1000000.
WRITE: / ' Zeit [µs]:', usec.
WRITE: / ' Zeit [s]:', sec.
WRITE: / ' max. Tasks:', o_task_manager->get_max_tasks( ).
WRITE: / ' free Tasks:', o_task_manager->get_free_tasks( ).
WRITE: / 'Tasks started:', lv_started.
WRITE: / ' Tasks ended:', lv_ended.
WRITE: / ' Tasks missed:', lv_missed.
WRITE: / ' Input lines:', lines( it_input ).
WRITE: / ' Result lines:', lines( it_result ).
ULINE.
WRITE: / | Task # \| Retries \| Time [µs] \| S \| IN: LOW \| IN: HIGH \| SUBRC \| SIZE|.
ULINE.
LOOP AT it_statistic ASSIGNING FIELD-SYMBOL(<fs_stat>).
WRITE: / <fs_stat>-task_number, '|', <fs_stat>-retries, '|', <fs_stat>-runtime, '|', <fs_stat>-successful, '|', <fs_stat>-input_data-ref_doc_low, '|', <fs_stat>-input_data-ref_doc_high, '|', <fs_stat>-subrc, '|', <fs_stat>-output_part_size.
ENDLOOP.
ULINE.
WRITE: / | ITEM # \| IN: LOW \| IN: HIGH \| OUT: REF_DOC|.
ULINE.
* Ergebnisausgabe
LOOP AT it_result ASSIGNING FIELD-SYMBOL(<fs_res>).
WRITE: / sy-tabix, '|', <fs_res>-input_data-ref_doc_low, '|', <fs_res>-input_data-ref_doc_high, '|', <fs_res>-output_data-ref_doc.
ENDLOOP.
ENDIF.
ENDIF.
Task-Klassen: INCLUDE ZTASK_MANAGER
*--------------------------------------------------------------------*
* Task-Klasse (Worker)
*--------------------------------------------------------------------*
* Ruft asynchon einen RFC-fähigen Funktionsbaustein
* und verarbeitet asynchron das Ergebnis (Event)
*--------------------------------------------------------------------*
CLASS lcl_task DEFINITION FINAL.
PUBLIC SECTION.
* Eingabedaten des Task
TYPES: ty_input_data TYPE bapi_ref_doc_range.
* Ausgabedaten des Task
TYPES: ty_output_data TYPE bapivbrksuccess.
TYPES: ty_it_input_data TYPE STANDARD TABLE OF ty_input_data WITH DEFAULT KEY.
TYPES: ty_it_output_data TYPE STANDARD TABLE OF ty_output_data WITH DEFAULT KEY.
* Name des RFC-fähigen Funktionsbausteines für "start_async_call" und "task_receive"-Handler
CONSTANTS: co_fb_name TYPE string VALUE 'BAPI_BILLINGDOC_GETLIST'.
* Event, wird getriggert, wenn die asynchrone Methode task_receive aufgerufen wird
EVENTS:
data_received
EXPORTING
VALUE(e_subrc) TYPE sy-subrc
VALUE(e_runtime) TYPE int4
VALUE(e_retries) TYPE i
VALUE(e_input_data) TYPE ty_input_data
VALUE(e_output_data) TYPE ty_it_output_data.
* Konstruktor
METHODS:
constructor
IMPORTING
i_task_group TYPE rzllitab-classname
i_task_number TYPE i.
* Startet asynchronen Aufruf des RFC-Bausteins
METHODS:
start_async_call
IMPORTING
i_input_data TYPE ty_input_data
i_started_after_n_retries TYPE i
RETURNING VALUE(rv_subrc) TYPE sy-subrc.
* Handlermethode, wird asynchron gerufen
METHODS:
task_receive
IMPORTING
p_task TYPE clike.
* Hilfsfunktionen
METHODS:
is_running
RETURNING VALUE(rv_running) TYPE boolean.
METHODS:
get_group
RETURNING VALUE(rv_group) TYPE rzllitab-classname.
METHODS:
get_task_number
RETURNING VALUE(rv_number) TYPE i.
PRIVATE SECTION.
DATA: lv_group TYPE rzllitab-classname.
DATA: lv_number TYPE i.
DATA: lv_running TYPE boolean.
DATA: lv_started_after_n_retries TYPE i.
DATA: lv_start_time TYPE int4.
DATA: lv_end_time TYPE int4.
* Merker für Übergabe-Parameter in start_async_call
DATA: lv_input_data TYPE ty_input_data.
ENDCLASS.
CLASS lcl_task IMPLEMENTATION.
*--------------------------------------------------------------------*
* Konstruktor
*--------------------------------------------------------------------*
* -> i_task_group - Gruppenname
* -> i_task_number - Tasknummer
*--------------------------------------------------------------------*
METHOD constructor.
lv_group = i_task_group.
lv_number = i_task_number.
lv_running = abap_false.
lv_start_time = 0.
lv_end_time = 0.
lv_started_after_n_retries = 0.
ENDMETHOD.
*--------------------------------------------------------------------*
* Startet asynchronen Aufruf des RFC-Bausteins
*--------------------------------------------------------------------*
* -> i_input_data - Eingabedaten für Verarbeitung
* -> i_started_after_n_retries - Statistikwert, nach wieviel Versuchen
* der Task gestartet werden konnte
* <- rv_subrc - Status des asynchronen Aufrufs
*--------------------------------------------------------------------*
METHOD start_async_call.
lv_running = abap_false.
lv_started_after_n_retries = i_started_after_n_retries.
GET RUN TIME FIELD lv_start_time.
* neuen asynchronen Aufruf des Bausteines starten
* Gruppe, Tasknummer und Handlerfunktion übergeben
* Baustein muss RFC-fähig sein
* Verfügbare RFC-Gruppen für Parallelverarbeitung: Transaktion RZ12
* Namen und Typen der EXPORTING-Parameter beachten:
* -> fehlerhafte Angaben werden nicht vom Compiler bemerkt oder auch nicht als sy-subrc zurückgegeben
CALL FUNCTION co_fb_name
STARTING NEW TASK lv_number
DESTINATION IN GROUP lv_group
CALLING task_receive ON END OF TASK
EXPORTING
refdocrange = i_input_data
EXCEPTIONS
system_failure = 1
communication_failure = 2
resource_failure = 3
OTHERS = 4.
* Fehlerstatus zurückgeben
rv_subrc = sy-subrc.
IF rv_subrc = 0.
lv_input_data = i_input_data.
lv_running = abap_true.
ENDIF.
ENDMETHOD.
*--------------------------------------------------------------------*
* Receive-Funktion, welche bei Fertigsstellung vom Task asynchron
* getriggert wird
* Es werden keine WRITE-Statements ausgeführt!
*--------------------------------------------------------------------*
* -> p_task - Tasknummer
*--------------------------------------------------------------------*
METHOD task_receive.
DATA: it_task_data TYPE ty_it_output_data.
* Ergebnisse des asynchronen RFC-Aufrufes vom Funktionsbaustein holen
RECEIVE RESULTS FROM FUNCTION co_fb_name
TABLES
success = it_task_data
EXCEPTIONS
system_failure = 1
communication_failure = 2
resource_failure = 3
OTHERS = 4.
GET RUN TIME FIELD lv_end_time.
DATA(lv_runtime) = lv_end_time - lv_start_time.
* Event für Datenrückgabe triggern
RAISE EVENT data_received
EXPORTING
e_subrc = sy-subrc
e_runtime = lv_runtime
e_retries = lv_started_after_n_retries
e_input_data = lv_input_data
e_output_data = it_task_data.
lv_running = abap_false.
ENDMETHOD.
*--------------------------------------------------------------------*
* Gibt Status des Tasks
*--------------------------------------------------------------------*
* <- rv_running - Status des Tasks
*--------------------------------------------------------------------*
METHOD is_running.
rv_running = lv_running.
ENDMETHOD.
*--------------------------------------------------------------------*
* Gibt Gruppenname, in welcher der Task läuft
*--------------------------------------------------------------------*
* <- rv_group - Gruppenname
*--------------------------------------------------------------------*
METHOD get_group.
rv_group = lv_group.
ENDMETHOD.
*--------------------------------------------------------------------*
* Gibt Tasknummer
*--------------------------------------------------------------------*
* <- rv_number - Tasknummer
*--------------------------------------------------------------------*
METHOD get_task_number.
rv_number = lv_number.
ENDMETHOD.
ENDCLASS.
*--------------------------------------------------------------------*
* Verwaltungs-Klasse für Tasks
*--------------------------------------------------------------------*
* 1. Verarbeitet Eingabedaten (Workitems)
* 2. Holt für jedes Workitem einen freien Task
* 3. Startet pro Workitem einen Task (asynchron)
* 4. Wertet das asynchron gelieferte Ergebis in einer Handlermethode aus
*--------------------------------------------------------------------*
* Sinnvoll ist die Implementierung nur, wenn die Workprozesse
* ausreichend lange dauern, so dass sich eine parallele Verarbeitung
* überhaupt lohnt
*--------------------------------------------------------------------*
CLASS lcl_task_manager DEFINITION FINAL CREATE PRIVATE.
PUBLIC SECTION.
* Datentyp für finale Ausgabe, wenn alle Workprozesse fertig sind
TYPES: BEGIN OF ty_final_result,
input_data TYPE lcl_task=>ty_input_data,
output_data TYPE lcl_task=>ty_output_data,
END OF ty_final_result.
TYPES: ty_it_final_result TYPE STANDARD TABLE OF ty_final_result WITH DEFAULT KEY.
TYPES: BEGIN OF ty_statistic,
task_number TYPE i,
runtime TYPE int4,
retries type i,
input_data TYPE lcl_task=>ty_input_data,
output_part_size TYPE i,
subrc TYPE sy-subrc,
successful TYPE boolean,
END OF ty_statistic.
TYPES: ty_it_statistic TYPE STANDARD TABLE OF ty_statistic WITH DEFAULT KEY.
* RFC-Gruppenname
* die Gruppe mit classname = 'parallel_generators' wird standardmäßig von Admins eingerichtet
* Gruppen sind in Tabelle "RZLLITAB" abgelegt, grouptype = 'S' (Server)
* Transaktion RZ12
CONSTANTS: co_default_task_group TYPE rzllitab-classname VALUE 'parallel_generators'.
* Factory-Funktion
CLASS-METHODS:
get_instance
IMPORTING
i_task_group TYPE rzllitab-classname DEFAULT co_default_task_group
RETURNING VALUE(rv_ref_task_manager) TYPE REF TO lcl_task_manager.
* Startet die parallele Abarbeitung der Eingabedaten
METHODS:
start_parallel_working
IMPORTING
i_it_input_data TYPE lcl_task=>ty_it_input_data
i_wait_time_sec TYPE i DEFAULT 10
i_max_retries TYPE i DEFAULT 3
EXPORTING
e_it_final_result TYPE ty_it_final_result
e_it_statistic TYPE ty_it_statistic
e_tasks_started TYPE i
e_tasks_ended TYPE i
e_tasks_missed TYPE i
RETURNING VALUE(rv_work_complete) TYPE boolean.
METHODS:
get_max_tasks
RETURNING VALUE(rv_max_tasks) TYPE i.
METHODS:
get_free_tasks
RETURNING VALUE(rv_free_tasks) TYPE i.
PRIVATE SECTION.
TYPES: BEGIN OF ty_task,
task_number TYPE i,
o_task TYPE REF TO lcl_task,
END OF ty_task.
* Null-Referenz
CONSTANTS: null TYPE REF TO lcl_task_manager VALUE IS INITIAL.
* Referenz auf ein Task-Objekt
CLASS-DATA: o_task_manager TYPE REF TO lcl_task_manager.
CLASS-DATA: lv_max_tasks TYPE i.
CLASS-DATA: lv_free_tasks TYPE i.
* Zähler
CLASS-DATA: lv_tasks_started TYPE i.
CLASS-DATA: lv_tasks_ended TYPE i.
CLASS-DATA: lv_active_tasks TYPE i.
* globale Taskliste
CLASS-DATA: it_tasks TYPE SORTED TABLE OF ty_task WITH UNIQUE KEY task_number.
* Ergebnisliste
CLASS-DATA: it_final_result TYPE ty_it_final_result.
* Ergebnisliste
CLASS-DATA: it_statistic TYPE ty_it_statistic.
* Handler für data_received-Ereignis der Tasks
METHODS:
on_task_completed FOR EVENT data_received OF lcl_task
IMPORTING
e_subrc
e_runtime
e_retries
e_input_data
e_output_data
sender.
* Hilfsfunktionen
METHODS:
get_free_task
RETURNING VALUE(rv_task_number) TYPE i.
METHODS:
get_task
IMPORTING
i_task_number TYPE i
RETURNING VALUE(rv_ref_task) TYPE REF TO lcl_task.
METHODS:
start_task
IMPORTING
i_input_data TYPE lcl_task=>ty_input_data
i_wait_time_sec TYPE i DEFAULT 10
i_max_retries TYPE i DEFAULT 3
RETURNING VALUE(rv_ok) TYPE boolean.
ENDCLASS.
*--------------------------------------------------------------------*
CLASS lcl_task_manager IMPLEMENTATION.
*--------------------------------------------------------------------*
* Factory Methode für Singleton (genau eine Referenz) auf den
* Taskmanager zurück
*--------------------------------------------------------------------*
* -> i_task_group - Name der RFC-Task-Group, in der die Tasks ablaufen
* sollen
* Vorgabewert ist 'parallel_generators', welche
* standardmäßig von Admins eingerichtet wird
* Gruppen sind in Tabelle "RZLLITAB" abgelegt,
* grouptype = 'S' (Server)
* Transaktion RZ12
* <- rv_ref_task_manager - Referenz auf Task-Manager-Objekt
*--------------------------------------------------------------------*
METHOD get_instance.
rv_ref_task_manager = null.
IF o_task_manager IS INITIAL.
DATA(lv_task_group) = i_task_group.
lv_max_tasks = 0.
lv_free_tasks = 0.
IF lv_task_group IS INITIAL.
* falls keine task group übergeben wurde, eine heraussuchen
* Verfügbare RFC-Gruppen für Parallelverarbeitung: Transaktion RZ12
SELECT SINGLE classname FROM rzllitab INTO @lv_task_group WHERE grouptype = 'S'.
ENDIF.
IF NOT lv_task_group IS INITIAL.
* Start neue LUW
COMMIT WORK.
* Parallel Background Tasks - Initialisierung der PBT-Umgebung
* Sollte nur 1x aufgerufen werden, sonst Exception "pbt_env_already_initialized"
CALL FUNCTION 'SPBT_INITIALIZE'
EXPORTING
group_name = lv_task_group
IMPORTING
max_pbt_wps = lv_max_tasks
free_pbt_wps = lv_free_tasks
EXCEPTIONS
invalid_group_name = 1
internal_error = 2
pbt_env_already_initialized = 3
currently_no_resources_avail = 4
no_pbt_resources_found = 5
cant_init_different_pbt_groups = 6
OTHERS = 7.
* wenn Initialisierung ok
IF sy-subrc = 0.
* wenn genug freie Tasks vorhanden
IF lv_free_tasks >= 1.
o_task_manager = NEW #( ).
lv_tasks_started = 0.
lv_tasks_ended = 0.
lv_active_tasks = 0.
CLEAR: it_tasks.
* Anzahl freie Tasks zur Liste hinzufügen
DO lv_free_tasks TIMES.
DATA(o_task) = NEW lcl_task( i_task_number = sy-index
i_task_group = lv_task_group ).
* Eventhandler für beendete Tasks
SET HANDLER o_task_manager->on_task_completed FOR o_task.
APPEND VALUE #( task_number = sy-index
o_task = o_task ) TO it_tasks.
ENDDO.
rv_ref_task_manager = o_task_manager.
ENDIF.
ENDIF.
ENDIF.
ELSE.
rv_ref_task_manager = o_task_manager.
ENDIF.
ENDMETHOD.
*--------------------------------------------------------------------*
* Parallele / asynchrone Abarbeitung anschieben
*--------------------------------------------------------------------*
* -> i_it_input_data - Eingabedaten
* -> i_wait_time_sec - Wartezeit für Abarbeitung aller Tasks in sec
* -> i_max_retries - max. Anz. Versuche
* <- e_it_final_result - Erbebnismenge der parallelen Verarbeitung
* <- e_tasks_started - Anz. gestartete Tasks
* <- e_tasks_ended - Anz. beendete Tasks (sollte im Idealfall
* e_tasks_started entsprechen
* <- e_tasks_missed - Anz. Tasks, die nicht gestartet werden
* konnten
*--------------------------------------------------------------------*
METHOD start_parallel_working.
rv_work_complete = abap_false.
lv_tasks_started = 0.
lv_tasks_ended = 0.
lv_active_tasks = 0.
CLEAR: it_final_result.
CLEAR: it_statistic.
DATA(lv_tasks_missed) = 0.
* Übergebene Workitems abarbeiten
LOOP AT i_it_input_data ASSIGNING FIELD-SYMBOL(<fs_input_data>).
* pro Workitem einen Task (asynchron) starten
IF me->start_task( i_input_data = <fs_input_data>
i_max_retries = i_max_retries ).
ELSE.
* Fehler: kein Task für Workitem verfügbar
lv_tasks_missed = lv_tasks_missed + 1.
APPEND VALUE #( task_number = -1
runtime = 0
retries = i_max_retries
input_data = <fs_input_data>
output_part_size = 0
subrc = -1
successful = abap_false ) TO it_statistic.
ENDIF.
ENDLOOP.
* warten bis alle Tasks fertig sind
WAIT FOR ASYNCHRONOUS TASKS UNTIL ( lv_active_tasks = 0 ) UP TO i_wait_time_sec SECONDS.
IF sy-subrc = 0.
rv_work_complete = abap_true.
ENDIF.
* Ergebnisrückgabe
e_it_final_result = it_final_result.
e_it_statistic = it_statistic.
e_tasks_started = lv_tasks_started.
e_tasks_ended = lv_tasks_ended.
e_tasks_missed = lv_tasks_missed.
ENDMETHOD.
*--------------------------------------------------------------------*
* Gibt Anzahl max. Tasks
*--------------------------------------------------------------------*
* <- rv_max_tasks - Anzahl max. Tasks
*--------------------------------------------------------------------*
METHOD get_max_tasks.
rv_max_tasks = lv_max_tasks.
ENDMETHOD.
*--------------------------------------------------------------------*
* Gibt Anzahl freie Tasks
*--------------------------------------------------------------------*
* <- rv_free_tasks - Anzahl freie Tasks
*--------------------------------------------------------------------*
METHOD get_free_tasks.
rv_free_tasks = lv_free_tasks.
ENDMETHOD.
*--------------------------------------------------------------------*
* Einen Task starten
*--------------------------------------------------------------------*
* -> i_input_data - Eingabedaten für die Verarbeitung
* -> i_wait_time_sec - Wartezeit für Abarbeitung aller Tasks in sec
* -> i_max_retries - max. Anz. Versuche wenn System "busy" bis
* - Abbruch erfolgt
* <- rv_ok - true, wenn Task gestartet werden konnte
*--------------------------------------------------------------------*
METHOD start_task.
rv_ok = abap_false.
DATA(lv_retries) = 0.
* n Neuversuche einen freien Task zu bekommen
WHILE lv_retries < i_max_retries.
DATA(lv_tasknumber) = me->get_free_task( ).
IF lv_tasknumber <> -1.
DATA(o_task) = me->get_task( lv_tasknumber ).
IF o_task IS BOUND.
DATA(lv_subrc) = o_task->start_async_call( i_input_data = i_input_data
i_started_after_n_retries = lv_retries ).
CASE lv_subrc.
WHEN 0.
* Ok
lv_tasks_started = lv_tasks_started + 1.
lv_active_tasks = lv_active_tasks + 1.
lv_retries = i_max_retries.
rv_ok = abap_true.
WHEN 1 OR 2.
* Failure
lv_retries = i_max_retries.
WHEN 3.
* Busy
IF lv_tasks_started > 0.
WAIT FOR ASYNCHRONOUS TASKS UNTIL ( lv_tasks_ended >= lv_tasks_started ) UP TO i_wait_time_sec SECONDS.
ENDIF.
IF sy-subrc = 0.
lv_retries = lv_retries + 1.
ELSE.
lv_retries = i_max_retries.
ENDIF.
WHEN OTHERS.
* Sollte nicht auftreten
lv_retries = i_max_retries.
ENDCASE.
ELSE.
* Task not found (sollte nicht vorkommen)
lv_retries = lv_retries + 1.
ENDIF.
ELSE.
* kein freier Task verfügbar -> warten
WAIT FOR ASYNCHRONOUS TASKS UNTIL ( lv_tasks_ended >= lv_tasks_started ) UP TO i_wait_time_sec SECONDS.
IF sy-subrc = 0.
lv_retries = lv_retries + 1.
ELSE.
lv_retries = i_max_retries.
ENDIF.
ENDIF.
ENDWHILE.
ENDMETHOD.
*--------------------------------------------------------------------*
* Freien Task aus der Liste der verfügbaren suchen
*--------------------------------------------------------------------*
* <- rv_task_number - Tasknummer des gefundenen Tasks
*--------------------------------------------------------------------*
METHOD get_free_task.
rv_task_number = -1.
LOOP AT it_tasks ASSIGNING FIELD-SYMBOL(<fs_task>).
IF <fs_task>-o_task->is_running( ) = abap_false.
rv_task_number = <fs_task>-task_number.
EXIT.
ENDIF.
ENDLOOP.
ENDMETHOD.
*--------------------------------------------------------------------*
* Referenz auf Task anhand der Tasknummer holen
*--------------------------------------------------------------------*
* -> i_task_number - Tasknummer
* <- rv_ref_task - Referenz auf Task
*--------------------------------------------------------------------*
METHOD get_task.
IF line_exists( it_tasks[ task_number = i_task_number ] ).
ASSIGN it_tasks[ task_number = i_task_number ] TO FIELD-SYMBOL(<fs_task>).
IF <fs_task> IS ASSIGNED.
rv_ref_task = <fs_task>-o_task.
ENDIF.
ENDIF.
ENDMETHOD.
*--------------------------------------------------------------------*
* Eventhandler, wenn Task ferig
*--------------------------------------------------------------------*
* -> e_input_data - Eingabedaten des Tasks
* -> e_output_data - Ausgabedaten des Tasks
* -> sender - Referenz auf Task
*--------------------------------------------------------------------*
METHOD on_task_completed.
* Zähler setzen
lv_tasks_ended = lv_tasks_ended + 1.
lv_active_tasks = lv_active_tasks - 1.
APPEND VALUE #( task_number = sender->get_task_number( )
runtime = e_runtime
retries = e_retries
input_data = e_input_data
output_part_size = lines( e_output_data )
subrc = e_subrc
successful = abap_true ) TO it_statistic.
* Hier Daten an Ergebnistabelle einfach anfügen
LOOP AT e_output_data ASSIGNING FIELD-SYMBOL(<fs_output_data>).
APPEND VALUE #( input_data = e_input_data
output_data = <fs_output_data> ) TO it_final_result.
ENDLOOP.
ENDMETHOD.
ENDCLASS.