Soalan Temuduga Multithreading di Jawa

Di Java, Multithreading melibatkan pelaksanaan dua atau lebih utas serentak, meningkatkan kelajuan proses berdasarkan kapasiti sistem. Multithreading memproses unit terkecil secara serentak, memudahkan pelaksanaan yang lebih pantas. Pembangun menggunakannya untuk tugas seperti animasi, permainan dan mengurus aplikasi besar, menyumbang kepada kecekapan ruang dan masa memori.

Kini, jika anda sedang mencari pekerjaan yang berkaitan dengan Multithreading di Jawa, anda perlu bersedia untuk Soalan Temuduga Multithreading di Jawa. Setiap temuduga sememangnya berbeza berdasarkan profil pekerjaan. Di sini, kami telah menyediakan Soalan Temu Bual Multithreading yang penting di Jawa dengan Jawapannya, yang akan membantu anda berjaya dalam temu duga anda.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Artikel ini akan membentangkan 40 soalan paling penting dan lazim tentang soalan temu bual multithreading di Jawa.

S1. Terangkan keadaan Benang yang berbeza.

Jawapan:
Keadaan benang juga dirujuk sebagai Kitaran Hayat Benang. Di bawah ialah keadaan Benang yang berbeza:

• • Baharu: Ini bermakna utas berada dalam keadaan baharu dan perlu mencipta tika kelas utas sebelum penggunaan kaedah mula.
  • Boleh Dijalankan: Selepas menggunakan kaedah mula, utas berada dalam keadaan boleh jalan dan penjadual tidak memilihnya untuk menjadi utas berjalan.
  • Berjalan: Apabila penjadual urutan dipilih, ia berada dalam keadaan berjalan.
  • Disekat: Ia juga dikenali sebagai Tidak Boleh Dijalankan. Apabila benang tidak layak untuk dijalankan, ia masih hidup.
  • Ditamatkan: Ini ialah keadaan apabila ia keluar daripada kaedah larian atau berada dalam keadaan mati.

S2. Apakah benang dalam Java?

Jawapan: Benang merujuk kepada unit kecil yang mengambil sedikit masa untuk dilaksanakan. Ia terutamanya bebas daripada laluan pelaksanaan. Ia adalah salah satu cara untuk memanfaatkan berbilang CPU yang tersedia dalam mesin. Dengan bantuan berbilang benang, proses tugas CPU menjadi lebih pantas. Java digunakan terutamanya untuk menyediakan sokongan kepada multithreading. Java menyokong multithreading untuk memanfaatkan berbilang pemproses dan meningkatkan prestasi program. Memanjangkan kelas Thread atau melaksanakan antara muka Runnable ialah dua cara untuk membuat thread.

S3. Terangkan perbezaan antara benang dan proses dalam JAVA.

Jawapan: Benang ialah tugas terkecil pelaksanaan dalam proses. Proses ini ialah persekitaran pelaksanaan serba lengkap yang mempunyai lebih daripada satu utas atau berbilang utas. Benang adalah pembahagian proses. Benang mempunyai akses terus kepada segmen data proses, manakala proses mempunyai salinan segmen datanya sendiri. Thread terutamanya berkongsi alamat yang dibuat oleh proses dan proses itu mempunyai alamatnya sendiri.

Benang ini boleh dibuat dengan mudah dan proses penciptaan memerlukan banyak perkara untuk dilakukan. Benang itu boleh berkomunikasi dengan mudah dengan utas lain, manakala proses itu boleh berkomunikasi dengan mudah dengan proses kanak-kanak, tetapi komunikasi antara proses adalah sukar. Benang mempunyai timbunan sendiri, manakala proses berkongsi sumber memori seperti ingatan timbunan, dsb. Jika sebarang perubahan telah dilakukan dalam utas, ia akan menjejaskan semua utas, tetapi dalam proses itu, ia tidak menjejaskan proses lain.

S4. Terangkan tentang Model Memori Java.

Jawapan: Ini adalah Soalan Temuduga multithreading yang biasa ditanya dalam temu bual. Beberapa tanggungjawab biasanya perlu diikuti oleh penguji multithreading dalam industri IT semasa.

Model Memori Java menetapkan set peraturan khusus yang mesti dipatuhi oleh program Java untuk mempamerkan gelagat yang konsisten merentas pelbagai seni bina memori, CPU dan sistem pengendalian. Peraturan ini memainkan peranan penting dalam multithreading. Model memori Java membantu membezakan perubahan yang dilakukan dalam salah satu utas, dan perubahan itu juga harus kelihatan kepada utas lain. Mod ini ialah susunan atur cara yang menyatakan bahawa setiap tindakan urutan berlaku sebelum setiap urutan datang kemudian dalam susunan atur cara.

