ਕੁਆਰਕਸ ਜ਼ਰੂਰੀ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਨੂੰ ਕਿਵੇਂ ਜੋੜਦਾ ਹੈ

ਇਸ ਸਾਲ ਅਸੀਂ ਕੰਟੇਨਰ ਥੀਮ ਨੂੰ ਗੰਭੀਰਤਾ ਨਾਲ ਵਿਕਸਤ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਹੇ ਹਾਂ, ਕਲਾਉਡ-ਨੇਟਿਵ Java и ਕਬਰਨੇਟਿਸ. ਇਹਨਾਂ ਵਿਸ਼ਿਆਂ ਦੀ ਇੱਕ ਤਰਕਪੂਰਨ ਨਿਰੰਤਰਤਾ ਕੁਆਰਕਸ ਫਰੇਮਵਰਕ ਬਾਰੇ ਇੱਕ ਕਹਾਣੀ ਹੋਵੇਗੀ, ਪਹਿਲਾਂ ਹੀ ਮੰਨਿਆ Habré 'ਤੇ. ਅੱਜ ਦਾ ਲੇਖ "ਸਬਟੋਮਿਕ ਸੁਪਰਫਾਸਟ ਜਾਵਾ" ਦੇ ਡਿਜ਼ਾਇਨ ਬਾਰੇ ਘੱਟ ਅਤੇ ਕੁਆਰਕਸ ਐਂਟਰਪ੍ਰਾਈਜ਼ ਲਈ ਲਿਆਏ ਗਏ ਵਾਅਦੇ ਬਾਰੇ ਜ਼ਿਆਦਾ ਹੈ।

ਜਾਵਾ ਅਤੇ ਜੇਵੀਐਮ ਅਜੇ ਵੀ ਬਹੁਤ ਮਸ਼ਹੂਰ ਹਨ, ਪਰ ਜਦੋਂ ਸਰਵਰ ਰਹਿਤ ਤਕਨਾਲੋਜੀਆਂ ਅਤੇ ਕਲਾਉਡ-ਨੇਟਿਵ ਮਾਈਕ੍ਰੋਸਰਵਿਸਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ, ਤਾਂ ਜਾਵਾ ਅਤੇ ਹੋਰ ਜੇਵੀਐਮ ਭਾਸ਼ਾਵਾਂ ਘੱਟ ਅਤੇ ਘੱਟ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਉਹ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਸਪੇਸ ਲੈਂਦੀਆਂ ਹਨ ਅਤੇ ਲੋਡ ਕਰਨ ਲਈ ਬਹੁਤ ਹੌਲੀ ਹੁੰਦੀਆਂ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਬਣਾਉਂਦੀਆਂ ਹਨ। ਥੋੜ੍ਹੇ ਸਮੇਂ ਦੇ ਕੰਟੇਨਰਾਂ ਨਾਲ ਵਰਤਣ ਲਈ ਮਾੜੀ ਤਰ੍ਹਾਂ ਅਨੁਕੂਲ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਇਹ ਸਥਿਤੀ ਹੁਣ ਕੁਆਰਕਸ ਦੀ ਬਦੌਲਤ ਬਦਲਣੀ ਸ਼ੁਰੂ ਹੋ ਰਹੀ ਹੈ।

ਸੁਪਰਫਾਸਟ ਉਪ-ਪਰਮਾਣੂ ਜਾਵਾ ਇੱਕ ਨਵੇਂ ਪੱਧਰ 'ਤੇ ਪਹੁੰਚ ਗਿਆ ਹੈ!

42 ਰੀਲੀਜ਼, 8 ਮਹੀਨਿਆਂ ਦਾ ਕਮਿਊਨਿਟੀ ਕੰਮ ਅਤੇ 177 ਸ਼ਾਨਦਾਰ ਡਿਵੈਲਪਰ - ਇਸ ਸਭ ਦਾ ਨਤੀਜਾ ਨਵੰਬਰ 2019 ਵਿੱਚ ਰਿਲੀਜ਼ ਹੋਇਆ ਸੀ ਕੁਆਰਕਸ 1.0, ਇੱਕ ਰੀਲੀਜ਼ ਜੋ ਪ੍ਰੋਜੈਕਟ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਮੀਲ ਪੱਥਰ ਦੀ ਨਿਸ਼ਾਨਦੇਹੀ ਕਰਦੀ ਹੈ ਅਤੇ ਬਹੁਤ ਸਾਰੀਆਂ ਸ਼ਾਨਦਾਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਸਮਰੱਥਾਵਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੀ ਹੈ (ਤੁਸੀਂ ਇਹਨਾਂ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਘੋਸ਼ਣਾ).

