job_queue_processes参数讲解

 本文转自【乐沙弥的世界】，在此感谢原作者！

Oracle jobs为Oracle开发人员和数据库管理员提供了数据库层面维护的极大便利性。对于Oracle jobs在Oracle 9i之前，是由dbms_jobs来实现，而到了10g之后，多出了dbms_scheduler方式。两者同样可以添加Oracle job，只不过dbms_scheduler的功能更为强大。在使用Oracle jobs时，我们不得不关注job_queue_processes参数，用于设定job队列可以启动的进程数。本文即是围绕此展开。查看该参数命令：

show parameter job;

 

1、job_queue_processes参数

     alter system set job_queue_processes= 0,,,1000

下面是11g reference的描述：
      JOB_QUEUE_PROCESSES specifies the maximum number of job slaves per instance that can be created for the execution of DBMS_JOB jobs and Oracle Scheduler (DBMS_SCHEDULER) jobs. DBMS_JOB and Oracle Scheduler share the same job coordinator and job slaves, and they are both controlled by the JOB_QUEUE_PROCESSES parameter.

      If the value of JOB_QUEUE_PROCESSES is set to 0, then DBMS_JOB jobs and Oracle Scheduler jobs will not run on the instance.If JOB_QUEUE_PROCESSES is set to a value in the range of 1 to 1000, then DBMS_JOB jobs and Oracle Scheduler jobs will run. The actual number of job slaves created for Oracle Scheduler jobs is auto-tuned by the Scheduler depending on several factors, including available resources, Resource Manager settings, and currently running jobs. However, the combined total number of job slaves running DBMS_JOB jobs and Oracle Scheduler jobs on an instance can never exceed the value of JOB_QUEUE_PROCESSES for that instance. The number of job slaves running Oracle Scheduler jobs is additionally limited to the value of the MAX_JOB_SLAVE_PROCESSES Scheduler attribute.

      Advanced replication uses Oracle Scheduler for data refreshes. Oracle Streams Advanced Queuing uses Oracle Scheduler for message propagation. Materialized views use Oracle Scheduler for automatic refreshes. Setting JOB_QUEUE_PROCESS to 0 will disable these features as well as any other features that use Oracle Scheduler or DBMS_JOB.

 

a、从上面的描述可知，对于Oracle job进程，包含协调进程(主进程)以及奴隶进程(子进程)。
b、job_queue_processes取值范围为0到1000，总共可创建多少个job进程由job_queue_processes参数来决定。
c、当job_queue_processes大于1时，且并行执行job时，至少一个为协调进程。其总数不会超出job_queue_processes的值。
d、job_queue_processes参数的值为且DBMS_JOB与DBMS_SCHEDULER共享。
e、job_queue_processes参数，当设定该值为0的时候则任意方式创建的job都不会运行。
f、非零值的job_queue_processes，其job子进程数依赖于可用资源，资源配置方式以及当前运行的job数来自行调整。
g、此外对于Scheduler jobs方式还受限制于scheduler属性MAX_JOB_SLAVE_PROCESSES的设置。
h、可以通过DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE来设置max_job_slave_processes

 