S5. Terangkan penggunaan pembolehubah Meruap dalam Java Multithreading.

Jawapan: Kata kunci atau pembolehubah yang tidak menentu memastikan pembolehubah kongsi atau contoh menerima kemas kini berterusan apabila berbilang urutan membuat perubahan. Ia adalah pengubah suai khas yang digunakan hanya untuk pembolehubah contoh, bukan kaedah. Mengisytiharkan medan sebagai tidak menentu dalam Java memastikan model memori Java menjamin nilai yang konsisten untuk pembolehubah itu merentas semua urutan. Program ini sentiasa membaca nilai pembolehubah yang tidak menentu dari memori utama, dengan itu mengurangkan kemungkinan ralat ketekalan ingatan. Selain itu, pembolehubah tidak menentu Java yang mewakili rujukan objek boleh menjadi batal. Menggunakan kata kunci yang tidak menentu adalah perlu apabila pembolehubah digunakan merentas berbilang urutan.

S6. Terangkan keadaan perlumbaan dalam benang.

Jawapan: Keadaan perlumbaan berlaku apabila terdapat perlumbaan antara beberapa utas. Keadaan perlumbaan ini disebabkan terutamanya oleh beberapa pepijat atau ralat pengaturcaraan. Benang yang perlu dilaksanakan pada mulanya kehilangan perlumbaan dan kemudian melaksanakan yang kedua dan beberapa perubahan dalam tingkah laku kod yang dirujuk sebagai pepijat bukan deterministik. Ia menjadi salah satu pepijat yang sukar untuk diketahui dan menghasilkan semula kerana sifat rawak benang.

S7. Terangkan rangka kerja cantuman garpu dalam Java.

Jawapan: Rangka kerja cantuman garpu diperkenalkan dalam JDK7. Ia adalah alat yang berkuasa untuk pembangun Java untuk memanfaatkan berbilang pemproses pelayan dunia hari ini. Ia direka terutamanya untuk kerja yang boleh dibahagikan kepada kepingan yang lebih kecil. Matlamat utama adalah untuk menggunakan kuasa pemprosesan yang ada untuk meningkatkan prestasi aplikasi. Ia terutamanya menggunakan algoritma mencuri kerja.

S8. Terangkan kumpulan benang dan penggunaannya dalam Java.

Jawapan: Kolam benang dikenali sebagai kolam benang. Benang biasanya dipanggil sebagai benang pekerja. Penciptaan benang memerlukan kos dari banyak segi, seperti masa dan sumber. Apabila anda mencipta benang pada masa meminta proses, secara amnya, ia memperlahankan masa tindak balas pemproses dan hanya beberapa had dalam bilangan utas boleh dibuat. Oleh itu, kerana dua isu utama ini, kumpulan benang telah dibuat. Di Java, Java API membolehkan kami mencipta pelbagai jenis kumpulan benang, seperti kumpulan benang tunggal, yang hanya mengambil satu proses pada satu masa. Satu lagi ialah kumpulan benang tetap yang mengambil bilangan benang tetap. Kemudian terdapat kumpulan benang cache, kumpulan benang boleh dikembangkan dan terutamanya sesuai untuk banyak tugas.

S9. Bagaimanakah data boleh dikongsi antara urutan?

Jawapan: Ini ialah Soalan Temu Bual multithreading yang paling popular di Jawa yang ditanya dalam temu bual. Beberapa kes ujian popular dalam industri IT semasa.

Data boleh dikongsi antara urutan dengan bantuan menggunakan objek kongsi atau struktur data serentak seperti baris gilir Menyekat. Ia terutamanya mengikut corak pengeluar-pengguna menggunakan tunggu dan memberitahu kaedah yang melibatkan perkongsian objek antara dua urutan.

S10. Bagaimanakah urutan diedarkan dalam ingatan tindanan dan timbunan?

Jawapan: Di Java, setiap urutan mempunyai tindanan sendiri, yang digunakan untuk menyimpan pembolehubah setempat, parameter kaedah dan tindanan panggilan. Memori timbunan ialah ingatan biasa yang dikongsi oleh semua rangkaian.

S11. Bezakan antara benang dan proses.

Jawapan:

S12. Apakah kaedah Java wait() digunakan?

Jawapan: Java menggunakan kaedah notify() dan notifyAll() bersama-sama dengan kaedah wait() untuk melaksanakan penyegerakan dan komunikasi antara benang. Kelas Objek, yang merupakan kelas asas untuk semua kelas Java, mengandungi kaedah ini. Sintaks diberikan di bawah :