ਅੱਜ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗੇ ਕਿ ਕਿਵੇਂ ਕੁਆਰਕਸ ਲਾਜ਼ਮੀ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਮਾਡਲਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਰੀਐਕਟਿਵ ਕੋਰ ਵਿੱਚ ਜੋੜਦਾ ਹੈ। ਅਸੀਂ ਇੱਕ ਸੰਖੇਪ ਇਤਿਹਾਸ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਾਂਗੇ ਅਤੇ ਫਿਰ ਇਸ ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਜਾਵਾਂਗੇ ਕਿ ਕੁਆਰਕਸ ਦਾ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਕੋਰ ਡੂਅਲਵਾਦ ਕੀ ਹੈ ਅਤੇ ਕਿਵੇਂ ਜਾਵਾ-ਡਿਵੈਲਪਰ ਇਨ੍ਹਾਂ ਲਾਭਾਂ ਦਾ ਲਾਭ ਲੈ ਸਕਦੇ ਹਨ।

ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼, ਘਟਨਾ ਸੰਚਾਲਿਤ ਆਰਕੀਟੈਕਚਰ и ਸਰਵਰ-ਫੰਕਸ਼ਨ - ਇਹ ਸਭ ਹੈ, ਜਿਵੇਂ ਕਿ ਉਹ ਕਹਿੰਦੇ ਹਨ, ਅੱਜ ਵਧ ਰਿਹਾ ਹੈ। ਹਾਲ ਹੀ ਵਿੱਚ, ਕਲਾਉਡ-ਕੇਂਦ੍ਰਿਤ ਆਰਕੀਟੈਕਚਰ ਦੀ ਰਚਨਾ ਬਹੁਤ ਆਸਾਨ ਅਤੇ ਵਧੇਰੇ ਪਹੁੰਚਯੋਗ ਹੋ ਗਈ ਹੈ, ਪਰ ਸਮੱਸਿਆਵਾਂ ਰਹਿੰਦੀਆਂ ਹਨ - ਖਾਸ ਕਰਕੇ ਜਾਵਾ ਡਿਵੈਲਪਰਾਂ ਲਈ। ਉਦਾਹਰਨ ਲਈ, ਸਰਵਰ ਰਹਿਤ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਸ਼ੁਰੂਆਤੀ ਸਮੇਂ ਨੂੰ ਘਟਾਉਣ, ਮੈਮੋਰੀ ਦੀ ਖਪਤ ਨੂੰ ਘਟਾਉਣ, ਅਤੇ ਅਜੇ ਵੀ ਉਹਨਾਂ ਦੇ ਵਿਕਾਸ ਨੂੰ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ ਅਤੇ ਆਨੰਦਦਾਇਕ ਬਣਾਉਣ ਦੀ ਤੁਰੰਤ ਲੋੜ ਹੈ। ਜਾਵਾ ਨੇ ਹਾਲ ਹੀ ਦੇ ਸਾਲਾਂ ਵਿੱਚ ਕਈ ਸੁਧਾਰ ਕੀਤੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਕੰਟੇਨਰਾਂ ਲਈ ਸੁਧਾਰੀ ਹੋਈ ਐਰਗੋਨੋਮਿਕਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਆਦਿ। ਹਾਲਾਂਕਿ, ਜਾਵਾ ਨੂੰ ਇੱਕ ਕੰਟੇਨਰ ਵਿੱਚ ਸਹੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਨਾ ਅਜੇ ਵੀ ਚੁਣੌਤੀਪੂਰਨ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਜਾਵਾ ਦੀਆਂ ਕੁਝ ਅੰਦਰੂਨੀ ਗੁੰਝਲਾਂ ਨੂੰ ਦੇਖ ਕੇ ਸ਼ੁਰੂਆਤ ਕਰਾਂਗੇ, ਜੋ ਕੰਟੇਨਰ-ਅਧਾਰਿਤ Java ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਵੇਲੇ ਖਾਸ ਤੌਰ 'ਤੇ ਗੰਭੀਰ ਹੁੰਦੀਆਂ ਹਨ।

ਪਹਿਲਾਂ, ਆਓ ਇਤਿਹਾਸ ਨੂੰ ਵੇਖੀਏ.

ਸਟਰੀਮ ਅਤੇ ਕੰਟੇਨਰ

ਸੰਸਕਰਣ 8u131 ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ਜਾਵਾ ਨੇ ਐਰਗੋਨੋਮਿਕਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਸੁਧਾਰ ਦੇ ਕਾਰਨ ਘੱਟ ਜਾਂ ਘੱਟ ਸਮਰਥਨ ਕੰਟੇਨਰਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕੀਤਾ। ਖਾਸ ਤੌਰ 'ਤੇ, JVM ਹੁਣ ਜਾਣਦਾ ਹੈ ਕਿ ਇਹ ਕਿੰਨੇ ਪ੍ਰੋਸੈਸਰ ਕੋਰ 'ਤੇ ਚੱਲ ਰਿਹਾ ਹੈ ਅਤੇ ਥਰਿੱਡ ਪੂਲ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦਾ ਹੈ-ਆਮ ਤੌਰ 'ਤੇ ਫੋਰਕ/ਜੋਇਨ ਪੂਲ-ਅਨੁਸਾਰ। ਬੇਸ਼ੱਕ, ਇਹ ਬਹੁਤ ਵਧੀਆ ਹੈ, ਪਰ ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਪਰੰਪਰਾਗਤ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਹੈ ਜੋ HTTP ਸਰਵਲੇਟ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਅਤੇ ਟੋਮਕੈਟ, ਜੇਟੀ, ਆਦਿ ਵਿੱਚ ਚਲਦੀ ਹੈ. ਨਤੀਜੇ ਵਜੋਂ, ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਹਰੇਕ ਬੇਨਤੀ ਨੂੰ ਇੱਕ ਵੱਖਰਾ ਥ੍ਰੈਡ ਦੇਵੇਗੀ ਅਤੇ I/O ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹੋਏ ਇਸ ਥ੍ਰੈਡ ਨੂੰ ਬਲੌਕ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ, ਉਦਾਹਰਨ ਲਈ, ਡੇਟਾਬੇਸ, ਫਾਈਲਾਂ ਜਾਂ ਹੋਰ ਸੇਵਾਵਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਵੇਲੇ। ਭਾਵ, ਅਜਿਹੀ ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਆਕਾਰ ਉਪਲਬਧ ਕੋਰਾਂ ਦੀ ਸੰਖਿਆ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦਾ, ਪਰ ਸਮਕਾਲੀ ਬੇਨਤੀਆਂ ਦੀ ਗਿਣਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਕੋਰਾਂ ਦੀ ਸੰਖਿਆ 'ਤੇ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਕੋਟਾ ਜਾਂ ਸੀਮਾਵਾਂ ਇੱਥੇ ਬਹੁਤ ਮਦਦਗਾਰ ਨਹੀਂ ਹੋਣਗੀਆਂ, ਅਤੇ ਮਾਮਲਾ ਅੰਤ ਵਿੱਚ ਥ੍ਰੋਟਲਿੰਗ ਵਿੱਚ ਖਤਮ ਹੋ ਜਾਵੇਗਾ।

