PERTEMUAN III(SISTEM TERDISTRIBUSI)

BAB III

PROCESSES

Dalam bab sebelumnya, kami berkonsentrasi pada komunikasi dalam sistem terdistribusi. Komunikasi terjadi antara proses, dan dalam bab ini, kita melihat lebih dekat bagaimana berbagai jenis proses memainkan peran penting dalam sistem terdistribusi. Konsep proses berasal dari bidang sistem operasi mana secara umum didefinisikan sebagai program dalam eksekusi. Dari perspektif sistem operasi, manajemen dan penjadwalan proses mungkin adalah masalah yang paling penting untuk menangani. Namun, ketika datang ke sistem terdistribusi, masalah lain ternyata sama atau lebih penting.

Misalnya, untuk efisien dalam mengatur sistem client-server, hal ini sering membuat kita nyaman untuk teknik multithreading. Seperti yang kita bahas dalam bagian pertama, kontribusi utama benang dalam sistem terdistribusi adalah bahwa mereka memungkinkan klien dan server yang akan dibangun sedemikian rupa sehingga komunikasi dan pengolahan lokal dapat tumpang tindih, sehingga tingkat kinerja yang tinggi.

Seperti yang kita bahas dalam Bab. I, client-server organisasi yang penting dalam sistem terdistribusi. Dalam bab ini, kita melihat lebih dekat pada organisasi yang khas dari kedua klien dan server. Kami juga memperhatikan masalah desain umum untuk server, yang dari penambahan sarana dasar, kami mempertimbangkan server objek tujuan umum, yang membentuk sarana dasar untuk melaksanakan obyek terdistribusi.

Suatu hal yang penting, terutama di wide-area sistem terdistribusi, proses bergerak antara mesin yang berbeda. Proses migrasi atau lebih khusus, migrasi kode, dapat membantu dalam mencapai skalabilitas, tetapi juga dapat membantu untuk secara dinamis mengkonfigurasi klien dan server. Apa yang sebenarnya dimaksud dengan migrasi kode dan apa implikasinya yang juga dibahas dalam bab ini.

Kami subjek penawaran terakhir dengan fenomena yang akan datang, yaitu bahwa dari agen perangkat lunak. Berbeda dengan model client-server agak asimetris, sistem multiagen kasar terdiri dari kumpulan agen-sama penting yang secara kolektif berusaha untuk mencapai tujuan bersama. Seorang agen software adalah jenis belum anouther proses dan dapat datang dalam bentuk yang berbeda. Mengambil perspektif terdistribusi-sistem, apa agen adalah, dan bagaimana agen berkolaborasi, dibahas dalam bagian terakhir.

3.1 Thread

Meskipun proses membentuk sebuah blok diagram dalam sistem terdistribusi, pada prakteknya menunjukkan bahwa rincian dari proses seperti yang disediakan oleh sistem operasi pada sistem terdistribusi yang dibangun tidak cukup. Sebaliknya, ternyata bahwa dengan memiliki rincian yang lebih baik dalam bentuk beberapa thread kontrol per proses membuat lebih mudah untuk membangun aplikasi terdistribusi dan untuk mencapai kinerja yang lebih baik. Dalam bagian ini, kita melihat lebih dekat pada peran thread dalam sistem terdistribusi dan menjelaskan mengapa mereka begitu penting. Terlebih pada thread dan bagaimana mereka dapat digunakan untuk membangun aplikasi.

Thread merupakan unit dasar dari penggunaan CPU, yang terdiri dari Thread_ID, program counter, register set, dan stack. Sebuah thread berbagi code section, data section, dan sumber daya sistem operasi dengan thread lain yang dimiliki oleh proses yang sama. Thread juga sering disebut lightweight process. Sebuah proses tradisional atau heavy weight process mempunyai thread tunggal yang berfungsi sebagai pengendali. Perbedaan antara proses dengan thread tunggal dengan proses dengan thread yang banyak adalah proses dengan thread yang banyak dapat mengerjakan lebih dari satu tugas pada satu satuan waktu. Banyak perangkat lunak yang berjalan pada PC modern dirancang secara multi-threading. Sebuah aplikasi biasanya diimplementasi sebagai proses yang terpisah dengan beberapa thread yang berfungsi sebagai pengendali. Contohnya sebuah web browser mempunyai thread untuk menampilkan gambar atau tulisan sedangkan thread yang lain berfungsi sebagai penerima data dari network. Kadang kala ada situasi dimana sebuah aplikasi diperlukan untuk menjalankan beberapa tugas yang serupa. Sebagai contohnya sebuah web server dapat mempunyai ratusan klien yangmengaksesnya secara concurrent. Kalau web server berjalan sebagai proses yang hanya mempunyai thread tunggal maka ia hanya dapat melayani satu klien pada pada satu satuan waktu. Bila ada klien lain yang ingin mengajukan permintaan maka ia harus menunggu sampai klien sebelumnya selesai dilayani. Solusinya adalah dengan membuat web server menjadi multi-threading. Dengan ini maka sebuah web server akan membuat thread yang akan mendengar permintaan klien, ketika permintaan lain diajukan maka web server akan menciptakan thread lain yang akan melayani permintaan tersebut.

3.1.1 Introduction to Threads

Untuk memahami peran thread dalam sistem terdistribusi, penting untuk memahami apa suatu proses, dan bagaimana proses dan thread berhubungan. Untuk mengeksekusi sebuah Program, sebuah sistem operasi menciptakan sejumlah prosesor virtual, masing-masing untuk menjalankan program yang berbeda. Untuk melacak prosesor virtual, operasi sistem memiliki tabel proses, mengandung catatan untuk menyimpan daftar nilai CPU , memori peta, file terbuka, informasi akunting. Hak istimewa, dll Suatu proses sering didefinisikan sebagai sebuah program dalam eksekusi, yaitu, sebuah program yang saat ini sedang dieksekusi di salah satu prosesor virtual sistem operasi. Suatu hal yang penting adalah bahwa sistem operasi membutuhkan perhatian besar untuk memastikan bahwa proses yang independen tidak bisa merugikan atau tidak sengaja mempengaruhi ketepatan dari perilaku masing-masing. Dengan kata lain, bahwa beberapa proses dapat dirangkap dibagi CPU yang sama dan sumber daya perangkat keras lainnya dibuat transparan. Biasanya, operasi sistem memerlukan dukungan hardware untuk melaksanakan pemisahan ini.