public final void wait() throws InterruptedException

Ini bermakna jika anda menggunakan wait(), anda harus sama ada mengisytiharkan bahawa kaedah yang memanggil wait() membuang pengecualian ini atau menangkap InterruptedException.

S13. Bezakan antara Benang pengguna dan Benang daemon?

Jawapan: Benang yang dibuat dalam Java dipanggil Benang Pengguna. Benang Daemon sentiasa berjalan di latar belakang, dan kitaran hayatnya yang lengkap bergantung pada utas utama. Benang daemon yang berjalan di latar belakang tidak akan menghalang JVM daripada menamatkannya. Benang anak yang dibuat daripada benang daemon juga akan menjadi benang daemon.

S14. Apakah cara yang berbeza untuk mencipta Benang dalam Java?

Jawapan:
Benang dalam Java boleh dibuat dalam dua cara:

• Dengan melanjutkan kelas Thread.

class MyThread extends Thread {
public void run() {
// Code to be executed in the new thread
}
}

// Creating and starting the thread
MyThread myThread = new MyThread();
myThread.start();

• Dengan melaksanakan Antara Muka Boleh Dijalankan.

class MyRunnable implements Runnable {
public void run() {
// Code to be executed in the new thread
}
}

// Creating a thread using the Runnable interface
Thread myThread = new Thread(new MyRunnable());
myThread.start();

S15. Apakah kitaran hayat Benang dalam JAVA?

Jawapan: Terdapat soalan temu bual Java biasa mengenai multithreading yang ditanya dalam temu bual. Berikut ialah kitaran hayat Benang:

• Baharu
• Boleh lari.
• Berlari.
• Disekat.
• Ditamatkan.

S16. Apakah yang berlaku jika kita memanggil kaedah run () bagi kelas Thread?

Jawapan: Memanggil kaedah run () secara langsung akan menyusun dan melaksanakan program dengan jayanya, tetapi program yang sama tidak akan dianggap sebagai Thread kerana tiada timbunan panggilan baharu akan dibuat dan program memulakannya pelaksanaan dalam timbunan panggilan yang sama tempat utama sedang berjalan.

Untuk mencipta Thread yang sepatutnya dijalankan dengan tindanan panggilan baharu, seseorang perlu menggunakan kaedah mula () kelas Thread.

S17. Bolehkah kita menjeda pelaksanaan Benang pada masa tertentu?

Jawapan: Ya, ini boleh dicapai di Jawa dengan memanggil sleep () kelas Thread. Kaedah tidur () juga mengambil hujah yang menunjukkan masa dalam milisaat.

S18. Bagaimanakah kita boleh mencapai penjadualan urutan dalam Java?

Jawapan: Ya, penjadualan urutan dalam Java adalah mungkin. Thread dalam Java boleh dijadualkan dalam dua cara, iaitu, Penghirisan Masa dan Penjadualan Pre-emptive.

Mari kita beralih ke Soalan Temuduga Java seterusnya mengenai Multithreading.

S19. Bolehkah Thread dimulakan dua kali?

Jawapan: Tidak, utas tidak boleh dimulakan dua kali. Jika kita cuba memulakan utas dua kali, ia akan membuang "java.lang.IllegalThreadStateException".

S20. Apakah cangkuk penutupan dalam Java?

Jawapan: Ini ialah Soalan Temuduga Java paling popular mengenai Multithreading yang ditanya dalam temu bual. Cangkuk penutupan ialah mekanisme yang digunakan untuk membersihkan sumber apabila JVM dimatikan secara normal atau secara tiba-tiba.

S21. Apakah yang tidak menentu?

Jawapan: Volatile ialah kata kunci dalam java, dan ia boleh digunakan dengan pembolehubah. Jika pembolehubah diisytiharkan sebagai tidak menentu, semua utas akan membaca nilai pembolehubah yang sama daripada memori utama dan bukannya daripada cache; oleh itu, ia menghalang bacaan ralat apabila berbilang benang menggunakan pembolehubah yang sama dalam operasinya.

S22. Bagaimanakah anda melaksanakan benang dalam JAVA?

Jawapan: Java menyediakan dua cara untuk melaksanakan urutan dalam atur cara. Antara muka java.Lang.Runnable mempunyai contoh Java.lang.Satu baris yang memerlukan tugas untuk dilaksanakan melalui tika. Kelas Thread sudah melaksanakan Runnable, jadi pengguna boleh terus mengatasi kaedah run() dengan melanjutkan kelas Thread atau melaksanakan antara muka Runnable.