ਮੈਮੋਰੀ ਥਕਾਵਟ

ਥਰਿੱਡ ਮੈਮੋਰੀ ਹਨ. ਅਤੇ ਇੰਟਰਾ-ਕੰਟੇਨਰ ਮੈਮੋਰੀ ਸੀਮਾਵਾਂ ਕਿਸੇ ਵੀ ਤਰ੍ਹਾਂ ਦਾ ਇਲਾਜ ਨਹੀਂ ਹਨ। ਬਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਤੇ ਥਰਿੱਡਾਂ ਦੀ ਗਿਣਤੀ ਵਧਾਉਣੀ ਸ਼ੁਰੂ ਕਰੋ, ਅਤੇ ਜਲਦੀ ਜਾਂ ਬਾਅਦ ਵਿੱਚ ਤੁਹਾਨੂੰ ਸਵਿਚਿੰਗ ਬਾਰੰਬਾਰਤਾ ਵਿੱਚ ਇੱਕ ਨਾਜ਼ੁਕ ਵਾਧੇ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਵੇਗਾ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ, ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਗਿਰਾਵਟ ਆਵੇਗੀ। ਨਾਲ ਹੀ, ਜੇਕਰ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਪਰੰਪਰਾਗਤ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਜਾਂ ਇੱਕ ਡੇਟਾਬੇਸ ਨਾਲ ਜੁੜਦੀ ਹੈ, ਜਾਂ ਕੈਚਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਜਾਂ ਹੋਰ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇੱਕ ਟੂਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੋ ਤੁਹਾਨੂੰ JVM ਦੇ ਅੰਦਰ ਦੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਇਹ ਮੈਮੋਰੀ ਨੂੰ ਮਾਰੇ ਬਿਨਾਂ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕਰਦਾ ਹੈ। JVM ਖੁਦ (ਉਦਾਹਰਨ ਲਈ, XX:+UseCGroupMemoryLimitForHeap)। ਅਤੇ ਭਾਵੇਂ, Java 9 ਤੋਂ, JVM ਨੇ cgroups ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਅਤੇ ਉਸ ਅਨੁਸਾਰ ਢਾਲਣਾ ਸਿੱਖਿਆ ਹੈ, ਮੈਮੋਰੀ ਨੂੰ ਰਿਜ਼ਰਵ ਕਰਨਾ ਅਤੇ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਇੱਕ ਗੁੰਝਲਦਾਰ ਮਾਮਲਾ ਹੈ।

ਕੋਟਾ ਅਤੇ ਸੀਮਾਵਾਂ

Java 11 ਨੇ CPU ਕੋਟਾ (ਜਿਵੇਂ PreferContainerQuotaForCPUCount) ਲਈ ਸਮਰਥਨ ਪੇਸ਼ ਕੀਤਾ ਹੈ। ਕੁਬਰਨੇਟਸ ਸੀਮਾਵਾਂ ਅਤੇ ਕੋਟਾ ਲਈ ਸਮਰਥਨ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਹਾਂ, ਇਹ ਸਭ ਕੁਝ ਸਮਝਦਾ ਹੈ, ਪਰ ਜੇਕਰ ਐਪਲੀਕੇਸ਼ਨ ਦੁਬਾਰਾ ਨਿਰਧਾਰਤ ਕੋਟੇ ਤੋਂ ਵੱਧ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਦੁਬਾਰਾ ਆਕਾਰ ਦੇ ਨਾਲ ਖਤਮ ਹੋ ਜਾਂਦੇ ਹਾਂ - ਜਿਵੇਂ ਕਿ ਰਵਾਇਤੀ Java ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਨਾਲ ਹੁੰਦਾ ਹੈ - ਕੋਰਾਂ ਦੀ ਸੰਖਿਆ ਦੁਆਰਾ ਅਤੇ ਹਰੇਕ ਲਈ ਇੱਕ ਵੱਖਰੇ ਥ੍ਰੈਡ ਦੀ ਵੰਡ ਨਾਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਬੇਨਤੀ ਹੈ, ਤਾਂ ਇਸ ਸਭ ਵਿੱਚ ਕੋਈ ਸਮਝ ਨਹੀਂ ਹੈ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜੇਕਰ ਤੁਸੀਂ ਕੁਬਰਨੇਟਸ ਅਧੀਨ ਪਲੇਟਫਾਰਮ ਦੇ ਕੋਟਾ ਅਤੇ ਸੀਮਾਵਾਂ ਜਾਂ ਸਕੇਲ-ਆਊਟ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਮੱਸਿਆ ਵੀ ਆਪਣੇ ਆਪ ਹੱਲ ਨਹੀਂ ਹੁੰਦੀ। ਅਸੀਂ ਅਸਲ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਵਧੇਰੇ ਸਰੋਤ ਖਰਚ ਕਰਦੇ ਹਾਂ ਜਾਂ ਜ਼ਿਆਦਾ ਖਰਚ ਕਰਦੇ ਹਾਂ। ਅਤੇ ਜੇਕਰ ਇਹ ਇੱਕ ਜਨਤਕ ਜਨਤਕ ਕਲਾਉਡ ਵਿੱਚ ਇੱਕ ਉੱਚ-ਲੋਡ ਸਿਸਟਮ ਹੈ, ਤਾਂ ਅਸੀਂ ਲਗਭਗ ਨਿਸ਼ਚਿਤ ਤੌਰ 'ਤੇ ਲੋੜ ਤੋਂ ਵੱਧ ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