2、测试参数job_queue_processes为1的情形

  1. -->演示环境  
  2. SQL> select * from v$version where rownum<2;  
  3.   
  4. BANNER  
  5. --------------------------------------------------------------------------------  
  6. Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - 64bit Production  
  7.   
  8. -->创建测试用表  
  9. CREATE TABLE tb_job  
  10. (  
  11.    job_name    VARCHAR2 (5),  
  12.    update_dt   VARCHAR2 (20)  
  13. );  
  14.   
  15. -->添加多个Oracle job来并发执行  
  16. SQL> ho more add_job.sql  
  17. DECLARE  
  18.    job_name   VARCHAR2 (20);  
  19. BEGIN  
  20.    DBMS_OUTPUT.put_line ('Current sysdate is ' || TO_CHAR (SYSDATE, 'yyyymmdd hh24:mi:ss'));  
  21.   
  22.    FOR i IN 1 .. 5  
  23.    LOOP  
  24.       job_name := 'JOB_' || TO_CHAR (i);  
  25.       sys.DBMS_SCHEDULER.create_job (  
  26.          job_name          => job_name,  
  27.          start_date        => sysdate+1/1440,  
  28.          repeat_interval   => 'freq = minutely; interval=1',  
  29.          end_date          => NULL,  
  30.          job_class         => 'DEFAULT_JOB_CLASS',  
  31.          job_type          => 'PLSQL_BLOCK',  
  32.          job_action        =>   '    
  33. begin  
  34. INSERT INTO tb_job  
  35.       SELECT '''  
  36.                              || job_name  
  37.                              || ''', TO_CHAR (SYSDATE, ''yyyymmdd hh24:mi:ss'') FROM DUAL;  
  38. dbms_lock.sleep(60);  
  39. commit;  
  40. end;  
  41. ',  
  42.          enabled           => true,  
  43.          comments          => 'my test job');  
  44.    END LOOP;  
  45. END;  
  46. /  
  47.   
  48. SQL> @add_job  
  49.   
  50. PL/SQL procedure successfully completed.  
  51.   
  52. -->查看job_queue_processes参数的值  
  53. SQL> show parameter job  
  54.   
  55. NAME                                 TYPE        VALUE  
  56. ------------------------------------ ----------- ------------------------------  
  57. job_queue_processes                  integer     1  
  58.   
  59. -->此时和Job相关的进程一个，为ora_j000  
  60. SQL> ho ps -ef | grep rac11g | grep ora_j | grep -v grep  
  61. oracle    9692     1  4 12:03 ?        00:00:01 ora_j000_rac11g1  
  62.   
  63. -->查看刚刚添加的job  
  64. -->下面的NEXT_RUN_DATE在秒级别上稍有差异，其实在定义job时，这个是由于前面的for循环造成的延迟  
  65. -->在此忽略这个细微的差异  
  66. SQL> @jobs  
  67.   
  68. OWNER        JOB_NAME       ENABL JOB_CLASS                      NEXT_RUN_DATE  
  69. ------------ -------------- ----- ------------------------------ -----------------------------------  
  70. SCOTT        JOB_1          TRUE  DEFAULT_JOB_CLASS              19-MAR-13 12.21.33.000000 PM +08:00  
  71. SCOTT        JOB_2          TRUE  DEFAULT_JOB_CLASS              19-MAR-13 12.21.33.000000 PM +08:00  
  72. SCOTT        JOB_3          TRUE  DEFAULT_JOB_CLASS              19-MAR-13 12.21.33.000000 PM +08:00  
  73. SCOTT        JOB_4          TRUE  DEFAULT_JOB_CLASS              19-MAR-13 12.21.34.000000 PM +08:00  
  74. SCOTT        JOB_5          TRUE  DEFAULT_JOB_CLASS              19-MAR-13 12.21.34.000000 PM +08:00  
  75.   
  76. -->job执行的情况，可以看到5个job被逐一执行  
  77. -->尽管我们定义时的NEXT_RUN_DATE相差1秒，而此时job的执行后则每一个相差1分钟  
  78. -->job_1与job_5相差4分多钟，这是由于我们定义了dbms_lock.sleep(60)为1分钟  
  79. -->其次可以看出由于只有一个job进程，因此每一个job是一个一个被执行  
  80. SQL> select * from tb_job;  
  81.   
  82. JOB_N UPDATE_DT  
  83. ----- --------------------  
  84. JOB_1 20130319 12:21:33  
  85. JOB_2 20130319 12:22:35  
  86. JOB_3 20130319 12:23:37  
  87. JOB_4 20130319 12:24:39  
  88. JOB_5 20130319 12:25:41  