Transparansi Hal ini konkurensi membutuhkan biaya yang relatif tinggi. Sebagai contoh, setiap kali sebuah proses dibuat, sistem operasi harus membuat lengkap ruang alamat yang independen. Alokasi dapat berarti menginisialisasi memori dengan segmen, misalnya, zeroing data segmen, menyalin program yang berkaitan ke dalam teks segmen, dan mengatur stack untuk data sementara. Demikian juga, CPU beralih antara dua proses mungkin relatif mahal juga. Selain dari penghematan CPU konteks (yang terdiri dari nilai-nilai , program counter, stack pointer, dll), sistem operasi juga akan harus memodifikasi register memori unit manajemen (MMU) dan cache membatalkan terjemahan alamat seperti di terjemahan lookaside buffer (TLB). Selain itu, jika sistem operasi mendukung proses lebih dari itu secara bersamaan dapat terus di memori utama, mungkin harus menukar proses antara memori utama dan disk sebelum beralih yang sebenarnya dapat mengambil tempat.

Seperti proses, sepotong thread mengeksekusi kode sendiri, secara independen dari thread lainnya. Namun, berbeda dengan proses, tidak ada usaha dibuat untuk mencapai transparansi konkurensi tingkat tinggi jika ini akan mengakibatkan penurunan kinerja. Oleh karena itu, sistem benang umumnya hanya mempertahankan informasi minimum untuk memungkinkan CPU untuk digunakan bersama oleh beberapa thread. Secara khusus, konteks threads sering terdiri dari tidak lebih dari konteks CPU, bersama dengan beberapa informasi lain untuk manajemen thread. Sebagai contoh, sistem thread ini dapat terus melacak fakta bahwa thread saat ini diblokir pada variabel mutex, sehingga tidak pilih untuk eksekusi. Informasi yang tidak benar-benar diperlukan untuk mengelola beberapa thread umumnya diabaikan. Untuk alasan ini, melindungi data terhadap patut akses dengan thread dalam proses tunggal sepenuhnya diserahkan ke aplikasi pengembang.

Ada dua implikasi penting dari pendekatan ini. Pertama-tama, kinerja
dari aplikasi multithreaded hampir tidak pernah lebih buruk daripada pendamping single-threaded. Bahkan, dalam banyak kasus, multithreading mengarah pada keuntungan kinerja. Kedua, karena thread tidak secara otomatis dilindungi jalan prosesnya terhadap satu sama lain, pengembangan aplikasi multithreaded membutuhkan tambahan intelektual usaha. Tepat desain dan menjaga hal-hal sederhana.

Multithreading juga berguna dalam konteks aplikasi besar. seperti aplikasi yang sering dikembangkan sebagai kumpulan program yang bekerja sama, masing-masing untuk dieksekusi oleh proses yang terpisah. Pendekatan ini adalah khas untuk lingkungan UNIX.
Kerjasama antara program-program dilaksanakan dengan cara komunikasi interprocess (IPC) mekanisme. Untuk sistem UNIX, mekanisme ini biasanya mencakup (bernama) pipa, antrian pesan, dan segmen memori bersama, Kelemahan utama dari semua mekanisme IPC adalah bahwa komunikasi sering memerlukan konteks switching yang luas.

Penggunaan Thread dalam Sistem Nondistributed

Sebelum membahas peran threads dalam sistem terdistribusi, mari kita pertama mempertimbangkan penggunaannya dalam tradisional, sistem nondistributed. Ada beberapa manfaat untuk proses multithreaded yang telah meningkatkan popularitas menggunakan sistem thread.

Manfaat yang paling penting berasal dari fakta bahwa dalam proses single-threaded, setiap kali system call bloking dijalankan, proses secara keseluruhan diblokir. Untuk mengilustrasikan, pertimbangkan sebuah aplikasi seperti program spreadsheet, dan menganggap bahwa pengguna terus menerus dan interaktif ingin mengubah nilai-nilai. Sebuah properti penting dari program spreadsheet adalah bahwa ia mempertahankan dependensi fungsional antara sel-sel yang berbeda, sering dari spreadsheet yang berbeda. Oleh karena itu, setiap kali sel yang dimodifikasi, semua sel bergantung secara otomatis diperbarui. Ketika pengguna mengubah nilai dalam satu sel, seperti modifikasi dapat memicu serangkaian besar perhitungan. Jika hanya ada satu thread tunggal kontrol, perhitungan tidak dapat melanjutkan sementara program ini menunggu input. Demikian juga, tidak mudah untuk memberikan masukan, sementara dependensi sedang dihitung. Solusi mudah adalah dengan memiliki minimal dua thread kontrol: satu untuk menangani interaksi dengan pengguna dan satu untuk memperbarui spreadsheet.

Keuntungan lain dari multithreading adalah bahwa hal itu menjadi mungkin untuk mengeksploitasi paralelisme ketika menjalankan program pada sistem multiprosesor. Dalam hal ini, setiap thread yang ditugaskan untuk CPU yang berbeda sedangkan data bersama disimpan dalam memori utama bersama. Ketika benar dirancang, paralelisme tersebut dapat transparan: proses akan berjalan sama baiknya pada sistem uniprocessor, meskipun lambat. Multithreading untuk paralelisme menjadi semakin penting dengan tersedianya workstation multiprosesor relatif murah. Sistem komputer tersebut biasanya digunakan untuk menjalankan server di klien-server aplikasi.