ਅਤੇ ਇਸ ਸਭ ਦਾ ਕੀ ਕਰਨਾ ਹੈ?

ਇਸਨੂੰ ਸਧਾਰਨ ਰੂਪ ਵਿੱਚ ਕਹਿਣ ਲਈ, ਅਸਿੰਕ੍ਰੋਨਸ ਅਤੇ ਗੈਰ-ਬਲਾਕਿੰਗ I/O ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਫਰੇਮਵਰਕ ਜਿਵੇਂ ਕਿ ਨੇਟੀ, ਦੀ ਵਰਤੋਂ ਕਰੋ। Vert.x ਜਾਂ ਅੱਕਾ। ਉਹ ਆਪਣੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਸੁਭਾਅ ਦੇ ਕਾਰਨ ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਅਨੁਕੂਲ ਹਨ. I/O ਨੂੰ ਨਾ-ਬਲਾਕ ਕਰਨ ਲਈ ਧੰਨਵਾਦ, ਇੱਕੋ ਥ੍ਰੈਡ ਕਈ ਇੱਕੋ ਸਮੇਂ ਦੀਆਂ ਬੇਨਤੀਆਂ 'ਤੇ ਕਾਰਵਾਈ ਕਰ ਸਕਦਾ ਹੈ। ਜਦੋਂ ਕਿ ਇੱਕ ਬੇਨਤੀ I/O ਨਤੀਜਿਆਂ ਦੀ ਉਡੀਕ ਕਰ ਰਹੀ ਹੈ, ਥ੍ਰੈਡ ਪ੍ਰੋਸੈਸਿੰਗ ਇਸ ਨੂੰ ਜਾਰੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਦੂਜੀ ਬੇਨਤੀ ਦੁਆਰਾ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ। ਅਤੇ ਜਦੋਂ ਅੰਤ ਵਿੱਚ I/O ਨਤੀਜੇ ਆਉਂਦੇ ਹਨ, ਪਹਿਲੀ ਬੇਨਤੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਜਾਰੀ ਰਹਿੰਦੀ ਹੈ। ਇੱਕੋ ਥ੍ਰੈਡ ਦੇ ਅੰਦਰ ਬੇਨਤੀਆਂ ਦੀ ਇੰਟਰਲੀਵਡ ਪ੍ਰੋਸੈਸਿੰਗ ਦੁਆਰਾ, ਤੁਸੀਂ ਥ੍ਰੈੱਡਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਨੂੰ ਘਟਾ ਸਕਦੇ ਹੋ ਅਤੇ ਬੇਨਤੀਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਸਰੋਤ ਦੀ ਖਪਤ ਨੂੰ ਘਟਾ ਸਕਦੇ ਹੋ।

ਗੈਰ-ਬਲਾਕਿੰਗ I/O ਦੇ ਨਾਲ, ਕੋਰਾਂ ਦੀ ਸੰਖਿਆ ਇੱਕ ਮੁੱਖ ਪੈਰਾਮੀਟਰ ਬਣ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ I/O ਥਰਿੱਡਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜੋ ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਜਦੋਂ ਸਹੀ ਢੰਗ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਤੁਹਾਨੂੰ ਕੋਰਾਂ ਵਿਚਕਾਰ ਲੋਡ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਵੰਡਣ ਅਤੇ ਘੱਟ ਸਰੋਤਾਂ ਨਾਲ ਉੱਚ ਵਰਕਲੋਡ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਇਹ ਸਭ ਕਿਵੇਂ ਹੈ?

