In C ++, sono stato abituato a utilizzare i thread nel modo seguente :
#include <iostream>
#include <thread>
#include <mutex>
std::mutex m;
int i = 0;
void makeACallFromPhoneBooth()
{
m.lock();
std::cout << i << " Hello Wife" << std::endl;
i++;
m.unlock();//man unlocks the phone booth door
}
int main()
{
std::thread man1(makeACallFromPhoneBooth);
std::thread man2(makeACallFromPhoneBooth);
man1.join();
man2.join();
return 0;
}
Ma quando ho visto i tutorial su multithreading Java , l'intera classe sembra gestire l'avvio e l'esecuzione del thread Uniti.
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo( String name){
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start ()
{
System.out.println("Starting " + threadName );
if (t == null)
{
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( "Thread-1");
R1.start();
}
}
La domanda:
- Bisogna cambiare il modo in cui si progettano le classi solo per essere in grado fare uso del threading?
- Se ho già un programma creato senza threading e lo voglio
introdurre il threading, avrei potuto farlo facilmente in C ++. Ma qui, esso
sembra che dovrò ridisegnare l'intera classe o renderla ereditaria
da
Runnable. È davvero così che lavori con i thread Java o lo sono dovevi progettarlo per il threading fin dall'inizio invece di introdurlo più tardi?
Un esempio di una classe che sto usando è questo:
public class abc extends abcParent {
//many member variables and functions here
public calculateThreshold() {
for(int i = 0; i<zillion; ++i) {
doSomethingThatIsParallelizable();
}
}//calculateThreshold
private doSomethingThatIsParallelizable() {
while(something) {
//do something else which is parallelizable
}//while
}//doSomething
}//class
L'utilizzo degli stream non è apparentemente consigliabile , quindi, come si fa a progettare una classe per il threading? Non sembra logico che abc abbia le funzioni start e run . È sciocco. abc riguarda solo la funzionalità di abc . Chiamerei abcInstance.calculateThreshold(); e avrebbe senso, ma chiamare abcInstance.run() anziché calculateThreshold() non ha la stessa leggibilità. Cosa consiglieresti?