Multithreading juga berguna dalam konteks aplikasi besar. Aplikasi ini sering dikembangkan sebagai kumpulan program bekerja sama, masing-masing akan dieksekusi oleh proses yang terpisah. Pendekatan ini khas untuk lingkungan UNIX. Kerjasama antara program diimplementasikan dengan cara interprocess (IPC) mekanisme komunikasi. Untuk sistem UNIX, mekanisme ini biasanya mencakup (bernama) pipa, antrian pesan, dan segmen memori bersama (lihat juga Stevens, 1992). Kelemahan utama dari semua mekanisme IPC adalah bahwa komunikasi sering memerlukan switching konteks yang luas, yang ditunjukkan pada tiga titik yang berbeda pada Gambar. 3-1.

Gambar 3-1. Konteks beralih sebagai hasil dari IPC.

Karena IPC memerlukan intervensi kernel, proses umumnya akan pertama-tama harus beralih dari mode pengguna ke mode kernel, ditampilkan sebagai S 1 pada Gambar. 3-1. Hal ini membutuhkan perubahan peta memori di MMU, serta pembilasan TLB. Dalam kernel, switch konteks proses berlangsung (S 2 dalam gambar), setelah itu pihak lain dapat diaktifkan dengan beralih dari mode kernel ke mode user lagi (S 3 dalam Gambar. 3-1). Saklar yang terakhir lagi membutuhkan perubahan peta MMU dan disiram TLB.

Alih-alih menggunakan proses, aplikasi juga dapat dibangun sedemikian rupa sehingga bagian yang berbeda yang dijalankan oleh thread terpisah. Komunikasi, antara bagian-bagian sepenuhnya menangani dengan menggunakan data bersama. Thread beralih kadang-kadang dapat dilakukan sepenuhnya di ruang pengguna, althrought dalam implementasi lain, kernel menyadari thread dan jadwal mereka. Efeknya bisa menjadi perbaikan dramatis dalam kinerja.

Akhirnya, ada juga alasan rekayasa perangkat lunak murni menggunakan thread: banyak aplikasi hanya lebih mudah untuk struktur sebagai koleksi thread bekerja sama. Pikirkan aplikasi yang membutuhkan tindakan melakukan beberapa tugas (lebih atau kurang mandiri). Sebagai contoh, dalam kasus pengolah kata, thread yang terpisah dapat digunakan untuk menangani input pengguna, ejaan dan memeriksa tata bahasa, tata letak dokumen, generasi indeks, dll

Thread Implementasi

            Thread sering disediakan dalam bentuk paket Thread. Paket seperti ini berisi operasi untuk menciptakan dan menghancurkan thread serta operasi tentang sinkronisasi variabel seperti mutexes dan variabel kondisi. Pada dasarnya ada dua pendekatan untuk menerapkan paket Thread. Pendekatan pertama adalah untuk membangun library thread yang dieksekusi seluruhnya dalam mode pengguna. Pendekatan kedua adalah memiliki kernel harus menyadari thread dan jadwal mereka.

Sebuah perpustakaan Thread user-level memiliki sejumlah keunggulan. Pertama, itu murah untuk menciptakan dan menghancurkan thread. Karena semua administrasi thread disimpan dalam pengguna ruang alamat, harga menciptakan thread terutama ditentukan oleh biaya untuk mengalokasikan memori untuk mengatur tumpukan Thread. Analog, menghancurkan thread terutama melibatkan memori membebaskan untuk stack, yang tidak lagi digunakan. kedua operasi yang murah.

Keuntungan kedua dari user-level thread, adalah bahwa konteks switching benang sering dapat dilakukan hanya dalam beberapa instruksi. Pada dasarnya, hanya nilai-nilai dari register CPU perlu disimpan dan kemudian mengisi dengan nilai-nilai yang tersimpan sebelumnya dari benang yang ia sedang diaktifkan. Tidak perlu mengubah peta memori, siram TLB, melakukan akuntansi CPU, dan sebagainya. Konteks thread switching dilakukan ketika dua thread harus melakukan sinkronisasi, misalnya, ketika memasuki bagian data bersama.

Namun, kelemahan dari user-level thread adalah bahwa permintaan dari system call blocking akan segera memblokir seluruh proses yang benang milik, dan dengan demikian juga semua benang lainnya dalam proses tersebut. Seperti yang kita menjelaskan, benang sangat berguna untuk menyusun aplikasi besar menjadi bagian-bagian yang dapat dieksekusi secara logis pada waktu yang sama. Sementara itu. Untuk aplikasi tersebut, pengguna tingkat benang tidak membantu.

Masalah-masalah ini dapat sebagian besar dielakkan dengan menerapkan threads di kernel sistem operasi. Sayangnya, ada harga yang harus dibayar: setiap operasi thread (penciptaan, penghapusan, sinkronisasi, dll), harus dilakukan oleh kernel, membutuhkan system call. Switching konteks thread sekarang dapat menjadi semahal beralih konteks proses. Akibatnya, sebagian besar manfaat menggunakan thread bukan proses kemudian menghilang.

Solusi terletak pada bentuk hibrida user-level dan kernel-level threads, umumnya disebut sebagai proses ringan (LWP). LWP Sebuah berjalan dalam konteks sebuah proses tunggal (berat-berat), dan bisa ada beberapa LWPs per proses. Selain memiliki LWPs, sistem juga menawarkan paket thread user-level, menawarkan aplikasi operasi biasa untuk menciptakan dan menghancurkan thread. Selain itu, paket menyediakan fasilitas untuk sinkronisasi thread, seperti mutexes dan variabel kondisi (lihat juga Sec. 1,4). Masalah improtant adalah bahwa paket thread diimplementasikan sepenuhnya dalam ruang pengguna. Dengan kata lain, operasi SLL pada thrad yang keluar tanpa intervensi dari kernel.

3-2. Menggabungkan kernel-tingkat proses ringan dan user-level threads.