ਨਹੀਂ, ਕੁਝ ਹੋਰ ਹੈ। ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਰੋਤਾਂ ਦੀ ਬਿਹਤਰ ਵਰਤੋਂ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ, ਪਰ ਇਹ ਇੱਕ ਕੀਮਤ 'ਤੇ ਵੀ ਆਉਂਦੀ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਕੋਡ ਨੂੰ ਗੈਰ-ਬਲਾਕ ਕਰਨ ਦੇ ਸਿਧਾਂਤਾਂ ਦੇ ਅਨੁਸਾਰ ਦੁਬਾਰਾ ਲਿਖਣਾ ਹੋਵੇਗਾ ਅਤੇ I/O ਥਰਿੱਡਾਂ ਨੂੰ ਬਲਾਕ ਕਰਨ ਤੋਂ ਬਚਣਾ ਹੋਵੇਗਾ। ਅਤੇ ਇਹ ਵਿਕਾਸ ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਇੱਕ ਬਿਲਕੁਲ ਵੱਖਰਾ ਮਾਡਲ ਹੈ। ਅਤੇ ਹਾਲਾਂਕਿ ਇੱਥੇ ਬਹੁਤ ਸਾਰੀਆਂ ਉਪਯੋਗੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਹਨ, ਇਹ ਅਜੇ ਵੀ ਸੋਚਣ ਦੇ ਆਮ ਤਰੀਕੇ ਵਿੱਚ ਇੱਕ ਬੁਨਿਆਦੀ ਤਬਦੀਲੀ ਹੈ।

ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇਹ ਸਿੱਖਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਕੋਡ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਜੋ ਅਸਿੰਕਰੋਨਸ ਚੱਲਦਾ ਹੈ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਗੈਰ-ਬਲਾਕਿੰਗ I/O ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇਹ ਦੱਸਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਕਿ ਜਦੋਂ ਇੱਕ ਬੇਨਤੀ ਦਾ ਜਵਾਬ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ ਤਾਂ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਬਸ ਬਲੌਕ ਕਰਨਾ ਅਤੇ ਉਡੀਕ ਕਰਨਾ ਹੁਣ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ। ਇਸਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਕਾਲਬੈਕ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ, ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਜਾਂ ਨਿਰੰਤਰਤਾ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਪਰ ਇਹ ਸਭ ਕੁਝ ਨਹੀਂ ਹੈ: ਗੈਰ-ਬਲਾਕਿੰਗ I/O ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਗੈਰ-ਬਲੌਕ ਕਰਨ ਵਾਲੇ ਸਰਵਰਾਂ ਅਤੇ ਗਾਹਕਾਂ ਦੋਵਾਂ ਦੀ ਲੋੜ ਹੈ, ਤਰਜੀਹੀ ਤੌਰ 'ਤੇ ਹਰ ਜਗ੍ਹਾ। HTTP ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ, ਪਰ ਇੱਥੇ ਡੇਟਾਬੇਸ, ਫਾਈਲ ਸਿਸਟਮ ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਵੀ ਹਨ.

ਅਤੇ ਹਾਲਾਂਕਿ ਕੁੱਲ ਅੰਤ-ਤੋਂ-ਅੰਤ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲਤਾ ਕੁਸ਼ਲਤਾ ਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ ਕਰਦੀ ਹੈ, ਅਜਿਹੀ ਤਬਦੀਲੀ ਅਭਿਆਸ ਵਿੱਚ ਪੇਟ ਲਈ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦੀ ਹੈ। ਇਸ ਲਈ, ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਅਤੇ ਲਾਜ਼ਮੀ ਕੋਡ ਨੂੰ ਜੋੜਨ ਦੀ ਯੋਗਤਾ ਇੱਕ ਪੂਰਵ ਸ਼ਰਤ ਬਣ ਜਾਂਦੀ ਹੈ:

1. ਸਾੱਫਟਵੇਅਰ ਸਿਸਟਮ ਦੇ ਸਭ ਤੋਂ ਵੱਧ ਲੋਡ ਕੀਤੇ ਖੇਤਰਾਂ ਵਿੱਚ ਸਰੋਤਾਂ ਦੀ ਪ੍ਰਭਾਵੀ ਵਰਤੋਂ ਕਰੋ;
2. ਇਸਦੇ ਬਾਕੀ ਭਾਗਾਂ ਵਿੱਚ ਸਰਲ ਸਟਾਈਲ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਕੁਆਰਕਸ ਪੇਸ਼ ਹੈ

ਅਸਲ ਵਿੱਚ, ਇਹ ਕੁਆਰਕਸ ਦਾ ਸਾਰ ਹੈ - ਇੱਕ ਸਿੰਗਲ ਰਨਟਾਈਮ ਵਾਤਾਵਰਣ ਵਿੱਚ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਅਤੇ ਲਾਜ਼ਮੀ ਮਾਡਲਾਂ ਨੂੰ ਜੋੜਨਾ।

Quarkus Vert.x ਅਤੇ Netty 'ਤੇ ਆਧਾਰਿਤ ਹੈ, ਜਿਸ ਵਿੱਚ ਡਿਵੈਲਪਰ ਦੀ ਮਦਦ ਕਰਨ ਲਈ ਸਿਖਰ 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਫਰੇਮਵਰਕ ਅਤੇ ਐਕਸਟੈਂਸ਼ਨਾਂ ਦੀ ਇੱਕ ਸੀਮਾ ਹੈ। ਕੁਆਰਕਸ ਨਾ ਸਿਰਫ਼ HTTP ਮਾਈਕਰੋ ਸਰਵਿਸਿਜ਼ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਸਗੋਂ ਇਵੈਂਟ-ਸੰਚਾਲਿਤ ਆਰਕੀਟੈਕਚਰ ਵੀ ਹੈ। ਇਸਦੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਸੁਭਾਅ ਦੇ ਕਾਰਨ, ਇਹ ਮੈਸੇਜਿੰਗ ਪ੍ਰਣਾਲੀਆਂ (ਅਪਾਚੇ ਕਾਫਕਾ, AMQP, ਆਦਿ) ਨਾਲ ਬਹੁਤ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।

ਚਾਲ ਇਹ ਹੈ ਕਿ ਜ਼ਰੂਰੀ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਕੋਡ ਦੋਵਾਂ ਲਈ ਇੱਕੋ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕੀਤੀ ਜਾਵੇ।

