Soalan satu

Soalan - Perbezaan antara Single Thread Model dan MultiThread

- MultiThread ialah program yang mengandungi dua atau lebih banyak tugas yang boleh
dijalankan secara serentak. Dalam multithreaded benang adalah unit terkecil dispatchable
kod. Ini bermaksud sesuatu program boleh melakukan satu atau lebih tugas serentak.
Multithread lebih pantas dari single thread. Multithreading adalah satu daripada ciri
paling penting Java. Ia membuatkan ia bahasa paling laju untuk dijalanakan pada web.

- Di dalam Single thread semasa satu keterangan kelas dimasukkan, kelas dipanggil
setiap kali instance baru bagi kelas tersebut akan diwujudkan.

Perbezaan antara Single Thread Model dan MultiThread :

Single Thread MultiThread

- boleh dijalankan secara serentak.
- lebih pantas.
- Program mesti memberi perhatian
sepenuhnya pada input papan kekunci
kerana tidak ada keupayaan untuk
mengendalikan lebih dari satu peristiwa
pada satu masa.
- Melakukan tugas satu persatu.
- Perlahan untuk dijalankan pada web.
- Berupaya untuk sesuatu aplikasi
mengekalkan responsif untuk proses input.
Pada MultiThread, jika pelaksanaan blok-
blok utama thread sedang melaksanakan
tugas, aplikasi lain akan berhenti(freeze).

- Di bawah adalah sebuah program yang menjelaskan pemisalan dan permintaan bagi
thread menggunakan antaramuka sebaliknya bagi menyambungkan kelas thread. Untuk
memulakan thread anda perlu menggunakan method start() pada objek anda.

class RunnableThread implements Runnable {

Thread runner;
public RunnableThread() {

}
public RunnableThread(String threadName) {
runner = new Thread(this, threadName);
System.out.println(runner.getName());
runner.start();.
}
public void run() {

System.out.println(Thread.currentThread());
}
}
public class RunnableExample {

public static void main(String[] args) {

Thread thread1 = new Thread(new RunnableThread(), “thread1″);

Thread thread2 = new Thread(new RunnableThread(), “thread2″);
RunnableThread thread3 = new RunnableThread(”thread3″);
thread1.start();
thread2.start();
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {

}
System.out.println(Thread.currentThread());
}
}
Soalan dua

Soalan – Terangkan Lifecycle of thread.

Perbezaan thread :

1. New state – Selepas membina Thread ia akan berada dalam method tetapi
sebelum fungsi start(). Pada ketika ini, Thread masih belum berfungsi.
2. Runnable (Ready-to-run) state - Satu thread bermula daripada Runnable. Satu
thread pertama memasuki runnable selepas method start() kaedah hanya satu
thread boleh dilarikan untuk ini selepas sama ada berlari, menunggu, diam atau
kembali dari fungsi yang terhalang juga. Pada situasi ini satu thread sedang
menunggu untuk satu proses.
3. Running state – Satu thread berada dalam situasi mengurus begitu cara benang
pada masa ini penguatkuasaan. Terdapat beberapa cara untuk memasuki fungsi
Runnable tetapi terdapat hanya sehala untuk memasuki fungsi Running: penjadual
memilih satu thread daripada runnable.
4. Dead state – Satu thread boleh jadi dikira tidak berfungsi atau tamat apabila
fungsi run() selesai. Jika mana-mana thread menyusul fungsi runnable,ia tidak
boleh di run semula.
5. Blocked - satu thread tidak boleh dilarikan disebabkan ia menunggu thread
sebelumnya tamat.
Static void sleep(long millisecond) throws InterruptedException

• Waiting for Notification – Satu thread menunggu untuk arahan daripada satu lagi
thread yang lain. Thread itu menghantar kembali untuk runnable setelah
menghantar arahan daripada satu lagi thread

.
final void wait(long timeout) throws InterruptedException
final void wait(long timeout, int nanos) throws InterruptedException
final void wait() throws InterruptedException

• Blocked on I/O – Thread itu menunggu untuk penyiapan bagi penyekatan

operasi. Satu thread boleh dilarikan disebabkan oleh menunggu sumber I / O.
Dalam kes itu Thread itu menghantar kembali untuk runnable selepas terdapatnya
sumber.

• Blocked for joint completion – Thread boleh dilarikan disini kerana ia

menunggu satu lagi thread yang masih belum sedia.
• Blocked for lock acquisition – Thread boleh dilarikan disini kerana ia menunggu
untuk memperolehi kunci satu objek.
Soalan tiga

Apa itu Deadlock?

Satu set proses atau Thread adalah satu jalan buntu apabila setiap satu Thread sedang
menunggu untuk satu peristiwa yang hanya satu lagi proses di dalam set itu boleh
menyebabkan. Contoh: Satu kebuntuan adalah bagi membina satu graf terarah yang
bucu-bucu adalah Thread atau proses dan yang mata mewakili "adalah menunggu untuk"
hubungan. Jika graf ini mengandungi satu kitaran, sistem itu adalah jalan buntu. Kecuali
sistem itu adalah direkabentuk untuk pulih daripada deadlocks, satu kebuntuan
menyebabkan program atau sistem menyangkut.

Synchronization Deadlocks Dalam Java

Deadlocks boleh terjadi di dalam Java kerana menyelarasakan kata kunci menyebabkan
penguatkuasaan Thread bagi menghalang sementara menunggu untuk kunci, atau
memantau, dikaitkan dengan menentukan objek. Thread mungkin sudah pun memegang
kunci dikaitkan dengan objek-objek lain, dua Thread boleh menjadi satu untuk menunggu
dan melepaskan satu kunci, dalam seperti satu kes, aturcara akan berakhir penantian
selama-lamanya. Contoh berikut itu menunjukkan satu set kaedah-kaedah yang
mempunyai potensi untuk kebuntuan. Kaedah kedua pula ialah mengunci kedua-dua
benda iaitu cacheLock dan tableLock, sebelum aturcara diteruskan. Dalam contoh ini,
membantah pemangku sebagai mengunci adalah global (statik)
Contoh Aturcara

public static Object cacheLock = new Object();

public static Object tableLock = new Object();
...
public void oneMethod() {
synchronized (cacheLock) {
synchronized (tableLock) {
doSomething();
}
}
}
public void anotherMethod() {
synchronized (tableLock) {
synchronized (cacheLock) {
doSomethingElse();
}
}
}

Kini, bayangkan Thread A memanggil oneMethod() manakala benang B serentak

panggilan-panggilan anotherMethod(). Bayangkan terus Thread A mengunci cacheLock,
dan, pada masa yang sama, Thread B mengunci tableLock. Kini Thread adalah jalan
buntus Thread mahupun akan melepaskan kuncinya sehingga ia memperoleh kunci lain,
tetapi mahupun akan dapat memperolehi kunci lain hingga Thread lain memberi ia naik.
Semasa satu Java deadlocks program, deadlocking Thread hanya penantian selama-
lamanya. Manakala Thread lain mungkin terus bergerak, akhirnya anda akan menutup
program, dan meneruskan semula program tersebut.