Paket thread dapat berbagi dengan LWPs beberapa, seperti ditunjukkan pada Gambar. 3.2. Ini berarti bahwa LWP masing-masing dapat berjalan sendiri (user-level) thread. Aplikasi multithreaded dibangun dengan menciptakan thread, dan kemudian menetapkan setiap thread untuk LWP suatu. Menetapkan thread untuk LWP yang biasanya implisit dan tersembunyi dari programmer.

Kombinasi (level user) thread dan LWPs bekerja sebagai berikut. Paket thread memiliki rutinitas tunggal untuk menjadwalkan thread berikutnya. Ketika membuat dan LWP (yang dilakukan dengan cara system call), LWP diberi tumpukan sendiri, dan diperintahkan untuk melaksanakan rutinitas penjadwalan mencari thread untuk mengeksekusi. Jika ada beberapa LWPs, maka masing-masing mengeksekusi scheduler. Tabel thread, yang digunakan untuk melacak set saat thread, dengan demikian dibagi oleh LWPs. Melindungi tabel ini untuk menjamin akses eksklusif, dilakukan dengan cara mutexesthat dilaksanakan seluruhnya di userspace. Dalam kata-kata, sinkronisasi antara LWPs tidak memerlukan dukungan kernel.

Ketika suatu LWP menemukan thread runnable, itu switch konteks untuk thread tersebut. Sementara itu, LWPs lain dapat mencari thread runnable lain juga. Jika thread perlu blok pada variabel mutex atau kondisi, ia melakukan administrasi yang diperlukan dan akhirnya panggilan rutin penjadwalan. Ketika thread lain runnable telah ditemukan, sebuah saklar konteks dibuat untuk thread tersebut. Keindahan dari semua ini adalah bahwa LWP mengeksekusi thread tidak perlu diberitahu: saklar konteks diimplementasikan sepenuhnya dalam ruang pengguna dan muncul ke LWP sebagai kode program normal.
Sekarang mari kita lihat apa yang terjadi ketika sebuah thread melakukan system call blocking. Dalam kasus ini, pelaksanaan perubahan dari mode pengguna ke mode kernel, tetapi masih berlanjut dalam konteks LWP saat ini. Pada titik di mana teh LWP saat ini tidak bisa lagi melanjutkan, sistem operasi dapat memutuskan untuk beralih konteks lain LWP, yang juga menyiratkan bahwa sebuah saklar konteks dibuat kembali ke mode pengguna. The LWP dipilih hanya akan terus di mana ia sebelumnya tinggalkan.

Ada beberapa keuntungan menggunakan LWPs dalam kombinasi dengan paket thread user-level. Pertama, menciptakan, menghancurkan, dan sinkronisasi thread relatif murah dan tidak melibatkan intervensi kernel sama sekali. Kedua, menetapkan bahwa proses memiliki LWPs cukup, panggilan systemm memblokir tidak akan menghentikan seluruh proses. Ketiga, tidak ada kebutuhan untuk sebuah aplikasi untuk mengetahui tentang LWPs. Semua itu adalah melihat user-level thread. Keempat, LWPs dapat dengan mudah digunakan dalam multiprocessing dapat disembunyikan sepenuhnya dari aplikasi. Satu-satunya kelemahan proses ringan dalam kombinasi dengan user-level thread adalah bahwa kita masih perlu membuat dan menghancurkan LWPs, yang hanya semahal dengan kernel-level threads. Namun, menciptakan dan menghancurkan LWPs perlu dilakukan hanya sesekali, dan sering sepenuhnya dikendalikan oleh sistem operasi.

Sebuah alternatif, tetapi pendekatan yang mirip dengan proses ringan, adalah untuk memanfaatkan aktivasi scheduler (Anderson et al., 1992). Perbedaan penting antara aktivasi scheduler dan LWPs, adalah bahwa ketika blok thread pada system call, kernel tidak upcall untuk paket thread, efektif memanggil rutin scheduler untuk memilih thread runnable berikutnya. Prosedur yang sama diulang ketika thread yang diblokir. Keuntungan dari pendekatan ini adalah bahwa hal itu menghemat pengelolaan LWPs oleh kernel. Namun, penggunaan upcalls dianggap kurang elegan, karena melanggar struktur sistem berlapis, di mana panggilan hanya ke lapisan yang lebih rendah-tingkat berikutnya yang diizinkan.

3.1.2 Threads dalam Sistem Terdistribusi

Sebuah properti penting dari thread adalah bahwa mereka dapat menyediakan sarana yang mudah digunakan yang memungkinkan panggilan sistem memblokir tanpa menghalangi seluruh proses di mana thread berjalan. Properti ini membuat thread sangat menarik untuk digunakan dalam sistem terdistribusi karena membuat lebih mudah untuk mengekspresikan komunikasi dalam bentuk mempertahankan koneksi logis beberapa pada saat yang sama. Kami menggambarkan ini titik dengan melihat lebih dekat pada klien dan server multithreaded, masing-masing.

Multithreaded Clients

Untuk membuat distribusi tingkat transparansi yang tinggi, sistem terdistribusi yang beroperasi di jaringan yang luas mungkin perlu untuk menyembunyikan pesan interprocess yang panjang perambatan waktu. Penundaan round-trip dalam jaringan area luas dengan mudah dapat dalam urutan ratusan milidetik. atau kadang-kadang bahkan detik.

Cara biasa untuk menyembunyikan komunikasi latency adalah untuk memulai komunikasi dan segera melanjutkan dengan sesuatu yang lain. Sebuah contoh yang khas di mana hal ini terjadi dalam browser Web. Dalam banyak kasus, sebuah dokumen Web terdiri dari HTML file yang berisi teks biasa bersama dengan koleksi gambar, ikon, dll. Untuk mendapatkan setiap elemen dari sebuah dokumen Web, browser harus mengatur koneksi TCPIIP, membaca data yang masuk, dan menyebarkannya ke suatu komponen tampilan. Menyiapkan koneksi serta membaca data yang masuk secara inheren memblokir operasi. Ketika berurusan dengan komunikasi jarak jauh, kita juga memiliki kelemahan bahwa waktu untuk setiap operasi untuk menyelesaikan mungkin relatif yang panjang