ਕੁਆਰਕਸ ਇਸ ਨੂੰ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਕਰਦਾ ਹੈ। ਲਾਜ਼ਮੀ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਵਿਚਕਾਰ ਚੋਣ ਸਪੱਸ਼ਟ ਹੈ - ਦੋਵਾਂ ਲਈ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਕਰਨਲ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜਿਸ ਨਾਲ ਇਹ ਅਸਲ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਉਹ ਤੇਜ਼, ਗੈਰ-ਬਲੌਕਿੰਗ ਕੋਡ ਹੈ ਜੋ ਲਗਭਗ ਹਰ ਚੀਜ਼ ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ ਜੋ ਇਵੈਂਟ-ਲੂਪ ਥਰਿੱਡ, ਉਰਫ਼ IO ਥਰਿੱਡ ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ। ਪਰ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਕਲਾਸਿਕ REST ਜਾਂ ਕਲਾਇੰਟ-ਸਾਈਡ ਐਪਲੀਕੇਸ਼ਨ ਹਨ, ਤਾਂ ਕੁਆਰਕਸ ਕੋਲ ਇੱਕ ਜ਼ਰੂਰੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਮਾਡਲ ਤਿਆਰ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕੁਆਰਕਸ ਵਿੱਚ HTTP ਸਮਰਥਨ ਇੱਕ ਗੈਰ-ਬਲਾਕਿੰਗ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਇੰਜਣ (Eclipse Vert.x ਅਤੇ Netty) ਦੀ ਵਰਤੋਂ 'ਤੇ ਅਧਾਰਤ ਹੈ। ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੀਆਂ ਸਾਰੀਆਂ HTTP ਬੇਨਤੀਆਂ ਪਹਿਲਾਂ ਇੱਕ ਇਵੈਂਟ ਲੂਪ (IO ਥ੍ਰੈਡ) ਦੁਆਰਾ ਪਾਸ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਫਿਰ ਕੋਡ ਦੇ ਉਸ ਹਿੱਸੇ ਨੂੰ ਭੇਜੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜੋ ਬੇਨਤੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਮੰਜ਼ਿਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਬੇਨਤੀ ਪ੍ਰਬੰਧਨ ਕੋਡ ਨੂੰ ਇੱਕ ਵੱਖਰੇ ਥ੍ਰੈਡ (ਅਖੌਤੀ ਵਰਕਰ ਥ੍ਰੈਡ, ਸਰਵਲੈਟਸ ਅਤੇ ਜੈਕਸ-ਆਰਐਸ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ) ਦੇ ਅੰਦਰ ਕਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਸਰੋਤ I/O ਥਰਿੱਡ (ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਰੂਟ) ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਮੈਸੇਜਿੰਗ ਸਿਸਟਮ ਕਨੈਕਟਰ Vert.x ਇੰਜਣ ਦੇ ਸਿਖਰ 'ਤੇ ਚੱਲ ਰਹੇ ਗੈਰ-ਬਲਾਕਿੰਗ ਕਲਾਇੰਟਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਇਸ ਲਈ, ਤੁਸੀਂ ਮੈਸੇਜਿੰਗ ਮਿਡਲਵੇਅਰ ਸਿਸਟਮਾਂ ਤੋਂ ਸੁਨੇਹਿਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਭੇਜ, ਪ੍ਰਾਪਤ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦੇ ਹੋ।

ਸਾਈਟ 'ਤੇ Quarkus.io Quarkus ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਨ ਲਈ ਇੱਥੇ ਕੁਝ ਚੰਗੇ ਟਿਊਟੋਰਿਅਲ ਹਨ:

• ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਰੂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
• ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ SQL ਕਲਾਇੰਟ
• ਰਿਐਕਟਿਵ ਮੈਸੇਜਿੰਗ ਨਾਲ ਅਪਾਚੇ ਕਾਫਕਾ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
• ਰਿਐਕਟਿਵ ਮੈਸੇਜਿੰਗ ਨਾਲ AMQP ਦੀ ਵਰਤੋਂ ਕਰਨਾ
• Vertx API ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਅਸੀਂ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਰਿਐਕਟਿਵ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਵੱਖ-ਵੱਖ ਪਹਿਲੂਆਂ ਨੂੰ ਸਿਖਾਉਣ ਲਈ ਔਨਲਾਈਨ ਹੈਂਡਸ-ਆਨ ਟਿਊਟੋਰੀਅਲ ਵੀ ਬਣਾਏ ਹਨ, ਕਿਸੇ IDE ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਅਤੇ ਕਿਸੇ ਕੰਪਿਊਟਰ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਇਹ ਪਾਠ ਲੱਭ ਸਕਦੇ ਹੋ ਇੱਥੇ.

ਉਪਯੋਗੀ ਸ੍ਰੋਤ

• ਕੁਆਰਕਸ ਨੂੰ ਅਜ਼ਮਾਉਣ ਦੇ 4 ਕਾਰਨ
• ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ ਦੀ ਵੈੱਬਸਾਈਟ - quarkus.io
• GitHub 'ਤੇ ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ - github.com/quarkusio/quarkus
• ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ ਟਵਿੱਟਰ - twitter.com/QuarkusIO
• ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ ਚੈਟ - quarkusio.zulipchat.com
• ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ ਫੋਰਮ - group.google.com/forum/#!forum/quarkus-dev

ਵਿਸ਼ੇ ਤੋਂ ਜਾਣੂ ਹੋਣ ਲਈ ਕੁਆਰਕਸ 'ਤੇ 10 ਵੀਡੀਓ ਪਾਠ

