Di dunia website, tentunya kegiatan request & response menjadi proses utama. Setiap request yang masuk akan diproses oleh sebuah program lalu diberikan outputnya (response). Topik kali ini adalah tentang bagaimana menjalankan proses untuk mengatasi request yang masuk lalu memberikan response-nya.
Kita membuat suatu program yang memproses setiap request lalu memberikan outputnya. Kita punya request yaitu “request”, di-proses dengan menambahkan kata2x “Hasil eksekusi dari :” di depan request masuk. Lalu outputnya di keluarkan. Dalam contoh ini, saya menggunakan Python dan berikut ini contoh prototipe sederhana :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| #!/usr/bin/env python
# buat file bernama test.py
# Ekskusi : python test.py request
import sys
import datetime
import time
__author__ = 'Yodi aditya - re.web.id'
def simpleProgram(request):
start = datetime.datetime.now() # Waktu input masuk
time.sleep(1) # Sleep selama 1 detik
now = datetime.datetime.now() # Waktu output
return request+ ': %s \nresponse: %s ' % (start,now)
""" proses utama ketika melakukan eksekusi ex : python test.py input """
if __name__ == '__main__' :
if len(sys.argv) > 1 :
print(simpleProgram(sys.argv[1]))
else:
print('Tidak ada input! Coba : python test.py request.') |
Contoh ouput program ini :
request: 2011-08-15 14:27:52.789295
response: 2011-08-15 14:27:53.790361
Mari buat asumsi bahwa dalam kasus ini ternyata setiap pengolahan sebuah request membutuhkan waktu 1 detik karena keterbatasan kemampuan server / komputer. Sekarang kita punya pengunjung yang melakukan request tiap 1 detik. Apa yang terjadi? Tentunya program ini akan berjalan lancar bukan?
Nah, bagaimana bila pada 1 detik yang bersamaan, ada 3 visitor yang mengakses program ini?
Kalau gitu kita ubah kode berikut menjadi :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| #!/usr/bin/env python
# buat file bernama test.py
# Ekskusi : python test.py request
import sys
import datetime
import time
__author__ = 'Yodi aditya - re.web.id'
def simpleProgram(request):
start = datetime.datetime.now() # Waktu input masuk
time.sleep(1) # Sleep selama 1 detik
now = datetime.datetime.now() # Waktu output
return request+ ': %s \nresponse: %s ' % (start,now)
""" proses utama ketika melakukan eksekusi ex : python test.py input """
if __name__ == '__main__' :
if len(sys.argv) > 1 :
for i in range(3): # Lakukan 3 kali iterasi
print(simpleProgram(sys.argv[1]))
else:
print('Tidak ada input! Coba : python test.py request.') |
Outputnya :
request: 2011-08-15 14:31:18.284534
response: 2011-08-15 14:31:19.285620
request: 2011-08-15 14:31:19.285862
response: 2011-08-15 14:31:20.286936
request: 2011-08-15 14:31:20.287031
response: 2011-08-15 14:31:21.287550
Dari sini terlihat bahwa program pertama kali melayani visitor 1 ( 18-19 ). Setelah selesai, maka akan melayani request visitor kedua ( 19-20 ). Dan yang terakhir, visitor ketiga (20-21).
Program ini memproses tiap 1 request saja. Setelah 1 request selesai, program baru menerima request berikutnya. Program ini tidak menerima request baru ketika proses request yang diterima belum selesai. Inilah yang disebut Blocking.
Lalu bagaimana kalau kita ingin program yang sedang memproses request bisa menerima request baru? Bagaimana program bisa menjalankan semua request secara simultan/bersamaan?
Dalam kondisi ini, kita membutuhkan Threading, yaitu metode untuk menjalankan semua proses masuk secara simultan. Program mampu menerima request baru sembari memproses request yang lama.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| #!/usr/bin/env python
# buat file bernama test.py
# Ekskusi : python test.py request
import sys
import datetime
import time
import threading
__author__ = 'Yodi aditya - re.web.id'
def simpleProgram(self, request):
start = datetime.datetime.now() # Waktu input masuk
time.sleep(1) # Sleep selama 1 detik
now = datetime.datetime.now() # Waktu output
print '(%s)\n%s: %s \nresponse: %s ' % (self.getName(), request, start,now)
class ThreadClass(threading.Thread):
def __init__(self, target, *args):
self._target = target
self._args = args
threading.Thread.__init__(self)
def run(self):
self._target(self, *self._args)
""" proses utama ketika melakukan eksekusi ex : python test.py input """
if __name__ == '__main__' :
if len(sys.argv) > 1 :
for i in range(3): # Lakukan 3 kali iterasi
t = ThreadClass(simpleProgram, sys.argv[1])
t.start()
else:
print('Tidak ada input! Coba : python test.py request.') |
Outputnya adalah :
(Thread-1)
request: 2011-08-15 15:19:37.864748
response: 2011-08-15 15:19:38.865882
(Thread-3)
request: 2011-08-15 15:19:37.864960
response: 2011-08-15 15:19:38.866367
(Thread-2)
request: 2011-08-15 15:19:37.864887
response: 2011-08-15 15:19:38.866516
Dari sini kelihatan bahwa 3 request bersamaan di-eksekusi langsung oleh program. Semua request di-eksekusi pada 37 dan output pada 38 ( 1 detik proses ).
Penggunaan Threading bisa dilakukan di berbagai bahasa pemograman yang support Threading seperti Python, Java, Clojure, C++ dan lainnya.
Implementasi Threading sangat penting di dunia website. Banyak sekali implementasi threading, seperti mengatasi proses Chatting dimana orang bisa menulis secara bersamaan. Membuat crawler yang mengunjungi berbagai situs lalu mengambil informasinya. Serta menghadapi request masuk secara bersamaan ketika website mendapatkan traffic tinggi.
Dapatkan source code via GitHub di https://github.com/yodiaditya/learning-python
Referensi :
http://linuxgazette.net/107/pai.html
http://www.ibm.com/developerworks/aix/library/au-threadingpython/