Akibatnya, terlihat bahwa browser Web yang melakukan beberapa tugas secara bersamaan. Ternyata, mengembangkan browser sebagai klien multithreaded menyederhanakan hal jauh. Begitu file HTML utama telah diambil, yang terpisah thread dapat diaktifkan untuk mengurus mengambil bagian-bagian lainnya. Setiap set thread koneksi terpisah untuk server dan menarik dalam data. Menyiapkan koneksi dan membaca data dari server dapat diprogram dengan menggunakan standar (pemblokiran) panggilan sistem, dengan asumsi bahwa pemblokiran panggilan tidak menangguhkan seluruh proses. kode untuk setiap thread adalah yang sama dan, di atas semua, sederhana. Sementara itu, pengguna hanya penundaan pemberitahuan di layar gambar dan semacamnya, tapi selain dapat menelusuri melalui dokumen.

Sekarang perhatikan bagaimana file server mungkin telah ditulis dalam ketiadaan thread. Salah satu kemungkinan adalah untuk memilikinya beroperasi sebagai thread tunggal. Pengulangan utama file server mendapat permintaan, memeriksa, dan membawanya keluar sampai selesai sebelum mendapatkan satu berikutnya. Sambil menunggu disk, server dalam keadaan idle dan bukan Proses permintaan lainnya. Akibatnya, permintaan dari klien lain tidak dapat ditangani. Selain itu, jika file server berjalan pada mesin khusus, seperti biasanya terjadi, CPU hanya menganggur sedangkan file server menunggu disk. Hasil akhirnya adalah bahwa banyak permintaan sedikit / detik dapat diproses. Jadi thread mendapatkan kinerja yang cukup besar, namun masing-masing thread diprogram secara berurutan, dengan cara yang biasa.

Sejauh ini kita telah melihat dua desain yang mungkin: sebuah file server multithreaded dan single-threaded file server. Misalkan bahwa benang tidak tersedia, tetapi sistem desainer menemukan kerugian kinerja karena tidak dapat diterima threading tunggal. Sepertiga kemungkinan adalah untuk menjalankan server sebagai mesin terbatas-negara besar. Ketika permintaan dating dalam, thread satu dan hanya memeriksa itu. Jika dapat dipenuhi dari cache, baik, tetapi jika tidak, pesan harus dikirim ke disk.

Namun, bukan menghalangi, itu mencatat keadaan permintaan saat ini dalam meja dan kemudian pergi dan mendapat pesan berikutnya. Pesan berikutnya dapat berupa permintaan untuk pekerjaan baru atau balasan dari disk tentang operasi sebelumnya. Jika kerja baru, pekerjaan yang dimulai. Jika itu adalah balasan dari disk, informasi yang relevan diambil dari meja dan jawaban diproses dan selanjutnya dikirim ke klien. Dalam skema ini, server akan memiliki untuk menggunakan panggilan Nonblocking untuk mengirim dan menerima.

Multithreaded Server

Thread yaitu kemampuan yang disediakan oleh Java untuk membuat aplikasi yang tangguh, karena thread dalam program memiliki fungsi dan tugas tersendiri. Dengan adanya thread, dapat membuat program yang lebih efisien dalam hal kecepatan maupun penggunaan sumber daya, karena kita dapat membagi proses dalam aplikasi kita pada waktu yang sama. Thread umumnya digunakan untuk pemrograman multitasking, networking, yang melibatkan pengaksesan ke sumber daya secara konkuren.

Ada dua cara yang bisa digunakan dalam membuat sebuah thread, yaitu :

1. Membuat subclass dari thread

Untuk menjalankan thread, dapat dilakukan dengan start(). Saat start() dijalankan, maka sebenarnya method dijalankan. Jadi untuk membuat thread, harus mendefinisikan pada definisi class. Konstruktor dari cara ini adalah :

ClassThread namavar = new ClassThread();

Namavar.start();

Atau dapat juga langsung dengan cara:

New ClassThread().start();

2. Mengimplementasikan interface Runnable

Cara ini merupakan cara yang paling sederhana dalam membuat thread. Runnable merupakan unit abstrak, yaitu kelas yang mengimplementasikan interface ini hanya cukup mengimplementasikan fungsi run(). Dalam mengimplementasi fungsi run(), kita akan mendefinisikan instruksi yang membangun sebuah thread. Konstruktor dari cara ini adalah :

ObjekRunnable objek = new ObjekRunnable();

Thread namavar = new Thread(Objek Runnable);

Atau dengan cara singkat seperti :

New Thread(new ObjekRunnable());

Multi Threading

Arti istilah Multithreading dianggap berkaitan erat dengan pengertian multi thread merupakan jalannya beberapa proses dengan urutan yang cepat (multitasking) dalam satu program. Multithreading ini merupakaan teknik pada manipulasi data dimana node-node pada struktur pohon data berisi penunjuk ke node yang lebih tinggi untuk membuat lintasan struktur menjadi lebih efisien.

Kalau sebelumnya kita telah mempelajari tentang proses, namun seiring berjalannya waktu dan tuntutan teknologi ternyata ditemukan kelemahan yang sebenarnya bisa diminimalisir pada proses. Untuk itulah diciptakan thread yang merupakan cara dari komputer untuk menjalankan dua atau lebih task dalam waktu bersamaan, sedangkan multithreading adalah cara komputer untuk membagi-bagi pekerjaan yang dikerjakan sebagian-sebagian dengan cepat sehingga menimbulkan efek seperti menjalakan beberapa task secara bersamaan walaupun otaknya hanya satu.

Keuntungan MultiThreading