ਜਿਵੇਂ ਕਿ ਉਹ ਵੈਬਸਾਈਟ 'ਤੇ ਕਹਿੰਦੇ ਹਨ Quarkus.io, ਕਵਾਕਰਸ - ਹੈ ਕਬਰਨੇਟਿਸ-ਅਧਾਰਿਤ Java ਸਟੈਕ, GraalVM ਅਤੇ OpenJDK HotSpot ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਸਭ ਤੋਂ ਵਧੀਆ Java ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਮਿਆਰਾਂ ਤੋਂ ਇਕੱਤਰ ਕੀਤਾ ਗਿਆ ਹੈ।

ਵਿਸ਼ੇ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਨ ਲਈ, ਅਸੀਂ 10 ਵੀਡੀਓ ਟਿਊਟੋਰਿਅਲ ਚੁਣੇ ਹਨ ਜੋ ਕੁਆਰਕਸ ਦੇ ਵੱਖ-ਵੱਖ ਪਹਿਲੂਆਂ ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਕਵਰ ਕਰਦੇ ਹਨ:

1. ਕੁਆਰਕਸ ਪੇਸ਼ ਕਰਨਾ: ਕੁਬਰਨੇਟਸ ਲਈ ਅਗਲੀ ਪੀੜ੍ਹੀ ਦਾ ਜਾਵਾ ਫਰੇਮਵਰਕ

ਥਾਮਸ ਕਵਾਰਨਸਟ੍ਰੋਮ ਅਤੇ ਜੇਸਨ ਗ੍ਰੀਨ ਦੁਆਰਾ
ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ ਦਾ ਟੀਚਾ ਕੁਬਰਨੇਟਸ ਅਤੇ ਸਰਵਰ ਰਹਿਤ ਵਾਤਾਵਰਣ ਲਈ ਇੱਕ ਜਾਵਾ ਪਲੇਟਫਾਰਮ ਬਣਾਉਣਾ ਹੈ, ਅਤੇ ਇੱਕ ਸਿੰਗਲ ਰਨਟਾਈਮ ਵਾਤਾਵਰਣ ਵਿੱਚ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਅਤੇ ਜ਼ਰੂਰੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਮਾਡਲਾਂ ਨੂੰ ਜੋੜਨਾ ਹੈ ਤਾਂ ਜੋ ਡਿਵੈਲਪਰ ਵੰਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨ ਆਰਕੀਟੈਕਚਰ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਆਪਣੀ ਪਹੁੰਚ ਨੂੰ ਲਚਕਦਾਰ ਢੰਗ ਨਾਲ ਬਦਲ ਸਕਣ। ਹੇਠਾਂ ਦਿੱਤੇ ਸ਼ੁਰੂਆਤੀ ਭਾਸ਼ਣ ਵਿੱਚ ਹੋਰ ਜਾਣੋ।

2. ਕੁਆਰਕਸ: ਸੁਪਰਫਾਸਟ ਸਬਟੌਮਿਕ ਜਾਵਾ

By: Burr Sutter
DevNation ਲਾਈਵ ਦਾ ਇਹ ਵੀਡੀਓ ਟਿਊਟੋਰਿਅਲ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੁਬਰਨੇਟਸ/ਓਪਨਸ਼ਿਫਟ ਵਾਤਾਵਰਨ ਵਿੱਚ ਐਂਟਰਪ੍ਰਾਈਜ਼ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨਾਂ, API, ਮਾਈਕ੍ਰੋਸਰਵਿਸਿਜ਼, ਅਤੇ ਸਰਵਰ ਰਹਿਤ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਕੁਆਰਕਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਬਹੁਤ ਛੋਟਾ, ਤੇਜ਼, ਅਤੇ ਵਧੇਰੇ ਸਕੇਲੇਬਲ ਬਣਾਉਂਦਾ ਹੈ।

3. ਕੁਆਰਕਸ ਅਤੇ ਗ੍ਰੇਲਵੀਐਮ: ਹਾਈਬਰਨੇਟ ਨੂੰ ਸੁਪਰ ਸਪੀਡ ਤੱਕ ਤੇਜ਼ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਸਬ-ਐਟੋਮਿਕ ਆਕਾਰਾਂ ਤੱਕ ਸੁੰਗੜਨਾ

ਲੇਖਕ: ਸਨੇ ਗ੍ਰਿਨਵੇਰੋ
ਪੇਸ਼ਕਾਰੀ ਤੋਂ ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਕੁਆਰਕਸ ਕਿਵੇਂ ਬਣਿਆ, ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਤੁਹਾਨੂੰ ਗੁੰਝਲਦਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਜਿਵੇਂ ਕਿ ਹਾਈਬਰਨੇਟ ORM, ਨੂੰ ਮੂਲ GraalVM ਚਿੱਤਰਾਂ ਦੇ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

4. ਸਰਵਰ ਰਹਿਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਿਤ ਕਰਨਾ ਸਿੱਖੋ

ਲੇਖਕ: ਮਾਰਟਿਨ ਲੂਥਰ
ਹੇਠਾਂ ਦਿੱਤੀ ਵੀਡੀਓ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕੁਆਰਕਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਧਾਰਨ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ ਕਿਵੇਂ ਬਣਾਈ ਜਾਵੇ ਅਤੇ ਇਸਨੂੰ ਨੈਟਿਵ 'ਤੇ ਸਰਵਰ ਰਹਿਤ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਤੌਰ 'ਤੇ ਤਾਇਨਾਤ ਕੀਤਾ ਜਾਵੇ।