S23. Bila hendak menggunakan Runnable dan bila hendak menggunakan Thread dalam Java?

Jawapan: Java menyediakan lebih baik untuk melaksanakan antara muka Runnable daripada melanjutkan kelas Thread kerana Java hanya membenarkan warisan tunggal. Kerana kelas boleh melaksanakan berbilang antara muka tetapi hanya memanjangkan satu kelas, ini memberikan fleksibiliti yang lebih besar apabila melibatkan perkongsian kod antara kelas.

S24. Mengapa dikatakan bahawa kelakuan Benang tidak dapat diramalkan?

Jawapan: Sebabnya ialah penjadual benang yang mengendalikan pelaksanaan benang. Penjadual mungkin melakukan persembahan yang berbeza pada platform Windows, UNIX dan LINUX. Semasa melaksanakan, utas yang sama mungkin memberikan output yang berbeza pada pelbagai platform, kadangkala pada platform yang sama. Untuk menyelesaikannya, pengguna boleh mencipta objek Runnable yang sama, mencipta gelung run() dalam kedua-dua utas dan memulakan kedua-dua baris bersama-sama.

Q25. What is a volatile variable in Java, and what is its significance?

Answer: Java facilitates users to share variables present in different threads. A volatile variable acts as a unique modifier that can be used only for instance variables. It provides that a write will happen before any consequent read. The Java memory model ensures the consistency of this variable.

Q26. What is the use of the synchronized keyword? What is the difference between synchronized and volatile keywords?

Answer: The synchronized keyword is used when the goal is to allow only one thread to run at a time in a specific section of code. It can be applied to define four different types of blocks, as shown below:

• Instance methods
• Static methods
• Code blocks inside instance methods
• Code blocks inside static methods

It can be declared as follows:

Public synchronized void example () {}

A volatile variable will never land up in a deadlock as it does not require obtaining any lock. While in synchronized variables, it may end up in a draw if they are not done correctly.

Q27. Why methods like wait(), notify(), and notify all() are present in the object class and not in the Thread class?

Answer: Object class has monitors that allow the Thread to lock an object, while Thread does not have any monitors. The object class’s monitor checks for the thing to see if it is available. Thread class having these methods would not help as multiple threads exist on an object, not vice versa.

Q28. Explain the difference between sleep() and wait() methods.

Answer:

• When the wait() method is called, the monitor moves the Thread from running to waiting for the state. Once a thread is in wait(), then it can move to runnable only when it has notified () or told all () for that object. The scheduler changes the state after this. While in the sleep() method, the state is changed to wait and will return to runnable only after sleep time.
• The wait () method is a part of Java.lang.Object class, while sleep() is a part of Java.lang.Thread class.

Q29. How to force start a thread in Java?

Answer: In Java, multithreading, one cannot force start a thread. Only thread schedulers can control lines and are not exposed to any API for control.

Q30. Does Thread leave object lock when wait() and sleep() methods are called?

Answer: A thread in the sleep() method does not leave the lock and moves to the waiting state. The Thread waits for sleep time to get over.

Q31. Explain the advantages of Multithreading.

Answer :
When it comes to software development, multithreading has several benefits:

1. Enhanced Performance: By utilizing multiple processor cores to execute tasks in parallel, multithreading improves the overall performance of applications.
2. Responsiveness: Multithreading helps applications with graphical user interfaces stay responsive by running background tasks simultaneously.
3. Resource Utilization: By allowing some threads to continue processing while others wait for I/O operations, efficient use of the system’s resources is achieved, maximizing the use of CPU and I/O devices.
4. Maintainability and modularity: Multithreading encourages modular design by assigning distinct threads to handle different functions, which results in code that is easier to read and maintain.
5. Asynchronous Programming: Multithreading makes it possible for tasks to run independently of the main program flow, which is essential for managing events or asynchronous input/output tasks.

Q32. How does time slicing differ from preemptive scheduling?

Answer:
1. Preemptive Scheduling: It is a scheduling technique used by operating systems that allows the system to start or stop a task that is presently underway in order to focus on a higher priority task.

Example: In a preemptive scheduling system, even if a lower-priority task is presently running, it may be preempted from execution if a higher-priority task becomes ready to run.

2. Round Robin Scheduling (Time Slicing): It is a scheduling technique where each process or thread is assigned a fixed time slot or quantum during which it can execute. Once the time slice expires, the next task in the queue is given CPU time.