Multiprocessing merupakan penggunaan dua atau lebih CPU dalam sebuah sistem komputer. Multitasking merupakan metode untuk menjalankan lebih dari satu proses dimana terjadi pembagian sumberdaya seperti CPU. Multithreading adalah cara pengeksekusian yang mengizinkan beberapa thread terjadi dalam sebuah proses, saling berbagi sumber daya tetapi dapat dijalankan secara independen. Keuntungan dari sistem yang menerapkan multithreading dapat kita kategorikan menjadi 4 bagian :

1.    Responsif. Aplikasi interaktif menjadi tetap responsif meskipun sebagian dari program sedang diblok atau melakukan operasi lain yang panjang. Umpamanya, sebuah thread dari web browser dapat melayani permintaan pengguna sementara thread yang lain berusaha menampilkan gambar.

2.    Berbagi sumber daya. Beberapa thread yang melakukan proses yang sama akan berbagi sumber daya. Keuntungannya adalah mengizinkan sebuah aplikasi untuk mempunyai beberapa thread yang berbeda dalam lokasi memori yang sama.

3.    Ekonomis. Pembuatan sebuah proses memerlukan pengalokasian memori dan sumber daya. Alternatifnya adalah dengan menggunakan thread, karena thread membagi memori dan sumber daya yang dimilikinya sehingga lebih ekonomis untuk membuat thread dan context switching thread. Akan susah mengukur perbedaan waktu antara thread dan switch, tetapi secara umum pembuatan dan pengaturan proses akan memakan waktu lebih lama dibandingkan dengan thread. Pada Solaris, pembuatan proses memakan waktu 30 kali lebih lama dibandingkan pembuatan thread sedangkan proses context switch 5 kali lebih lama dibandingkan context switching thread.

4.    Utilisasi arsitektur multiprosesor. Keuntungan dari multithreading dapat sangat meningkat pada arsitektur multiprosesor, dimana setiap thread dapat berjalan secara paralel di atas procesor yang berbeda. Pada arsitektur processor tunggal, CPU menjalankan setiap thread secara bergantian tetapi hal ini berlangsung sangat cepat sehingga menciptakan ilusi paralel, tetapi pada kenyataanya hanya satu thread yang dijalankan CPU pada satu-satuan waktu.

Model MultiThreading

Beberapa terminologi yang akan dibahas: 

1.    Thread pengguna: Thread yang pengaturannya dilakukan oleh pustaka thread pada tingkatan pengguna. Karena pustaka yang menyediakan fasilitas untuk pembuatan dan penjadwalan thread, thread pengguna cepat dibuat dan dikendalikan.

2.    Thread Kernel: Thread yang didukung langsung oleh kernel. Pembuatan, penjadwalan dan manajemen thread dilakukan oleh kernel pada kernel space. Karena dilakukan oleh sistem operasi, proses pembuatannya akan lebih lambat jika dibandingkan dengan thread pengguna.

Model-Model MultiThreading: 

1.    Model Many-to-One. Model ini memetakan beberapa thread tingkatan pengguna ke sebuah thread. tingkatan kernel. Pengaturan thread dilakukan dalam ruang pengguna sehingga efisien. Hanya satu thread pengguna yang dapat mengakses thread kernel pada satu saat. Jadi Multiple thread tidak dapat berjalan secara paralel pada multiprosesor. Contoh: Solaris Green Threads dan GNU Portable Threads.

2.    Model One-to-One. Model ini memetakan setiap thread tingkatan pengguna ke setiap thread. Ia menyediakan lebih banyak concurrency dibandingkan model Many-to-One. Keuntungannya sama dengan keuntungan thread kernel. Kelemahan model ini ialah setiap pembuatan thread pengguna memerlukan tambahan thread kernel. Karena itu, jika mengimplementasikan sistem ini maka akan menurunkan kinerja dari sebuah aplikasi sehingga biasanya jumlah thread dibatasi dalam sistem. Contoh: Windows NT/XP/2000 , Linux, Solaris 9.

3.    Model Many-to-Many. Model ini memultipleks banyak thread tingkatan pengguna ke thread kernel yang jumlahnya sedikit atau sama dengan tingkatan pengguna. Model ini mengizinkan developer membuat thread sebanyak yang ia mau tetapi concurrency tidak dapat diperoleh karena hanya satu thread yang dapat dijadwalkan oleh kernel pada suatu waktu. Keuntungan dari sistem ini ialah kernel thread yang bersangkutan dapat berjalan secara paralel pada multiprosessor.

Kesimpulan
Thread adalah alur kontrol dari suatu proses. Keuntungan menggunakan Multithreading: 

1. Meningkatkan respon dari pengguna.

2. Pembagian sumber daya.

3. Ekonomis.

4. Mengambil keuntungan dari arsitektur multiprosessor.

Tiga model Multithreading: 

1. Model Many-to-One.

2. Model One-to-One.

3. Model Many-to-Many.

Walaupun ada manfaat penting untuk klien multithreaded, seperti yang telah kita lihat, penggunaan utama dari multithreading dalam sistem terdistribusi ditemukan di sisi server. Praktek menunjukkan multithreading yang tidak hanya simplifiels kode server jauh, tetapi juga membuat lebih mudah untuk mengembangkan server yang mengeksploitasi paralelisme untuk mencapai kinerja tinggi, bahkan pada sistem prosesor tunggal. Namun, sekarang komputer multiprosesor yang tersedia secara luas sebagai general - workstation tujuan, multithreading untuk paralelisme bahkan lebih berguna.

Untuk memahami manfaat dari benang untuk menulis kode server, mempertimbangkan organisasi file server yang kadang-kadang memiliki untuk memblokir menunggu disk. File server biasanya menunggu permintaan masuk untuk operasi file, kemudian melakukan permintaan, dan kemudian mengirimkan kembali jawabannya. Salah satu organisasi yang mungkin, dan sangat populer ditunjukkan pada gambar. 3.3. di sini satu thread, dispatcher, membaca permintaan yang masuk untuk operasi file. Permintaan dikirim oleh klien ke titik akhir dengan baik-tahu server ini. Setelah memeriksa permintaan, server memilih sebuah thread (i, e., Diblokir) pekerja menganggur dan memberikannya permintaan.