3、测试参数job_queue_processes大于1的情形

  1. -->首先移除之前的job  
  2. SQL> ho more remove_job.sql  
  3. DECLARE  
  4.    job_name   VARCHAR2 (10);  
  5. BEGIN  
  6.    FOR i IN 1 .. 5  
  7.    LOOP  
  8.       job_name := 'JOB_' || TO_CHAR (i);  
  9.       sys.DBMS_SCHEDULER.drop_job (job_name, force => TRUE);  
  10.    END LOOP;  
  11. END;  
  12. /  
  13.   
  14. SQL> @remove_job  
  15.   
  16. PL/SQL procedure successfully completed.  
  17.   
  18. -->此时设置job_queue_processes的值为6  
  19. SQL> alter system set job_queue_processes=6;  
  20.   
  21. System altered.  
  22.   
  23. -->清空测试用表  
  24. SQL> truncate table tb_job;  
  25.   
  26. Table truncated.  
  27.   
  28. -->此时Oracle为job启动了2个进程  
  29. SQL> ho ps -ef | grep rac11g | grep ora_j | grep -v grep  
  30. oracle    3477     1  9 12:29 ?        00:00:01 ora_j000_rac11g1  
  31. oracle    3491     1  4 12:29 ?        00:00:00 ora_j001_rac11g1  
  32.   
  33. -->添加多个job  
  34. SQL> @add_job  
  35.   
  36. PL/SQL procedure successfully completed.  
  37.   
  38. --> Author : Robinson  
  39. --> Blog   : http://blog.csdn.net/robinson_0612  
  40.   
  41. SQL> @jobs  
  42.   
  43. OWNER                JOB_NAME    ENABL JOB_CLASS             NEXT_RUN_DATE  
  44. -------------------- ----------- ----- --------------------- -----------------------------------  
  45. SCOTT                JOB_1       TRUE  DEFAULT_JOB_CLASS     19-MAR-13 12.31.55.000000 PM +08:00  
  46. SCOTT                JOB_2       TRUE  DEFAULT_JOB_CLASS     19-MAR-13 12.31.56.000000 PM +08:00  
  47. SCOTT                JOB_3       TRUE  DEFAULT_JOB_CLASS     19-MAR-13 12.31.56.000000 PM +08:00  
  48. SCOTT                JOB_4       TRUE  DEFAULT_JOB_CLASS     19-MAR-13 12.31.56.000000 PM +08:00  
  49. SCOTT                JOB_5       TRUE  DEFAULT_JOB_CLASS     19-MAR-13 12.31.56.000000 PM +08:00  
  50.   
  51. -->片刻后可以看到job进程总数达到6个  
  52. SQL> ho ps -ef | grep rac11g | grep ora_j | grep -v grep  
  53. oracle    7668     1  1 11:57 ?        00:00:01 ora_j000_rac11g1  
  54. oracle    7678     1  0 11:57 ?        00:00:01 ora_j001_rac11g1  
  55. oracle    7700     1  1 11:57 ?        00:00:01 ora_j002_rac11g1  
  56. oracle    9230     1  0 11:57 ?        00:00:00 ora_j003_rac11g1  
  57. oracle    9257     1  2 11:58 ?        00:00:01 ora_j005_rac11g1  
  58. oracle    9353     1  7 11:59 ?        00:00:00 ora_j004_rac11g1            
  59.   
  60. -->查看表tb_job的情形                     
  61. SQL> select * from tb_job order by 1,2;  
  62.   
  63. JOB_N UPDATE_DT  
  64. ----- --------------------  
  65. JOB_1 20130319 12:31:57  
  66. JOB_1 20130319 12:32:58  
  67. JOB_1 20130319 12:33:59  
  68. JOB_2 20130319 12:31:58  
  69. JOB_2 20130319 12:32:59  
  70. JOB_2 20130319 12:34:00  
  71. JOB_3 20130319 12:31:58  
  72. JOB_3 20130319 12:32:59  
  73. JOB_3 20130319 12:34:00  
  74. JOB_4 20130319 12:31:59  
  75. JOB_4 20130319 12:33:00  
  76. JOB_4 20130319 12:34:01  
  77. JOB_5 20130319 12:31:58  
  78. JOB_5 20130319 12:32:59  
  79. JOB_5 20130319 12:34:00  
  80.   
  81. -->从上面的查询结果可知每一个job的上一次与下一次执行间隔基本保持在1分钟  
  82. -->不同job之间的每一次执行时间基本上是相同的，这与job_queue_processes为1时完全不一样  
  83. -->也就是说即使是job_5，基本上与job_1是同时执行，而不是像前面测试那样前面所有的执行完后才被执行  
  84.   
  85. -->移除job  
  86. SQL> @remove_job  
  87.   
  88. PL/SQL procedure successfully completed.  
  89.   
  90. -->移除测试表  
  91. SQL> drop table tb_job purge;  
  92.   
  93. Table dropped.  

4、小结
a、job_queue_processes参数决定了job作业能够使用的总进程数。
b、当该参数为0值，任何job都不会被执行，建议合理设置该值且至少大于1。
c、对于job运行时间也应该尽量合理的设置间隔以及启动时间。
d、如果同一时间内运行的Job数很多，过小的参数值导致job不得不进行等待。而过大的参数值则消耗更多的系统资源。
f、对于存在依赖关系的job，尽可能将其进行合并到一个job中，如使用chain等。