For instance, if the time slice is set to 10 milliseconds and there are three tasks (A, B, and C), each task receives 10 milliseconds of CPU time in a cyclic fashion (A for 10 ms, then B for 10 ms, and so on).

Q33. What is deadlock?

Answer: Every thread in a system that is waiting for a resource that another waiting thread is holding causes a deadlock. In this case, all of the threads are in a universal waiting state because none of them can continue executing. A deadlock occurs when there is no opportunity for any thread to execute, leading to a halt. Complex circumstances known as deadlocks can impair a program’s regular runtime and possibly lead to coding problems. Maintaining the system’s performance and stability requires controlling and avoiding deadlocks.

Q34. How can a deadlock situation be identified? How is it easily avoidable?

Answer: Tools that display blocked threads, such as thread dumps, can be used to identify deadlocks. TryLock with timeouts, acquiring locks in a consistent order, and reducing lock contention are ways to prevent deadlocks. To lower the chance of deadlocks, properly design multithreaded programs and make use of higher-level concurrency tools.

Q35. Is there a stack for every thread in multithreaded programming?

Answer: Yes, every thread in multithreaded programming has a separate stack. Local variables and details about each thread’s function calls are kept on the stack. Each thread will function independently and have a dedicated area to manage its execution context because of this division.

Q36. How is a thread’s safety achieved?

Answer: A class is considered thread-safe when multiple threads can use its methods or objects concurrently without experiencing conflicts. In multithreaded programming, achieving thread safety is essential to avoiding race situations. This can be done in a few different ways:

• Synchronization: Limiting access to shared resources by employing locks and other mechanisms to make sure that only one thread at a time can access crucial areas.
• Volatile Keyword: Designating variables as volatile ensures consistency by making changes made to the variable by one thread visible to other threads.
• Lock-Based Mechanism: This technique uses explicit locks, like ReentrantLock, to control access to important code segments and stop thread interference.
• Atomic wrapper classes: (such as AtomicInteger and AtomicBoolean) for operations that must be carried out atomically without the need for explicit.

Q37. Tell me the difference between User thread and Daemon thread?

Answer: 

java Thread userThread 
= new Thread(() -> {
/* Thread logic */ 
}); 
userThread.start();

java Thread daemonThread = 
new Thread(() -> { 
/* Thread logic */ 
}); 
daemonThread.setDaemon(true);
daemonThread.start();

Q38. How are daemon threads made?

Answer: The Thread class in Java provides the setDaemon(boolean on) method, which can be used to create daemon threads. When all non-daemon threads have finished running, a daemon thread operates in the background and does not stop the Java Virtual Machine (JVM) from shutting down.

Here’s an easy illustration:

public class DaemonThreadExample {
public static void main(String[] args) {
Thread daemonThread = new Thread(() -> {
while (true) {
// Do some background tasks
System.out.println("Daemon Thread is running");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// Setting the thread as daemon
daemonThread.setDaemon(true);
// Starting the daemon thread
daemonThread.start();
// Main thread
System.out.println("Main thread is finished");
}
}

Output:

Explanation:

The daemonThread.setDaemon(true) line in this example designates the thread as a daemon thread. Regardless of its state, the daemon thread will end when the main thread completes its execution and the JVM terminates.

It is crucial to remember that a thread will throw an IllegalThreadStateException if it is not started as a daemon. You are unable to alter a thread’s daemon status once it has begun.

Q39. How do notify() and notifyAll() differ from one another?

Answer:
1. notify():

• Wakes up one of the threads that are currently waiting on the object.
• The scheduling policy of the JVM determines which thread will be notified, and this decision is not guaranteed.

2. notifyAll():

• Wakes up all the threads that are currently waiting on the object.
• Usually makes sure that every thread in line has an opportunity to obtain the lock and verify the altered state.

Q40. What does it mean to be in a deadlock and when can it happen?

Answer: Multiple processes create a deadlock in computing when they become stuck holding resources, waiting for another process to acquire that resource. This situation prevents any progress and results in mutual blocking between the processes.

When the following four requirements referred to as the Coffman conditions—are satisfied, a deadlock usually results:

• Mutual Exclusion: One or more resources must be kept in a non-sharable mode, which limits the resource’s use to a single process at a time.
• Hold and Wait: A process needs to be holding one resource at a time while it waits to obtain more resources that other processes are holding.
• No Preemption: Resources must be released willingly from a process; they cannot be taken away by force.
• Circular Wait: When two or more processes are in a circular chain, each process is waiting for a resource that the subsequent process in the chain is holding.

Atas ialah kandungan terperinci Soalan Temuduga Multithreading di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!