Gambar 3.3 server multithreaded yang diorganizir dalam model operator / pekerja

Hasil pekerja dengan melakukan membaca memblokir pada sistem file lokal, yang dapat menyebabkan thread untuk ditunda sampai data yang diambil dari disk. Jika benang ditunda, thread lain dipilih untuk dieksekusi. Sebagai contoh, operator tersebut dapat dipilih untuk mendapatkan lebih banyak pekerjaan. Atau, thread lain pekerja dapat dipilih yang sekarang siap untuk menjalankan.

Sekarang mempertimbangkan bagaimana file server dapat ditulis dengan tidak adanya benang. Salah satu kemungkinan adalah untuk memilikinya beroperasi sebagai thread tunggal. Lingkaran utama dari file server mendapat permintaan, meneliti, dan membawanya keluar sampai selesai sebelum mendapatkan yang berikutnya. Sambil menunggu disk, server idle dan tidak memproses permintaan lainnya. Akibatnya, permintaan dari klien lain tidak dapat ditangani. Selain itu, jika file server berjalan pada mesin khusus, seperti yang biasanya terjadi, CPU hanya menganggur sementara file server menunggu disk. Hasil bersih adalah bahwa banyak sedikit requsts / sec dapat diproses. Ini benang mendapatkan kinerja yang cukup, namun setiap thread diprogram secara berurutan, dengan cara yang biasa.

Sejauh ini kita telah melihat dua desain yang mungkin: file server multithreaded dan file server single-threaded. Misalkan bahwa benang tidak tersedia tetapi perancang sistem menemukan hilangnya kinerja karena tidak dapat diterima threading tunggal. Kemungkinan ketiga adalah untuk menjalankan server sebagai mesin finite-negara besar. Ketika permintaan datang, benang satu dan hanya memeriksa itu. Jika dapat dipenuhi dari cache, baik tetapi jika tidak, pesan harus dikirim ke disk.

Namun, bukannya menghalangi, itu mencatat keadaan permintaan saat di meja dan kemudian pergi dan mendapatkan pesan berikutnya. Pesan berikutnya dapat berupa permintaan untuk pekerjaan baru atau balasan dari disk tentang operasi sebelumnya. Jika itu adalah pekerjaan baru, pekerjaan yang dimulai. Jika itu adalah balasan dari disk, informasi yang relevan diambil dari meja dan jawabannya diproses dan kemudian dikirim ke klien. Dalam skema ini, server harus menggunakan panggilan nonblocking untuk mengirim dan menerima.

Dalam desain ini, "proses sekuensial" Model yang kita miliki dalam dua kasus pertama hilang. Keadaan perhitungan harus secara eksplisit disimpan dan dikembalikan dalam tabel untuk setiap pesan yang dikirim dan diterima. Akibatnya, kita simulasi benang dan tumpukan mereka dengan cara yang keras. Proses ini sedang dioperasikan sebagai mesin finite-state yang mendapat suatu peristiwa dan kemudian bereaksi untuk itu tergantung pada apa yang ada di dalamnya.

Model	Characteristics
Threads	Parallelism, blocking system calls
Single-threaded process	No parallelism, blocking system calls
Finite-state machine	Parallelism, nonblocking system calls

Gambar 3-4. tiga cara untuk membangun server

Ini tidak harus jelas apa benang tawarkan. Mereka memungkinkan untuk mempertahankan gagasan proses berurutan yang membuat system call blocking dan masih mencapai paralelisme. System call blocking membuat program lebih mudah dan paralelisme meningkatkan kinerja. Server single-threaded mempertahankan kemudahan memblokir panggilan sistem, tetapi menyerah kinerja. Pendekatan terbatas mesin-negara mencapai kinerja tinggi melalui paralelisme, tetapi menggunakan non-blocking panggilan, sehingga sulit untuk program. Model ini diringkas dalam gambar 3-4.

3.2 CLIENTS

Dalam bab-bab sebelumnya kita membahas model client-server, peran klien dan server, dan cara mereka berinteraksi. Mari kita sekarang Tahe melihat lebih dekat pada anatomi klien dan server, masing-masing. Kita mulai di bagian ini dengan diskusi tentang klien. Server dibahas pada bagian berikutnya.

3.2.1 User Interfaces

Tugas utama dari kebanyakan klien adalah untuk berinteraksi dengan pengguna manusia dan remote server. Mendukung antarmuka kepada pengguna adalah fitur kunci dari kebanyakan klien. Dalam mengandalikan timbulnya banyak, antarmuka antara pengguna dan server remote relatif sederhana dan terintegrasi dengan hardware klien. Misalnya, telepon selular memiliki tampilan sederhana dikombinasikan dengan satu set tradisional kunci untuk nomor panggilan. Yang lebih canggih yang juga menawarkan fasilitas e-mail, dapat dilengkapi dengan keyboard lengkap, pad elektronik, atau unit untuk pengenalan suara.

Sebuah kelas penting dibentuk oleh antarmuka pengguna grafis. Pada halaman berikut, pertama-tama kita melihat lebih dekat pada sistem jendela X sebagai contoh dari antarmuka pengguna grafis yang lebih tradisional. Kami kemudian mempertimbangkan antarmuka modern yang mendukung komunikasi langsung antara aplikasi.

X Window System

The X Window System, umumnya refferedto hanya sebagai X, yang digunakan untuk mengontrol bit-dipetakan terminal, yang meliputi monitor, keyboard, dan perangkat penunjuk seperti mouse. Dalam arti, X dapat dilihat sebagai bagian dari sistem operasi yang mengontrol terminal. Jantung dari sistem dibentuk oleh apa yang kita sebut kernel X. Ini berisi semua terminal-spesifik device driver, dan dengan demikian, umumnya sangat tergantung pada perangkat keras.

