☰

concurrent_promise

Parallel processing module for JavaScript that can specify the number of concurrent executions.

此腳本不應該直接安裝，它是一個供其他腳本使用的函式庫。欲使用本函式庫，請在腳本 metadata 寫上： // @require https://update.greatest.deepsurf.us/scripts/398566/785036/concurrent_promise.js 

  1. ( ( exports ) => {
  2. 'use strict';
  3.  
  4. const
  5.     version = '1.0.1',
  6.     
  7.     execute = async ( promise_functions, max_concurrent_worker = 10 ) => {
  8.         let concurrent_workers = Array( max_concurrent_worker ).fill( null ),
  9.             waiting_worker_queue = [],
  10.             success_list = [],
  11.             failure_list = [],
  12.             
  13.             log_debug = ( header ) => {
  14.                 if ( ! exports.debug_mode ) {
  15.                     return;
  16.                 }
  17.                 if ( header ) {
  18.                     console.log( header );
  19.                 }
  20.                 console.log( '- concurrent_workers:', concurrent_workers );
  21.                 console.log( '- waiting_worker_queue:', waiting_worker_queue );
  22.                 console.log( '- success_list:', success_list );
  23.                 console.log( '- failure_list:', failure_list );
  24.             },
  25.             
  26.             attempt_work_delegation = () => {
  27.                 log_debug( '*** attempt_work_delegation()' );
  28.                 
  29.                 if ( waiting_worker_queue.length <= 0 ) {
  30.                     return;
  31.                 }
  32.                 
  33.                 let target_worker_id = -1;
  34.                 
  35.                 for ( let worker_id = 0; worker_id < concurrent_workers.length; worker_id ++ ) {
  36.                     if ( ! concurrent_workers[ worker_id ] ) {
  37.                         target_worker_id = worker_id;
  38.                         break;
  39.                     }
  40.                 }
  41.                 
  42.                 if ( target_worker_id < 0 ) {
  43.                     return;
  44.                 }
  45.                 
  46.                 let target_worker = concurrent_workers[ target_worker_id ] = waiting_worker_queue.shift(),
  47.                     target_promise = target_worker.promise = target_worker.promise_function(),
  48.                     
  49.                     finish = ( is_success, result ) => {
  50.                         target_worker.is_success = is_success;
  51.                         target_worker.result = result;
  52.                         ( is_success ? success_list : failure_list ).push( target_worker );
  53.                         target_worker.resolve( result );
  54.                         concurrent_workers[ target_worker_id ] = null;
  55.                         attempt_work_delegation();
  56.                     };
  57.                 
  58.                 target_worker.worker_id = target_worker_id;
  59.                 
  60.                 target_promise
  61.                 .then( ( result ) => {
  62.                     finish( true, result );
  63.                 } )
  64.                 .catch( ( result ) => {
  65.                     finish( false, result );
  66.                 } );
  67.             },
  68.             
  69.             add_worker = ( worker ) => {
  70.                 waiting_worker_queue.push( worker );
  71.                 attempt_work_delegation();
  72.             },
  73.             
  74.             wrap_promise_function = ( promise_function, call_index ) => {
  75.                 return new Promise( ( resolve, reject ) => {
  76.                     add_worker( {
  77.                         call_index : call_index,
  78.                         promise_function : promise_function,
  79.                         resolve : resolve,
  80.                         reject : reject,
  81.                     } );
  82.                 } );
  83.             },
  84.             
  85.             promise_results = await Promise.all( promise_functions.map( ( promise_function, call_index ) => wrap_promise_function( promise_function, call_index ) ) );
  86.         
  87.         success_list.sort( ( a, b ) => a.call_index - b.call_index );
  88.         failure_list.sort( ( a, b ) => a.call_index - b.call_index );
  89.         
  90.         log_debug( '*** concurrent_executor() : end' );
  91.         
  92.         let result_info = {
  93.                 promise_results : promise_results,
  94.                 success_list : success_list,
  95.                 failure_list : failure_list,
  96.             };
  97.         
  98.         if ( exports.debug_mode ) {
  99.             Object.assign( result_info, {
  100.                 waiting_worker_queue : waiting_worker_queue,
  101.                 concurrent_workers : concurrent_workers,
  102.             } );
  103.         }
  104.         
  105.         return result_info;
  106.     };
  107.  
  108. Object.assign( exports, {
  109.     version : version,
  110.     execute : execute,
  111.     debug_mode : false,
  112. } );
  113.  
  114. } )( ( typeof exports != 'undefined' ) ? exports : ( ( typeof window != 'undefined' ) ? window : this )[ 'concurrent_promise' ] = {} );