['   \n  \n [ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ? ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?\', "ਨਹੀਂ, ਮੈਂ ਇਹ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ-ਪੱਧਰ ਨੰਬਰ ਹੈ।ਇੱਕ ਪ੍ਰਕਿਰਿਆ-ਪੱਧਰੀ ਨੰਬਰ ਦਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਥਰਿੱਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਕਿਸੇ ਵੀ ਸਮੇਂ CPU ਉੱਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਲਈ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਇਸ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।10 ਸਕਿੰਟਾਂ ਲਈ CPU, ਜਦੋਂ ਕਿ ਦੂਜਾ ਥਰਿੱਡ ਬੇਕਾਰ ਹੈ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਹੋਵੇਗਾ, 5 ਸਕਿੰਟ ਨਹੀਂ (ਦੁਆਰਾ ਬਿਤਾਏ ਗਏ ਸਮੇਂ ਦਾ ਅੱਧਾ ਹਿੱਸਾ)ਸਰਗਰਮ ਥਰਿੱਡ). \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।CPU ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। \\n\\nI ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਹੋਰ ਪ੍ਰਸ਼ਨ ਹਨ! ",\'ਨਾਮ _ 1 ਉਸ ਮਾਮਲੇ ਵਿੱਚ, ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਥਰਿੱਡ ਨਾਮ _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲਦੀ ਰਹਿੰਦੀ ਹੈ, ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਅਜੇ ਵੀ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ, ਠੀਕ ਹੈ?ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਨੰਬਰ \'] ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?\', "ਨਹੀਂ, ਮੈਂ ਇਹ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ-ਪੱਧਰ ਨੰਬਰ ਹੈ।ਇੱਕ ਪ੍ਰਕਿਰਿਆ-ਪੱਧਰੀ ਨੰਬਰ ਦਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਥਰਿੱਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਕਿਸੇ ਵੀ ਸਮੇਂ CPU ਉੱਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਲਈ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਇਸ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।10 ਸਕਿੰਟਾਂ ਲਈ CPU, ਜਦੋਂ ਕਿ ਦੂਜਾ ਥਰਿੱਡ ਬੇਕਾਰ ਹੈ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਹੋਵੇਗਾ, 5 ਸਕਿੰਟ ਨਹੀਂ (ਦੁਆਰਾ ਬਿਤਾਏ ਗਏ ਸਮੇਂ ਦਾ ਅੱਧਾ ਹਿੱਸਾ)ਸਰਗਰਮ ਥਰਿੱਡ). \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।CPU ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। \\n\\nI ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਹੋਰ ਪ੍ਰਸ਼ਨ ਹਨ! ",\'ਨਾਮ _ 1 ਉਸ ਮਾਮਲੇ ਵਿੱਚ, ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਥਰਿੱਡ ਨਾਮ _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲਦੀ ਰਹਿੰਦੀ ਹੈ, ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਅਜੇ ਵੀ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ, ਠੀਕ ਹੈ?ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਨੰਬਰ \', "ਹਾਂ, ਇਹ ਸਹੀ ਹੈ! ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦੇਵੇ, ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਜਾਰੀ ਰਹੇਗਾਇਹ ਉਦੋਂ ਤੱਕ ਵਧਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰ ਰਹੀ ਹੈ। \\n\\n ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈਪ੍ਰਕਿਰਿਆ ਦਾ ਪੱਧਰ, ਅਤੇ ਇਹ ਕੁੱਲ ਸਮਾਂ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੇ ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਇਆ ਹੈ। ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਚਲਾਉਂਦੇ ਹੋਏ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਤੁਰੰਤ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ CPU ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ।ਸਰੋਤ. \\n\\n ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਵਧਦਾ ਰਹੇਗਾ ਜਿਵੇਂ ਕਿਹੋਰ ਥਰਿੱਡ ਚਲਾਉਣਾ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ। CPU ਸਮਾਂ ਉਦੋਂ ਤੱਕ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ ਜਦੋਂ ਤੱਕ ਦੋਵੇਂ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਨਹੀਂ ਕਰਦੇ। \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿCPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਸਿੰਗਲ ਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਹੁੰਦਾ ਹੈਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ, ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਮਾਪ ਹੈ ਜੋ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਹੈਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ \'ਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।\', \'ਫਿਰ ਤੁਸੀਂ ਕਿਉਂ ਕਿਹਾ ਕਿ ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ\'] ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?\', "ਨਹੀਂ, ਮੈਂ ਇਹ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ-ਪੱਧਰ ਨੰਬਰ ਹੈ।ਇੱਕ ਪ੍ਰਕਿਰਿਆ-ਪੱਧਰੀ ਨੰਬਰ ਦਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਥਰਿੱਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਕਿਸੇ ਵੀ ਸਮੇਂ CPU ਉੱਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਲਈ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਇਸ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।10 ਸਕਿੰਟਾਂ ਲਈ CPU, ਜਦੋਂ ਕਿ ਦੂਜਾ ਥਰਿੱਡ ਬੇਕਾਰ ਹੈ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਹੋਵੇਗਾ, 5 ਸਕਿੰਟ ਨਹੀਂ (ਦੁਆਰਾ ਬਿਤਾਏ ਗਏ ਸਮੇਂ ਦਾ ਅੱਧਾ ਹਿੱਸਾ)ਸਰਗਰਮ ਥਰਿੱਡ). \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।CPU ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। \\n\\nI ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਹੋਰ ਪ੍ਰਸ਼ਨ ਹਨ! ",\'ਨਾਮ _ 1 ਉਸ ਮਾਮਲੇ ਵਿੱਚ, ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਥਰਿੱਡ ਨਾਮ _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲਦੀ ਰਹਿੰਦੀ ਹੈ, ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਅਜੇ ਵੀ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ, ਠੀਕ ਹੈ?ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਨੰਬਰ \', "ਹਾਂ, ਇਹ ਸਹੀ ਹੈ! ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦੇਵੇ, ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਜਾਰੀ ਰਹੇਗਾਇਹ ਉਦੋਂ ਤੱਕ ਵਧਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰ ਰਹੀ ਹੈ। \\n\\n ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈਪ੍ਰਕਿਰਿਆ ਦਾ ਪੱਧਰ, ਅਤੇ ਇਹ ਕੁੱਲ ਸਮਾਂ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੇ ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਇਆ ਹੈ। ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਚਲਾਉਂਦੇ ਹੋਏ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਤੁਰੰਤ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ CPU ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ।ਸਰੋਤ. \\n\\n ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਵਧਦਾ ਰਹੇਗਾ ਜਿਵੇਂ ਕਿਹੋਰ ਥਰਿੱਡ ਚਲਾਉਣਾ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ। CPU ਸਮਾਂ ਉਦੋਂ ਤੱਕ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ ਜਦੋਂ ਤੱਕ ਦੋਵੇਂ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਨਹੀਂ ਕਰਦੇ। \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿCPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਸਿੰਗਲ ਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਹੁੰਦਾ ਹੈਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ, ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਮਾਪ ਹੈ ਜੋ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਹੈਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ \'ਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।\', \'ਫਿਰ ਤੁਸੀਂ ਕਿਉਂ ਕਿਹਾ ਕਿ ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਸੀ. ਪੀ. ਯੂ. ਦਾ ਸਮਾਂ ਨਹੀਂ ਵਧਾਉਂਦਾ\', \'ਤੁਸੀਂ ਸਹੀ ਹੋ, ਅਤੇ ਮੈਂ ਇਸ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ।ਉਲਝਣ. ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਇਹ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ। CPU ਸਮਾਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਸਮੇਂ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਦੁਆਰਾ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਚੱਲ ਨਹੀਂ ਰਹੇ ਹਨ। \\n\\nਜਬ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਇਸ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋਏ, ਇਹ ਕਿਸੇ ਵੀ CPU ਸਰੋਤ ਨੂੰ ਜਾਰੀ ਕਰਦਾ ਹੈ ਜੋ ਇਹ ਵਰਤ ਰਿਹਾ ਸੀ, ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਉਹਨਾਂ ਸਰੋਤਾਂ ਨੂੰ ਹੋਰ ਥਰਿੱਡਾਂ ਜਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਹਨਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹੈ। ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਲਈ NAME _ 1 CPU ਸਮੇਂ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਹੋਰ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ ਜਾਂਪ੍ਰਕਿਰਿਆਵਾਂ। \\n\\n ਮੇਰੀ ਗਲਤੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਤੁਹਾਡਾ ਧੰਨਵਾਦ। ਮੈਂ ਭਵਿੱਖ ਵਿੱਚ ਆਪਣੇ ਜਵਾਬਾਂ ਦੇ ਨਾਮ ਬਾਰੇ ਵਧੇਰੇ ਸਾਵਧਾਨ ਰਹਾਂਗਾ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਉਹ ਸਹੀ ਅਤੇ ਸਹੀ ਹਨ।", \'ਕੀ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੋਵਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ?\' ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?\', "ਨਹੀਂ, ਮੈਂ ਇਹ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ-ਪੱਧਰ ਨੰਬਰ ਹੈ।ਇੱਕ ਪ੍ਰਕਿਰਿਆ-ਪੱਧਰੀ ਨੰਬਰ ਦਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਥਰਿੱਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਕਿਸੇ ਵੀ ਸਮੇਂ CPU ਉੱਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਲਈ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਇਸ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।10 ਸਕਿੰਟਾਂ ਲਈ CPU, ਜਦੋਂ ਕਿ ਦੂਜਾ ਥਰਿੱਡ ਬੇਕਾਰ ਹੈ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਹੋਵੇਗਾ, 5 ਸਕਿੰਟ ਨਹੀਂ (ਦੁਆਰਾ ਬਿਤਾਏ ਗਏ ਸਮੇਂ ਦਾ ਅੱਧਾ ਹਿੱਸਾ)ਸਰਗਰਮ ਥਰਿੱਡ). \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।CPU ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। \\n\\nI ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਹੋਰ ਪ੍ਰਸ਼ਨ ਹਨ! ",\'ਨਾਮ _ 1 ਉਸ ਮਾਮਲੇ ਵਿੱਚ, ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਥਰਿੱਡ ਨਾਮ _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲਦੀ ਰਹਿੰਦੀ ਹੈ, ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਅਜੇ ਵੀ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ, ਠੀਕ ਹੈ?ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਨੰਬਰ \', "ਹਾਂ, ਇਹ ਸਹੀ ਹੈ! ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦੇਵੇ, ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਜਾਰੀ ਰਹੇਗਾਇਹ ਉਦੋਂ ਤੱਕ ਵਧਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰ ਰਹੀ ਹੈ। \\n\\n ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈਪ੍ਰਕਿਰਿਆ ਦਾ ਪੱਧਰ, ਅਤੇ ਇਹ ਕੁੱਲ ਸਮਾਂ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੇ ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਇਆ ਹੈ। ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਚਲਾਉਂਦੇ ਹੋਏ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਤੁਰੰਤ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ CPU ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ।ਸਰੋਤ. \\n\\n ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਵਧਦਾ ਰਹੇਗਾ ਜਿਵੇਂ ਕਿਹੋਰ ਥਰਿੱਡ ਚਲਾਉਣਾ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ। CPU ਸਮਾਂ ਉਦੋਂ ਤੱਕ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ ਜਦੋਂ ਤੱਕ ਦੋਵੇਂ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਨਹੀਂ ਕਰਦੇ। \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿCPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਸਿੰਗਲ ਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਹੁੰਦਾ ਹੈਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ, ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਮਾਪ ਹੈ ਜੋ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਹੈਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ \'ਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।\', \'ਫਿਰ ਤੁਸੀਂ ਕਿਉਂ ਕਿਹਾ ਕਿ ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਸੀ. ਪੀ. ਯੂ. ਦਾ ਸਮਾਂ ਨਹੀਂ ਵਧਾਉਂਦਾ\', \'ਤੁਸੀਂ ਸਹੀ ਹੋ, ਅਤੇ ਮੈਂ ਇਸ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ।ਉਲਝਣ. ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਇਹ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ। CPU ਸਮਾਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਸਮੇਂ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਦੁਆਰਾ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਚੱਲ ਨਹੀਂ ਰਹੇ ਹਨ। \\n\\nਜਬ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਇਸ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋਏ, ਇਹ ਕਿਸੇ ਵੀ CPU ਸਰੋਤ ਨੂੰ ਜਾਰੀ ਕਰਦਾ ਹੈ ਜੋ ਇਹ ਵਰਤ ਰਿਹਾ ਸੀ, ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਉਹਨਾਂ ਸਰੋਤਾਂ ਨੂੰ ਹੋਰ ਥਰਿੱਡਾਂ ਜਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਹਨਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹੈ। ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਲਈ NAME _ 1 CPU ਸਮੇਂ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਹੋਰ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ ਜਾਂਪ੍ਰਕਿਰਿਆਵਾਂ। \\n\\n ਮੇਰੀ ਗਲਤੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਤੁਹਾਡਾ ਧੰਨਵਾਦ। ਮੈਂ ਭਵਿੱਖ ਵਿੱਚ ਆਪਣੇ ਜਵਾਬਾਂ ਦੇ ਨਾਮ ਬਾਰੇ ਵਧੇਰੇ ਸਾਵਧਾਨ ਰਹਾਂਗਾ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਉਹ ਸਹੀ ਅਤੇ ਸਹੀ ਹਨ।\',\' ਕੀ ਸੀਪੀਯੂ ਟਾਈਮ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੋਵਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ? \',\' ਹਾਂ, ਸੀਪੀਯੂ ਟਾਈਮ ਨੂੰ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਥਰਿੱਡ ਪੱਧਰ ਦੋਵਾਂ \'ਤੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ। \\n\\n ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ, CPU ਸਮਾਂ ਹਰੇਕ ਥਰਿੱਡ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ ਜੋ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾ ਰਿਹਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਹੈਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ NAME _ 1 ਘਡ਼ੀ ਚੱਕਰ ਜਾਂ ਸਕਿੰਟਾਂ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।\'Thread.getCPUTime ()\' ਵਿਧੀ ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਉੱਤੇ, ਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਹੈਸਾਰੇ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਦਾ ਜੋਡ਼ NAME _ 1 ਪ੍ਰਕਿਰਿਆ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ \'Process.get CPUTine ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਸਮਾਂ ਕੰਧ ਘਡ਼ੀ ਸਮੇਂ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। CPU ਸਮਾਂ CPU ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਨਿਰਦੇਸ਼ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆ ਦੇ ਲਾਗੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘ ਗਿਆ ਹੈ। CPU ਸਮਾਂ ਹੈਪ੍ਰਕਿਰਿਆ ਨੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਇੱਕ ਵਧੇਰੇ ਸਹੀ ਮਾਪ, ਪਰ ਇਸ ਵਿੱਚ I/O ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਿਤਾਇਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਜਾਂ ਹੋਰ ਘਟਨਾਵਾਂ। \\n\\nਅਤੇ, ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ CPU ਸਮਾਂ CPU ਕੋਰਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਹੋ ਸਕਦਾ ਹੈ। ਮਲਟੀ-ਕੋਰ ਸਿਸਟਮਾਂ ਉੱਤੇ,ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਕਈ ਕੋਰਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਕੋਰ ਲਈ ਅਸਲ CPU ਸਮਾਂ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਨਾਲ ਸਿਸਟਮ ਉੱਤੇਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ, ਹਰੇਕ ਕੋਰ ਵਿੱਚ ਮਲਟੀਪਲ ਥਰਿੱਡ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਲਈ CPU ਟਾਈਮ ਨੂੰ ਮਲਟੀਪਲ CPU ਕੋਰ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਦੋਵਾਂ ਨੂੰ ਮਾਪਣ ਲਈ] ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?\', "ਨਹੀਂ, ਮੈਂ ਇਹ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ-ਪੱਧਰ ਨੰਬਰ ਹੈ।ਇੱਕ ਪ੍ਰਕਿਰਿਆ-ਪੱਧਰੀ ਨੰਬਰ ਦਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਥਰਿੱਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਕਿਸੇ ਵੀ ਸਮੇਂ CPU ਉੱਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਲਈ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਇਸ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।10 ਸਕਿੰਟਾਂ ਲਈ CPU, ਜਦੋਂ ਕਿ ਦੂਜਾ ਥਰਿੱਡ ਬੇਕਾਰ ਹੈ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਹੋਵੇਗਾ, 5 ਸਕਿੰਟ ਨਹੀਂ (ਦੁਆਰਾ ਬਿਤਾਏ ਗਏ ਸਮੇਂ ਦਾ ਅੱਧਾ ਹਿੱਸਾ)ਸਰਗਰਮ ਥਰਿੱਡ). \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।CPU ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। \\n\\nI ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਹੋਰ ਪ੍ਰਸ਼ਨ ਹਨ! ",\'ਨਾਮ _ 1 ਉਸ ਮਾਮਲੇ ਵਿੱਚ, ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਥਰਿੱਡ ਨਾਮ _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲਦੀ ਰਹਿੰਦੀ ਹੈ, ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਅਜੇ ਵੀ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ, ਠੀਕ ਹੈ?ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਨੰਬਰ \', "ਹਾਂ, ਇਹ ਸਹੀ ਹੈ! ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦੇਵੇ, ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਜਾਰੀ ਰਹੇਗਾਇਹ ਉਦੋਂ ਤੱਕ ਵਧਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰ ਰਹੀ ਹੈ। \\n\\n ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈਪ੍ਰਕਿਰਿਆ ਦਾ ਪੱਧਰ, ਅਤੇ ਇਹ ਕੁੱਲ ਸਮਾਂ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੇ ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਇਆ ਹੈ। ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਚਲਾਉਂਦੇ ਹੋਏ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਤੁਰੰਤ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ CPU ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ।ਸਰੋਤ. \\n\\n ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਵਧਦਾ ਰਹੇਗਾ ਜਿਵੇਂ ਕਿਹੋਰ ਥਰਿੱਡ ਚਲਾਉਣਾ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ। CPU ਸਮਾਂ ਉਦੋਂ ਤੱਕ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ ਜਦੋਂ ਤੱਕ ਦੋਵੇਂ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਨਹੀਂ ਕਰਦੇ। \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿCPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਸਿੰਗਲ ਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਹੁੰਦਾ ਹੈਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ, ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਮਾਪ ਹੈ ਜੋ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਹੈਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ \'ਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।\', \'ਫਿਰ ਤੁਸੀਂ ਕਿਉਂ ਕਿਹਾ ਕਿ ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਸੀ. ਪੀ. ਯੂ. ਦਾ ਸਮਾਂ ਨਹੀਂ ਵਧਾਉਂਦਾ\', \'ਤੁਸੀਂ ਸਹੀ ਹੋ, ਅਤੇ ਮੈਂ ਇਸ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ।ਉਲਝਣ. ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਇਹ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ। CPU ਸਮਾਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਸਮੇਂ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਦੁਆਰਾ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਚੱਲ ਨਹੀਂ ਰਹੇ ਹਨ। \\n\\nਜਬ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਇਸ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋਏ, ਇਹ ਕਿਸੇ ਵੀ CPU ਸਰੋਤ ਨੂੰ ਜਾਰੀ ਕਰਦਾ ਹੈ ਜੋ ਇਹ ਵਰਤ ਰਿਹਾ ਸੀ, ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਉਹਨਾਂ ਸਰੋਤਾਂ ਨੂੰ ਹੋਰ ਥਰਿੱਡਾਂ ਜਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਹਨਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹੈ। ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਲਈ NAME _ 1 CPU ਸਮੇਂ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਹੋਰ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ ਜਾਂਪ੍ਰਕਿਰਿਆਵਾਂ। \\n\\n ਮੇਰੀ ਗਲਤੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਤੁਹਾਡਾ ਧੰਨਵਾਦ। ਮੈਂ ਭਵਿੱਖ ਵਿੱਚ ਆਪਣੇ ਜਵਾਬਾਂ ਦੇ ਨਾਮ ਬਾਰੇ ਵਧੇਰੇ ਸਾਵਧਾਨ ਰਹਾਂਗਾ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਉਹ ਸਹੀ ਅਤੇ ਸਹੀ ਹਨ।\',\' ਕੀ ਸੀਪੀਯੂ ਟਾਈਮ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੋਵਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ? \',\' ਹਾਂ, ਸੀਪੀਯੂ ਟਾਈਮ ਨੂੰ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਥਰਿੱਡ ਪੱਧਰ ਦੋਵਾਂ \'ਤੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ। \\n\\n ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ, CPU ਸਮਾਂ ਹਰੇਕ ਥਰਿੱਡ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ ਜੋ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾ ਰਿਹਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਹੈਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ NAME _ 1 ਘਡ਼ੀ ਚੱਕਰ ਜਾਂ ਸਕਿੰਟਾਂ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।\'Thread.getCPUTime ()\' ਵਿਧੀ ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਉੱਤੇ, ਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਹੈਸਾਰੇ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਦਾ ਜੋਡ਼ NAME _ 1 ਪ੍ਰਕਿਰਿਆ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ \'Process.get CPUTine ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਸਮਾਂ ਕੰਧ ਘਡ਼ੀ ਸਮੇਂ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। CPU ਸਮਾਂ CPU ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਨਿਰਦੇਸ਼ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆ ਦੇ ਲਾਗੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘ ਗਿਆ ਹੈ। CPU ਸਮਾਂ ਹੈਪ੍ਰਕਿਰਿਆ ਨੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਇੱਕ ਵਧੇਰੇ ਸਹੀ ਮਾਪ, ਪਰ ਇਸ ਵਿੱਚ I/O ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਿਤਾਇਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਜਾਂ ਹੋਰ ਘਟਨਾਵਾਂ। \\n\\nਅਤੇ, ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ CPU ਸਮਾਂ CPU ਕੋਰਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਹੋ ਸਕਦਾ ਹੈ। ਮਲਟੀ-ਕੋਰ ਸਿਸਟਮਾਂ ਉੱਤੇ,ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਕਈ ਕੋਰਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਕੋਰ ਲਈ ਅਸਲ CPU ਸਮਾਂ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਨਾਲ ਸਿਸਟਮ ਉੱਤੇਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ, ਹਰੇਕ ਕੋਰ ਵਿੱਚ ਮਲਟੀਪਲ ਥਰਿੱਡ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਲਈ CPU ਟਾਈਮ ਨੂੰ ਮਲਟੀਪਲ CPU ਕੋਰ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਦੋਵੇਂ \',\' ਨਾਮ _ 1 ਨਾਮ _ 3 ਨੂੰ ਮਾਪਣ ਲਈ, ਤੁਸੀਂ \'os\' ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ CPU ਟਾਈਮ ਅਤੇ ਵਾਲ ਘਡ਼ੀ ਟਾਈਮ ਦੋਵਾਂ ਨੂੰ ਮਾਪ ਸਕਦੇ ਹੋ।\'os.clock ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜੋ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਮਾਪCPU ਟਾਈਮ ਜਿੰਨਾ ਸਟੀਕ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਇਹ I/O ਓਪਰੇਸ਼ਨਾਂ ਜਾਂ ਹੋਰ ਘਟਨਾਵਾਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਲੇਖਾ ਜੋਖਾ ਨਹੀਂ ਕਰਦਾ ਹੈ। \\n\\n ਕੰਧ ਘਡ਼ੀ ਨੂੰ ਮਾਪਣ ਲਈਇਸ ਸਮੇਂ, ਤੁਸੀਂ \'os.time ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਯੂਨਿਕਸ ਯੁੱਗ (1 ਜਨਵਰੀ, 1970,00:00:00) ਤੋਂ ਮੌਜੂਦਾ ਸਮੇਂ NAME _ 1 ਸਕਿੰਟ ਨਾਲ ਇੱਕ ਟੇਬਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ CPU ਟਾਈਮ ਅਤੇ ਵਾਲ ਕਲੌਕ ਟਾਈਮ ਦੋਵਾਂ ਨੂੰ ਮਾਪਣ ਲਈ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋ NAME _ 1 NAME _ 3: \\n "\\n-- CPU ਨੂੰ ਮਾਪੋਟਾਈਮ\\ਨਲੋਕਲ ਸਟਾਰਟ _ ਟਾਈਮ = os.clock () \\n-- ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ\\ਨਲੋਕਲ ਈਲੈਪਸਡ _ ਟਾਈਮ = os.clock ()-ਸਟਾਰਟ _ ਟਾਈਮ\\ਨਪ੍ਰਿੰਟ ("CPU ਟਾਈਮਃ", ਈਲੈਪਸਡ _ ਟਾਈਮ) \\n\\n-- -ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ ਮਾਪੋ-ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ-\\nlokal elapsed _ ਸਮਯ = os.time ()-ਸਟਾਰਟ _ ਟਾਈਮ\\nਪ੍ਰਿੰਟ ("ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂਃ",\'os.clock ()\' ਫੰਕਸ਼ਨ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ \'os.time ()\'ਫੰਕਸ਼ਨ ਯੂਨਿਕਸ ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਤੁਹਾਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ \'os.time ()\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਸਮੇਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸਹੀ ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ. \',\' ਮੇਰਾ ਮਤਲਬ ਹੈ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਅਤੇ ਥਰਿੱਡ ਦੇ ਪੱਧਰ ਨੂੰ ਮਾਪਣਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ \'] ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?\', "ਨਹੀਂ, ਮੈਂ ਇਹ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ-ਪੱਧਰ ਨੰਬਰ ਹੈ।ਇੱਕ ਪ੍ਰਕਿਰਿਆ-ਪੱਧਰੀ ਨੰਬਰ ਦਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਥਰਿੱਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਕਿਸੇ ਵੀ ਸਮੇਂ CPU ਉੱਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਲਈ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਇਸ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।10 ਸਕਿੰਟਾਂ ਲਈ CPU, ਜਦੋਂ ਕਿ ਦੂਜਾ ਥਰਿੱਡ ਬੇਕਾਰ ਹੈ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਹੋਵੇਗਾ, 5 ਸਕਿੰਟ ਨਹੀਂ (ਦੁਆਰਾ ਬਿਤਾਏ ਗਏ ਸਮੇਂ ਦਾ ਅੱਧਾ ਹਿੱਸਾ)ਸਰਗਰਮ ਥਰਿੱਡ). \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।CPU ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। \\n\\nI ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਹੋਰ ਪ੍ਰਸ਼ਨ ਹਨ! ",\'ਨਾਮ _ 1 ਉਸ ਮਾਮਲੇ ਵਿੱਚ, ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਥਰਿੱਡ ਨਾਮ _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲਦੀ ਰਹਿੰਦੀ ਹੈ, ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਅਜੇ ਵੀ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ, ਠੀਕ ਹੈ?ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਨੰਬਰ \', "ਹਾਂ, ਇਹ ਸਹੀ ਹੈ! ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦੇਵੇ, ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਜਾਰੀ ਰਹੇਗਾਇਹ ਉਦੋਂ ਤੱਕ ਵਧਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰ ਰਹੀ ਹੈ। \\n\\n ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈਪ੍ਰਕਿਰਿਆ ਦਾ ਪੱਧਰ, ਅਤੇ ਇਹ ਕੁੱਲ ਸਮਾਂ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੇ ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਇਆ ਹੈ। ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਚਲਾਉਂਦੇ ਹੋਏ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਤੁਰੰਤ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ CPU ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ।ਸਰੋਤ. \\n\\n ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਵਧਦਾ ਰਹੇਗਾ ਜਿਵੇਂ ਕਿਹੋਰ ਥਰਿੱਡ ਚਲਾਉਣਾ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ। CPU ਸਮਾਂ ਉਦੋਂ ਤੱਕ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ ਜਦੋਂ ਤੱਕ ਦੋਵੇਂ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਨਹੀਂ ਕਰਦੇ। \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿCPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਸਿੰਗਲ ਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਹੁੰਦਾ ਹੈਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ, ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਮਾਪ ਹੈ ਜੋ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਹੈਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ \'ਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।\', \'ਫਿਰ ਤੁਸੀਂ ਕਿਉਂ ਕਿਹਾ ਕਿ ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਸੀ. ਪੀ. ਯੂ. ਦਾ ਸਮਾਂ ਨਹੀਂ ਵਧਾਉਂਦਾ\', \'ਤੁਸੀਂ ਸਹੀ ਹੋ, ਅਤੇ ਮੈਂ ਇਸ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ।ਉਲਝਣ. ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਇਹ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ। CPU ਸਮਾਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਸਮੇਂ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਦੁਆਰਾ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਚੱਲ ਨਹੀਂ ਰਹੇ ਹਨ। \\n\\nਜਬ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਇਸ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋਏ, ਇਹ ਕਿਸੇ ਵੀ CPU ਸਰੋਤ ਨੂੰ ਜਾਰੀ ਕਰਦਾ ਹੈ ਜੋ ਇਹ ਵਰਤ ਰਿਹਾ ਸੀ, ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਉਹਨਾਂ ਸਰੋਤਾਂ ਨੂੰ ਹੋਰ ਥਰਿੱਡਾਂ ਜਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਹਨਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹੈ। ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਲਈ NAME _ 1 CPU ਸਮੇਂ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਹੋਰ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ ਜਾਂਪ੍ਰਕਿਰਿਆਵਾਂ। \\n\\n ਮੇਰੀ ਗਲਤੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਤੁਹਾਡਾ ਧੰਨਵਾਦ। ਮੈਂ ਭਵਿੱਖ ਵਿੱਚ ਆਪਣੇ ਜਵਾਬਾਂ ਦੇ ਨਾਮ ਬਾਰੇ ਵਧੇਰੇ ਸਾਵਧਾਨ ਰਹਾਂਗਾ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਉਹ ਸਹੀ ਅਤੇ ਸਹੀ ਹਨ।\',\' ਕੀ ਸੀਪੀਯੂ ਟਾਈਮ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੋਵਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ? \',\' ਹਾਂ, ਸੀਪੀਯੂ ਟਾਈਮ ਨੂੰ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਥਰਿੱਡ ਪੱਧਰ ਦੋਵਾਂ \'ਤੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ। \\n\\n ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ, CPU ਸਮਾਂ ਹਰੇਕ ਥਰਿੱਡ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ ਜੋ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾ ਰਿਹਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਹੈਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ NAME _ 1 ਘਡ਼ੀ ਚੱਕਰ ਜਾਂ ਸਕਿੰਟਾਂ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।\'Thread.getCPUTime ()\' ਵਿਧੀ ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਉੱਤੇ, ਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਹੈਸਾਰੇ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਦਾ ਜੋਡ਼ NAME _ 1 ਪ੍ਰਕਿਰਿਆ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ \'Process.get CPUTine ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਸਮਾਂ ਕੰਧ ਘਡ਼ੀ ਸਮੇਂ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। CPU ਸਮਾਂ CPU ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਨਿਰਦੇਸ਼ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆ ਦੇ ਲਾਗੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘ ਗਿਆ ਹੈ। CPU ਸਮਾਂ ਹੈਪ੍ਰਕਿਰਿਆ ਨੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਇੱਕ ਵਧੇਰੇ ਸਹੀ ਮਾਪ, ਪਰ ਇਸ ਵਿੱਚ I/O ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਿਤਾਇਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਜਾਂ ਹੋਰ ਘਟਨਾਵਾਂ। \\n\\nਅਤੇ, ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ CPU ਸਮਾਂ CPU ਕੋਰਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਹੋ ਸਕਦਾ ਹੈ। ਮਲਟੀ-ਕੋਰ ਸਿਸਟਮਾਂ ਉੱਤੇ,ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਕਈ ਕੋਰਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਕੋਰ ਲਈ ਅਸਲ CPU ਸਮਾਂ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਨਾਲ ਸਿਸਟਮ ਉੱਤੇਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ, ਹਰੇਕ ਕੋਰ ਵਿੱਚ ਮਲਟੀਪਲ ਥਰਿੱਡ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਲਈ CPU ਟਾਈਮ ਨੂੰ ਮਲਟੀਪਲ CPU ਕੋਰ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਦੋਵੇਂ \',\' ਨਾਮ _ 1 ਨਾਮ _ 3 ਨੂੰ ਮਾਪਣ ਲਈ, ਤੁਸੀਂ \'os\' ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ CPU ਟਾਈਮ ਅਤੇ ਵਾਲ ਘਡ਼ੀ ਟਾਈਮ ਦੋਵਾਂ ਨੂੰ ਮਾਪ ਸਕਦੇ ਹੋ।\'os.clock ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜੋ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਮਾਪCPU ਟਾਈਮ ਜਿੰਨਾ ਸਟੀਕ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਇਹ I/O ਓਪਰੇਸ਼ਨਾਂ ਜਾਂ ਹੋਰ ਘਟਨਾਵਾਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਲੇਖਾ ਜੋਖਾ ਨਹੀਂ ਕਰਦਾ ਹੈ। \\n\\n ਕੰਧ ਘਡ਼ੀ ਨੂੰ ਮਾਪਣ ਲਈਇਸ ਸਮੇਂ, ਤੁਸੀਂ \'os.time ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਯੂਨਿਕਸ ਯੁੱਗ (1 ਜਨਵਰੀ, 1970,00:00:00) ਤੋਂ ਮੌਜੂਦਾ ਸਮੇਂ NAME _ 1 ਸਕਿੰਟ ਨਾਲ ਇੱਕ ਟੇਬਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ CPU ਟਾਈਮ ਅਤੇ ਵਾਲ ਕਲੌਕ ਟਾਈਮ ਦੋਵਾਂ ਨੂੰ ਮਾਪਣ ਲਈ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋ NAME _ 1 NAME _ 3: \\n "\\n-- CPU ਨੂੰ ਮਾਪੋਟਾਈਮ\\ਨਲੋਕਲ ਸਟਾਰਟ _ ਟਾਈਮ = os.clock () \\n-- ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ\\ਨਲੋਕਲ ਈਲੈਪਸਡ _ ਟਾਈਮ = os.clock ()-ਸਟਾਰਟ _ ਟਾਈਮ\\ਨਪ੍ਰਿੰਟ ("CPU ਟਾਈਮਃ", ਈਲੈਪਸਡ _ ਟਾਈਮ) \\n\\n-- -ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ ਮਾਪੋ-ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ-\\nlokal elapsed _ ਸਮਯ = os.time ()-ਸਟਾਰਟ _ ਟਾਈਮ\\nਪ੍ਰਿੰਟ ("ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂਃ",\'os.clock ()\' ਫੰਕਸ਼ਨ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ \'os.time ()\'ਫੰਕਸ਼ਨ ਯੂਨਿਕਸ ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਤੁਹਾਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ \'os.time ()\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਸਮੇਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸਹੀ ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ। \',\' ਮੇਰਾ ਮਤਲਬ ਹੈ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਅਤੇ ਥਰਿੱਡ ਦੇ ਪੱਧਰ ਨੂੰ ਮਾਪਣਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ \',\' ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਥਰਿੱਡ ਦੇ ਪੱਧਰ ਦੋਵਾਂ \'ਤੇ ਸੀ. ਪੀ. ਯੂ. ਸਮੇਂ ਨੂੰ ਮਾਪਣਾਨਾਮ _ 1 ਨਾਮ _ 3, ਤੁਸੀਂ \'os\' ਮੋਡੀਊਲ ਅਤੇ \'ਥਰਿੱਡ\' ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ (ਜੇਕਰ ਤੁਸੀਂ ਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ)। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋਃ \\n \'\\n--ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਮਾਪੋ-ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ-\\nlokal elapsed _ ਸਮਯ = os.clock () -ਸਟਾਰਟ _ ਟਾਈਮ \\nਪ੍ਰਿੰਟ ("ਪ੍ਰਕਿਰਿਆ CPU ਸਮਾਂਃ", ਲੰਘਿਆ ਹੋਇਆ _ ਸਮਾਂ) \\n-- ਮੌਜੂਦਾ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਮਾਪੋ\\nlokal ਥਰਿੱਡ _ ਸਟਾਰਟ _ ਟਾਈਮ = thread.clock () \\n-- ਕਰੋਕੁੱਝ ਕੰਮ ਇੱਥੇ ਹੁੰਦੇ ਹਨ \\nlo ਤਾ ਥਰਿੱਡ _ ਈਲੈਪਸਡ _ ਟਾਈਮ = thread.clock ()-ਥਰਿੱਡ _ ਸਟਾਰਟ _ ਟਾਈਮ \\nਪ੍ਰਿੰਟ ("ਥਰਿੱਡ CPU ਟਾਈਮਃ", ਥਰਿੱਡ _ ਈਲੈਪਸਡ _ ਟਾਈਮ) \\n "\'\\nThe\' os.clock () \'ਫੰਕਸ਼ਨ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ \'thread.clock ()\' ਫੰਕਸ਼ਨ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਮੌਜੂਦਾ ਥਰਿੱਡ ਸ਼ੁਰੂ ਹੋ ਗਿਆ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'thread.clock ()\' ਫੰਕਸ਼ਨ ਸਿਰਫ਼ ਤਾਂ ਹੀ ਉਪਲੱਬਧ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ-ਨਾਮ _ 1 ਤੁਹਾਡਾ ਨਾਮ _ 3 ਪ੍ਰੋਗਰਾਮ। ਜੇਕਰ ਤੁਸੀਂ ਹੋਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਮਾਪਣ ਲਈ \'os.clock ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਅਤੇ \'thread.clock ()\' ਫੰਕਸ਼ਨ ਕ੍ਰਮਵਾਰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਜਾਂ ਥਰਿੱਡ ਲਈ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਣਾ ਚਾਹੁੰਦੇ ਹੋਕਈ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਾਂ ਥਰਿੱਡਾਂ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਵੱਖਰੀ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ, ਜਿਵੇਂ ਕਿ \'ps\' ਜਾਂ \'ਸਿਖਰ\' ਕਮਾਂਡ NAME _ 1 a ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਂ ਕਿਸੇ ਤੀਜੀ ਧਿਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।ਲਾਇਬ੍ਰੇਰੀ ਜਿਵੇਂ \'ਨਾਮ _ 3-ਪਰਫ-ਕਾਊਂਟਰ\'. \',\' ਮੇਰਾ ਮਤਲਬ ਹੈ ਨਾਮ _ 1 ਨਾਮ _ 3 \'] ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ?\', "ਨਹੀਂ, ਮੈਂ ਇਹ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਕਿ ਸੀਪੀਯੂ ਟਾਈਮ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ-ਪੱਧਰ ਨੰਬਰ ਹੈ।ਇੱਕ ਪ੍ਰਕਿਰਿਆ-ਪੱਧਰੀ ਨੰਬਰ ਦਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਥਰਿੱਡ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਕਿਸੇ ਵੀ ਸਮੇਂ CPU ਉੱਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਲਈ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇਕਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਇਸ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।10 ਸਕਿੰਟਾਂ ਲਈ CPU, ਜਦੋਂ ਕਿ ਦੂਜਾ ਥਰਿੱਡ ਬੇਕਾਰ ਹੈ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਹੋਵੇਗਾ, 5 ਸਕਿੰਟ ਨਹੀਂ (ਦੁਆਰਾ ਬਿਤਾਏ ਗਏ ਸਮੇਂ ਦਾ ਅੱਧਾ ਹਿੱਸਾ)ਸਰਗਰਮ ਥਰਿੱਡ). \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, CPU ਸਮਾਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।CPU ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। \\n\\nI ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਸੇ ਵੀ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ। ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਡੇ ਕੋਈ ਹੋਰ ਪ੍ਰਸ਼ਨ ਹਨ! ",\'ਨਾਮ _ 1 ਉਸ ਮਾਮਲੇ ਵਿੱਚ, ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਹੋਰ ਥਰਿੱਡ ਨਾਮ _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲਦੀ ਰਹਿੰਦੀ ਹੈ, ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਅਜੇ ਵੀ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ, ਠੀਕ ਹੈ?ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ ਨੰਬਰ \', "ਹਾਂ, ਇਹ ਸਹੀ ਹੈ! ਭਾਵੇਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦੇਵੇ, ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਜਾਰੀ ਰਹੇਗਾਇਹ ਉਦੋਂ ਤੱਕ ਵਧਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਖਪਤ ਕਰ ਰਹੀ ਹੈ। \\n\\n ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈਪ੍ਰਕਿਰਿਆ ਦਾ ਪੱਧਰ, ਅਤੇ ਇਹ ਕੁੱਲ ਸਮਾਂ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੇ ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਇਆ ਹੈ। ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਚਲਾਉਂਦੇ ਹੋਏ, ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਤੁਰੰਤ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ ਹੋਰ ਥਰਿੱਡ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਅਜੇ ਵੀ ਚੱਲ ਰਹੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ CPU ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਹੈ।ਸਰੋਤ. \\n\\n ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਦੋ ਥਰਿੱਡ ਹਨ, ਅਤੇ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਵਧਦਾ ਰਹੇਗਾ ਜਿਵੇਂ ਕਿਹੋਰ ਥਰਿੱਡ ਚਲਾਉਣਾ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ। CPU ਸਮਾਂ ਉਦੋਂ ਤੱਕ ਘੱਟ ਨਹੀਂ ਹੋਵੇਗਾ ਜਦੋਂ ਤੱਕ ਦੋਵੇਂ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਨਹੀਂ ਕਰਦੇ। \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿCPU ਟਾਈਮ ਥਰਿੱਡ ਟਾਈਮ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। ਥਰਿੱਡ ਟਾਈਮ ਇੱਕ ਮਾਪ ਹੈ ਕਿ ਇੱਕ ਸਿੰਗਲ ਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਆਮ ਤੌਰ ਉੱਤੇ ਹੁੰਦਾ ਹੈਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ, ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਮਾਪ ਹੈ ਜੋ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੀ. ਪੀ. ਯੂ. ਉੱਤੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਹੈਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ \'ਤੇ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।\', \'ਫਿਰ ਤੁਸੀਂ ਕਿਉਂ ਕਿਹਾ ਕਿ ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਸੀ. ਪੀ. ਯੂ. ਦਾ ਸਮਾਂ ਨਹੀਂ ਵਧਾਉਂਦਾ\', \'ਤੁਸੀਂ ਸਹੀ ਹੋ, ਅਤੇ ਮੈਂ ਇਸ ਲਈ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ।ਉਲਝਣ. ਜਦੋਂ ਇੱਕ ਥਰਿੱਡ ਚਲਾਉਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਇਹ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ। CPU ਸਮਾਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਸਮੇਂ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਦੇ ਥਰਿੱਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਥਰਿੱਡਾਂ ਦੁਆਰਾ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਚੱਲ ਨਹੀਂ ਰਹੇ ਹਨ। \\n\\nਜਬ ਇੱਕ ਥਰਿੱਡ ਰੁਕਦਾ ਹੈਇਸ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋਏ, ਇਹ ਕਿਸੇ ਵੀ CPU ਸਰੋਤ ਨੂੰ ਜਾਰੀ ਕਰਦਾ ਹੈ ਜੋ ਇਹ ਵਰਤ ਰਿਹਾ ਸੀ, ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਉਹਨਾਂ ਸਰੋਤਾਂ ਨੂੰ ਹੋਰ ਥਰਿੱਡਾਂ ਜਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਹਨਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹੈ। ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਲਈ NAME _ 1 CPU ਸਮੇਂ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਹੋਰ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਨਹੀਂ ਵਧਾਉਂਦਾ ਜਾਂਪ੍ਰਕਿਰਿਆਵਾਂ। \\n\\n ਮੇਰੀ ਗਲਤੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਲਈ ਤੁਹਾਡਾ ਧੰਨਵਾਦ। ਮੈਂ ਭਵਿੱਖ ਵਿੱਚ ਆਪਣੇ ਜਵਾਬਾਂ ਦੇ ਨਾਮ ਬਾਰੇ ਵਧੇਰੇ ਸਾਵਧਾਨ ਰਹਾਂਗਾ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਉਹ ਸਹੀ ਅਤੇ ਸਹੀ ਹਨ।\',\' ਕੀ ਸੀਪੀਯੂ ਟਾਈਮ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੋਵਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ? \',\' ਹਾਂ, ਸੀਪੀਯੂ ਟਾਈਮ ਨੂੰ ਥਰਿੱਡ ਪੱਧਰ ਅਤੇ ਥਰਿੱਡ ਪੱਧਰ ਦੋਵਾਂ \'ਤੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ। \\n\\n ਥਰਿੱਡ ਪੱਧਰ ਉੱਤੇ, CPU ਸਮਾਂ ਹਰੇਕ ਥਰਿੱਡ ਲਈ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ ਜੋ NAME _ 1 ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾ ਰਿਹਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਹੈਥਰਿੱਡ ਚਲਾਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ NAME _ 1 ਘਡ਼ੀ ਚੱਕਰ ਜਾਂ ਸਕਿੰਟਾਂ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।\'Thread.getCPUTime ()\' ਵਿਧੀ ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਉੱਤੇ, ਸਮੁੱਚੀ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਹੈਸਾਰੇ ਥਰਿੱਡਾਂ ਲਈ CPU ਸਮੇਂ ਦਾ ਜੋਡ਼ NAME _ 1 ਪ੍ਰਕਿਰਿਆ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ \'Process.get CPUTine ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਪਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਨਾਮ _ 1 ਨਾਮ _ 2. \\n\\n ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ CPU ਸਮਾਂ ਕੰਧ ਘਡ਼ੀ ਸਮੇਂ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ। CPU ਸਮਾਂ CPU ਦੇ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ।ਨਿਰਦੇਸ਼ ਚਲਾਉਣ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ ਉਸ ਸਮੇਂ ਦੀ ਮਾਤਰਾ ਦਾ ਇੱਕ ਮਾਪ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆ ਦੇ ਲਾਗੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘ ਗਿਆ ਹੈ। CPU ਸਮਾਂ ਹੈਪ੍ਰਕਿਰਿਆ ਨੇ ਚਲਾਉਣ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਇੱਕ ਵਧੇਰੇ ਸਹੀ ਮਾਪ, ਪਰ ਇਸ ਵਿੱਚ I/O ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਿਤਾਇਆ ਸਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਜਾਂ ਹੋਰ ਘਟਨਾਵਾਂ। \\n\\nਅਤੇ, ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ CPU ਸਮਾਂ CPU ਕੋਰਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਹੋ ਸਕਦਾ ਹੈ। ਮਲਟੀ-ਕੋਰ ਸਿਸਟਮਾਂ ਉੱਤੇ,ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮਾਂ ਕਈ ਕੋਰਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਕੋਰ ਲਈ ਅਸਲ CPU ਸਮਾਂ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਨਾਲ ਸਿਸਟਮ ਉੱਤੇਹਾਈਪਰ-ਥ੍ਰੈਡਿੰਗ, ਹਰੇਕ ਕੋਰ ਵਿੱਚ ਮਲਟੀਪਲ ਥਰਿੱਡ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਥਰਿੱਡ ਲਈ CPU ਟਾਈਮ ਨੂੰ ਮਲਟੀਪਲ CPU ਕੋਰ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਦੋਵੇਂ \',\' ਨਾਮ _ 1 ਨਾਮ _ 3 ਨੂੰ ਮਾਪਣ ਲਈ, ਤੁਸੀਂ \'os\' ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ CPU ਟਾਈਮ ਅਤੇ ਵਾਲ ਘਡ਼ੀ ਟਾਈਮ ਦੋਵਾਂ ਨੂੰ ਮਾਪ ਸਕਦੇ ਹੋ।\'os.clock ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜੋ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਲੰਘੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਮਾਪCPU ਟਾਈਮ ਜਿੰਨਾ ਸਟੀਕ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਇਹ I/O ਓਪਰੇਸ਼ਨਾਂ ਜਾਂ ਹੋਰ ਘਟਨਾਵਾਂ ਦੀ ਉਡੀਕ ਵਿੱਚ ਬਿਤਾਏ ਸਮੇਂ ਦਾ ਲੇਖਾ ਜੋਖਾ ਨਹੀਂ ਕਰਦਾ ਹੈ। \\n\\n ਕੰਧ ਘਡ਼ੀ ਨੂੰ ਮਾਪਣ ਲਈਇਸ ਸਮੇਂ, ਤੁਸੀਂ \'os.time ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਯੂਨਿਕਸ ਯੁੱਗ (1 ਜਨਵਰੀ, 1970,00:00:00) ਤੋਂ ਮੌਜੂਦਾ ਸਮੇਂ NAME _ 1 ਸਕਿੰਟ ਨਾਲ ਇੱਕ ਟੇਬਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ CPU ਟਾਈਮ ਅਤੇ ਵਾਲ ਕਲੌਕ ਟਾਈਮ ਦੋਵਾਂ ਨੂੰ ਮਾਪਣ ਲਈ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋ NAME _ 1 NAME _ 3: \\n "\\n-- CPU ਨੂੰ ਮਾਪੋਟਾਈਮ\\ਨਲੋਕਲ ਸਟਾਰਟ _ ਟਾਈਮ = os.clock () \\n-- ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ\\ਨਲੋਕਲ ਈਲੈਪਸਡ _ ਟਾਈਮ = os.clock ()-ਸਟਾਰਟ _ ਟਾਈਮ\\ਨਪ੍ਰਿੰਟ ("CPU ਟਾਈਮਃ", ਈਲੈਪਸਡ _ ਟਾਈਮ) \\n\\n-- -ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ ਮਾਪੋ-ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ-\\nlokal elapsed _ ਸਮਯ = os.time ()-ਸਟਾਰਟ _ ਟਾਈਮ\\nਪ੍ਰਿੰਟ ("ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂਃ",\'os.clock ()\' ਫੰਕਸ਼ਨ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ \'os.time ()\'ਫੰਕਸ਼ਨ ਯੂਨਿਕਸ ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਤੁਹਾਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ \'os.time ()\' ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਸਮੇਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸਹੀ ਕੰਧ ਘਡ਼ੀ ਦਾ ਸਮਾਂ। \',\' ਮੇਰਾ ਮਤਲਬ ਹੈ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੱਧਰ ਅਤੇ ਥਰਿੱਡ ਦੇ ਪੱਧਰ ਨੂੰ ਮਾਪਣਾ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ \',\' ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਥਰਿੱਡ ਦੇ ਪੱਧਰ ਦੋਵਾਂ \'ਤੇ ਸੀ. ਪੀ. ਯੂ. ਸਮੇਂ ਨੂੰ ਮਾਪਣਾਨਾਮ _ 1 ਨਾਮ _ 3, ਤੁਸੀਂ \'os\' ਮੋਡੀਊਲ ਅਤੇ \'ਥਰਿੱਡ\' ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ (ਜੇਕਰ ਤੁਸੀਂ ਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ)। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋਃ \\n \'\\n--ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਮਾਪੋ-ਇੱਥੇ ਕੁੱਝ ਕੰਮ ਕਰੋ-\\nlokal elapsed _ ਸਮਯ = os.clock () -ਸਟਾਰਟ _ ਟਾਈਮ \\nਪ੍ਰਿੰਟ ("ਪ੍ਰਕਿਰਿਆ CPU ਸਮਾਂਃ", ਲੰਘਿਆ ਹੋਇਆ _ ਸਮਾਂ) \\n-- ਮੌਜੂਦਾ ਥਰਿੱਡ ਲਈ CPU ਸਮਾਂ ਮਾਪੋ\\nlokal ਥਰਿੱਡ _ ਸਟਾਰਟ _ ਟਾਈਮ = thread.clock () \\n-- ਕਰੋਕੁੱਝ ਕੰਮ ਇੱਥੇ ਹੁੰਦੇ ਹਨ \\nlo ਤਾ ਥਰਿੱਡ _ ਈਲੈਪਸਡ _ ਟਾਈਮ = thread.clock ()-ਥਰਿੱਡ _ ਸਟਾਰਟ _ ਟਾਈਮ \\nਪ੍ਰਿੰਟ ("ਥਰਿੱਡ CPU ਟਾਈਮਃ", ਥਰਿੱਡ _ ਈਲੈਪਸਡ _ ਟਾਈਮ) \\n "\'\\nThe\' os.clock () \'ਫੰਕਸ਼ਨ NAME _ 3 ਦੁਭਾਸ਼ੀਏ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ \'thread.clock ()\' ਫੰਕਸ਼ਨ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਮੌਜੂਦਾ ਥਰਿੱਡ ਸ਼ੁਰੂ ਹੋ ਗਿਆ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'thread.clock ()\' ਫੰਕਸ਼ਨ ਸਿਰਫ਼ ਤਾਂ ਹੀ ਉਪਲੱਬਧ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ-ਨਾਮ _ 1 ਤੁਹਾਡਾ ਨਾਮ _ 3 ਪ੍ਰੋਗਰਾਮ। ਜੇਕਰ ਤੁਸੀਂ ਹੋਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਲਈ CPU ਸਮੇਂ ਨੂੰ ਮਾਪਣ ਲਈ \'os.clock ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਅਤੇ \'thread.clock ()\' ਫੰਕਸ਼ਨ ਕ੍ਰਮਵਾਰ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਜਾਂ ਥਰਿੱਡ ਲਈ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ CPU ਟਾਈਮ ਨੂੰ ਮਾਪਣਾ ਚਾਹੁੰਦੇ ਹੋਕਈ ਪ੍ਰਕਿਰਿਆਵਾਂ ਜਾਂ ਥਰਿੱਡਾਂ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਵੱਖਰੀ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ, ਜਿਵੇਂ ਕਿ \'ps\' ਜਾਂ \'ਸਿਖਰ\' ਕਮਾਂਡ NAME _ 1 a ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਾਂ ਕਿਸੇ ਤੀਜੀ ਧਿਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।ਲਾਇਬਰੇਰੀ ਜਿਵੇਂ ਕਿ \'NAME _ 3-perf-counter\'. \',\' ਮੇਰਾ ਮਤਲਬ ਹੈ NAME _ 1 NAME _ 3 \',\' NAME _ 1 NAME _ 3 \', ਤੁਸੀਂ CPU ਸਮੇਂ ਨੂੰ ਮਾਪਣ ਲਈ\' os \'ਅਤੇ\' ਥਰਿੱਡ \'ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਥਰਿੱਡ, ਕ੍ਰਮਵਾਰ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋ ", \'ਮੇਰਾ ਮਤਲਬ ਹੈ NAME _ 1 NAME _ 3, os.clock () ਪੂਰੇ ਦਾ CPU ਸਮਾਂ ਹੈ।ਇੱਕ ਥਰਿੱਡ ਦੀ ਪ੍ਰਕਿਰਿਆ? \\n\\n\\n \'] ', 'ਕੀ ਤੁਸੀਂ ਕਹਿ ਰਹੇ ਹੋ ਕਿ ਸੀ. ਪੀ. ਯੂ. ਸਮਾਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ ਦੀ ਬਜਾਏ ਇੱਕ ਥਰਿੱਡ ਪੱਧਰ ਨੰਬਰ ਹੈ? \n ']