Kernel X menawarkan Sebuah antarmuka yang relatif rendah tingkat untuk mengendalikan layar, tetapi juga untuk menangkap peristiwa dari keyboard dan mouse. Ini antarmuka dibuat tersedia untuk aplikasi sebagai perpustakaan yang disebut Xlib. Ini organisasi umum ditunjukkan pada gambar 3-5 (di X terminologi, kernel X disebut sebagai server X, sedangkan program yang memanfaatkan fitur-fiturnya, disebut X klien. Untuk menghindari memar dengan standar client-server terminologi, kita menahan diri dari menggunakan pengertian dari X server dan client X).

X membedakan antara dua jenis program aplikasi: aplikasi normal dan window manager. Aplikasi normal pada umumnya meminta (melalui Xlib) penciptaan jendela pada layar, yang mereka kemudian digunakan untuk input dan pengolahan output. Selain itu, X akan memastikan bahwa setiap kali jendela aplikasi yang aktif, yaitu, ketika mouse menunjuk di dalam jendela itu, bahwa semua kejadian dari keyboard dan mouse arepassed ke aplikasi.

Gambar 3-5. organisasi dasar dari X Windows System

Sebuah window manager adalah sebuah aplikasi yang diberikan izin khusus untuk memanipulasi seluruh layar. Aplikasi normal harus mematuhi pembatasan manipulasi layar dilaksanakan oleh window manager. Misalnya, window manager dapat memutuskan bahwa jendela tidak mungkin tumpang tindih, atau bahwa jendela harus selalu ditampilkan dalam warna yang sama. Akibatnya, window manager menentukan "tampilan dan nuansa" dari sistem window secara keseluruhan.

Aspek menarik dari X, adalah bahwa kernel X dan aplications X tidak perlu selalu berada pada mesin yang sama. Secara khusus, X menyediakan protokol X, yang merupakan jaringan yang berorientasi protokol komunikasi dimana sebuah instance dari Xlib dapat bertukar data dan peristiwa dengan kernel X. Hal ini menyebabkan sangat berbeda jenis client-server organisasi di mana tingkat kecanggihan klien dapat bervariasi. Dalam dari yang paling sederhana, klien berjalan hanya kernel X, sedangkan semua kode aplikasi pada mesin remote. Terminal tha dikonfigurasi seperti ini, sering disebut terminal X. Dalam bentuk yang paling canggih, mesin klien mengandung berbagai aplikasi, termasuk window manager, dan hampir tidak ada jaringan komunikasi yang diperlukan.

Adalah penting untuk menyadari bahwa user-interface sistem seperti X pada dasarnya tidak memberikan lebih dari antarmuka grafis untuk aplikasi. Satu-satunya informasi bahwa aplikasi dapat harapkan dari sistem tersebut adalah peristiwa identirying tindakan pengguna dasar yang secara langsung berhubungan dengan perangkat yang terpasang pada terminal. Contoh peristiwa tersebut adalah yang keystrokes tentang, posisi mouse, operasi tombol, dll

Compound Documents

Seperti yang telah disebutkan di bab 1, antarmuka pengguna yang modern melakukan lebih banyak daripada sistem seperti X. khususnya, mereka memungkinkan aplikasi untuk berbagi jendela grafis tunggal, dan menggunakan jendela ti pertukaran data melalui tindakan pengguna. Tindakan tambahan yang dapat dilakukan oleh pengguna termasuk apa yang umumnya disebut drag-and-drop operasi, dan di tempat mengedit masing-masing.

Sebuah contoh khas drag dan drop fungsional bergerak ikon yang mewakili file, aa ke ikon yang mewakili tempat sampah, sehingga file yang dihapus. Dalam kasus ini, bahwa antarmuka pengguna akan perlu melakukan lebih dari sekedar mengatur icon pada layar, maka akan harus melewati nama file A ke aplikasi yang terkait dengan sampah dapat sesegera ikon A telah dipindahkan di atas dari sampah aplikasi. Contoh lain dengan mudah datang ke pikiran.

Dalam editing ditempatkan terbaik dapat digambarkan dengan cara teks dokumen yang berisi dan grafis. Bayangkan bahwa dokumen sedang ditampilkan dalam pengolah kata standar. Begitu pengguna menempatkan mouse di atas gambar, user interface melewati informasi tersebut untuk aplikasi gambar untuk memungkinkan pengguna untuk memodifikasi gambar. Misalnya, pengguna mungkin telah diputar gambar, yang dapat mempengaruhi penempatan gambar dalam dokumen. User interface sehingga tahu pengolah kata. Yang terakhir, pada gilirannya dapat secara otomatis memperbarui tata letak halaman dokumen.

Ide kunci di balik antarmuka pengguna adalah gagasan dari sebuah dokumen senyawa, yang dapat didefinisikan sebagai kumpulan dokumen, mungkin dari kibds sangat diferent (seperti teks, gambar, spreadsheet, dll). Yang secara scamlessly terintegrasi di tingkat user interface. Seorang pengguna dalam terface yang dapat menangani dokumen senyawa menyembunyikan fakta bahwa aplikasi yang berbeda beroperasi pada bagian yang berbeda dari dokumen. kepada pengguna semua bagian yang terintegrasi dalam cara yang mulus. Ketika mengubah bagian lain, antarmuka pengguna dapat mengambil tindakan yang tepat, misalnya dengan memberitahukan aplikasi yang relevan.

Analog dengan situasi yang dijelaskan untuk sistem window X, aplikasi yang terkait dengan dokumen senyawa tidak perlu mengeksekusi pada machine.however klien, harus jelas bahwa pengguna antarmuka yang mendukung dokumen senyawa mungkin harus melakukan pengolahan lebih banyak yang mereka yang tidak.