5. ਕੁਆਰਕਸ: ਮਜ਼ੇਦਾਰ ਕੋਡਿੰਗ ਕਰੋ

ਲੇਖਕ: ਐਡਸਨ ਯਾਨਾਗਾ
ਤੁਹਾਡੇ ਪਹਿਲੇ ਕੁਆਰਕਸ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਵੀਡੀਓ ਗਾਈਡ, ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ ਕਿ ਕੁਆਰਕਸ ਡਿਵੈਲਪਰਾਂ ਦਾ ਦਿਲ ਕਿਉਂ ਜਿੱਤ ਰਿਹਾ ਹੈ।

6. ਜਾਵਾ ਅਤੇ ਕੰਟੇਨਰ - ਉਹਨਾਂ ਦਾ ਭਵਿੱਖ ਕੀ ਹੋਵੇਗਾ

Mark Little ਵੱਲੋਂ ਪੋਸਟ ਕੀਤਾ ਗਿਆ
ਇਹ ਪੇਸ਼ਕਾਰੀ ਜਾਵਾ ਦੇ ਇਤਿਹਾਸ ਨੂੰ ਪੇਸ਼ ਕਰਦੀ ਹੈ ਅਤੇ ਦੱਸਦੀ ਹੈ ਕਿ ਕੁਆਰਕਸ ਜਾਵਾ ਦਾ ਭਵਿੱਖ ਕਿਉਂ ਹੈ।

7. ਕੁਆਰਕਸ: ਸੁਪਰਫਾਸਟ ਸਬਟੌਮਿਕ ਜਾਵਾ

ਲੇਖਕ: ਦਿਮਿਤਰੀਸ ਐਂਡਰੇਡਿਸ
ਕੁਆਰਕਸ ਦੇ ਫਾਇਦਿਆਂ ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਜਿਨ੍ਹਾਂ ਨੂੰ ਡਿਵੈਲਪਰਾਂ ਤੋਂ ਮਾਨਤਾ ਮਿਲੀ ਹੈ: ਸਾਦਗੀ, ਅਤਿ-ਉੱਚੀ ਗਤੀ, ਵਧੀਆ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਮਿਆਰ।

8. ਕੁਆਰਕਸ ਅਤੇ ਉਪ-ਪਰਮਾਣੂ ਰਾਕੇਟ ਪ੍ਰਣਾਲੀਆਂ

ਲੇਖਕ: ਕਲੇਮੈਂਟ ਐਸਕੋਫੀਅਰ
GraalVM ਦੇ ਨਾਲ ਏਕੀਕਰਣ ਦੁਆਰਾ, ਕੁਆਰਕਸ ਇੱਕ ਅਤਿ-ਤੇਜ਼ ਵਿਕਾਸ ਅਨੁਭਵ ਅਤੇ ਇੱਕ ਉਪ-ਪਰਮਾਣੂ ਰਨਟਾਈਮ ਵਾਤਾਵਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਲੇਖਕ ਕੁਆਰਕਸ ਦੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪੱਖ ਬਾਰੇ ਗੱਲ ਕਰਦਾ ਹੈ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਅਤੇ ਸਟ੍ਰੀਮਿੰਗ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇਸਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ।

9. ਇਕਲਿਪਸ ਮਾਈਕ੍ਰੋਪ੍ਰੋਫਾਈਲ ਵਿੱਚ ਕੁਆਰਕਸ ਅਤੇ ਤੇਜ਼ ਐਪਲੀਕੇਸ਼ਨ ਵਿਕਾਸ

ਲੇਖਕ: ਜੌਨ ਕਲਿੰਗਨ
Eclipse MicroProfile ਅਤੇ Quarkus ਨੂੰ ਮਿਲਾ ਕੇ, ਡਿਵੈਲਪਰ ਪੂਰੇ ਫੀਚਰ ਵਾਲੇ ਕੰਟੇਨਰਾਈਜ਼ਡ ਮਾਈਕ੍ਰੋਪ੍ਰੋਫਾਈਲ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾ ਸਕਦੇ ਹਨ ਜੋ ਕਿ ਦਸਾਂ ਮਿਲੀਸਕਿੰਟਾਂ ਵਿੱਚ ਲਾਂਚ ਹੁੰਦੇ ਹਨ। ਵੀਡੀਓ ਕੁਬਰਨੇਟਸ ਪਲੇਟਫਾਰਮ 'ਤੇ ਤੈਨਾਤੀ ਲਈ ਇੱਕ ਕੰਟੇਨਰਾਈਜ਼ਡ ਮਾਈਕ੍ਰੋਪ੍ਰੋਫਾਈਲ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੋਡ ਕਰਨ ਦੇ ਤਰੀਕੇ ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਜਾਂਦਾ ਹੈ।

10. ਜਾਵਾ, "ਟਰਬੋ" ਸੰਸਕਰਣ

ਲੇਖਕ: ਮਾਰਕਸ ਬੀਲ
ਲੇਖਕ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕੁਆਰਕਸ ਨੂੰ ਸੁਪਰ-ਛੋਟੇ, ਸੁਪਰ-ਫਾਸਟ ਜਾਵਾ ਕੰਟੇਨਰ ਬਣਾਉਣ ਲਈ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ ਜੋ ਅਸਲ ਸਫਲਤਾਵਾਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਨ, ਖਾਸ ਕਰਕੇ ਸਰਵਰ ਰਹਿਤ ਵਾਤਾਵਰਣ ਵਿੱਚ।

ਸਰੋਤ: www.habr.com