Newsgroup: it.lavoro.informatica
Titolo: java vs c++ - threads - creazione distruzione con pool thread

Visto che i due programmi erano gia pronti e come al solito l'Andrea 
trova scusanti ...
 
IL concetto e' lo stesso del precedente post con i thread sul  nastro di 
partenza
In c++ non esiste nella lib std una classe per il pool quindi uso un 
semplice vector
La macchina di test e' la stessa
 
//ThPool.java
import java.util.concurrent.*;
import java.util.*;
 
public class ThPool{
     public ThPool(int n){
         ExecutorService service = Executors.newFixedThreadPool(n);
         Vector<MyCallable> list = new Vector<MyCallable>();
		list.ensureCapacity(n);
         while(n > 0)
             list.add(new MyCallable(n--));
         try{
             service.invokeAll(list);  //fa partire i threads
         }
		catch(Exception err){
             err.printStackTrace();
         }
         service.shutdown(); //attende che i threads finiscano
     }
     public static void main(String args[]){
         new ThPool(Integer.parseInt(args[0]));
     }
     class MyCallable implements Callable<Integer> {
		int m_id;
         public MyCallable(int id){ m_id=id;}
         public Integer call(){
			//System.out.println(m_id);
			return m_id;
		}
     }
}
 
 
 
//thpool.cpp
#include <iostream>
#include <sstream>
#include <thread>
#include <chrono>
#include <vector>
#include <mutex>
#include <condition_variable>
 
 
#ifdef DISPLAY
static std::mutex g_display_mutex;
#endif
 
static std::mutex g_mutex_start;
static std::condition_variable g_cv;
static bool g_ready;
 
using java_int_t=int32_t;
 
class callable {
	public:
		callable(java_int_t id) : m_id(id) {}
		java_int_t operator()();
	private:
		java_int_t m_id;
};
 
java_int_t callable::operator()() {
#ifdef DISPLAY
	g_display_mutex.lock();
	std::cout << "thread " << m_id << " sleeping...\n";
	g_display_mutex.unlock();
#endif
	std::unique_lock<std::mutex> lck(g_mutex_start);
	g_cv.wait(lck, []{return g_ready;});
	lck.unlock();
#ifdef DISPLAY
	g_display_mutex.lock();
	std::cout << "thread " << m_id << " end\n";
	g_display_mutex.unlock();
#endif
	return m_id;
}
 
template <typename T>
inline T convert(const char* s) {
	T n;
	std::istringstream os(s);
	os >> n;
	return n;
}
 
 
int main(int argc, char** argv) {
	++argv;
	auto n = convert<java_int_t>(*argv);
	std::vector<std::thread> ths;
	ths.reserve(static_cast<std::size_t>(n));
	while (n)
		ths.push_back(std::thread(callable(n--)));
#ifdef DISPLAY
	g_display_mutex.lock();
	std::cout << "start" << std::endl;
	g_display_mutex.unlock();
#endif
	g_ready = true;
	g_cv.notify_all();
	for (auto& th : ths)
		th.join();
}
 
thpool.sh
#!/bin/sh
JAVA_HOME=/opt/jdk1.8.0_192
PATH="$JAVA_HOME/bin:$PATH"
LD_LIBRARY_PATH="$JAVA_HOME/lib:$LD_LIBRARY_PATH"
rm -f a.out *.class *.o
javac -version
javac  ThPool.java
g++ --version
g++ -std=c++11 -Wall -O2  -pthread thpool.cpp
 
for x in 1 2 3
do
	time java ThPool "$1"
	time ./a.out "$1"
done
 
 
+ JAVA_HOME=/opt/jdk1.8.0_192
+ PATH=/opt/jdk1.8.0_192/bin:...
+ LD_LIBRARY_PATH=/opt/jdk1.8.0_192/lib:
+ rm -f a.out ThPool.class 'ThPool$MyCallable.class' '*.o'
+ javac -version
javac 1.8.0_192
+ javac ThPool.java
+ g++ --version
g++-4.8.real (Ubuntu 4.8.4-2ubuntu1~14.04.4) 4.8.4
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
+ g++ -std=c++11 -Wall -O2 -pthread thpool.cpp
+ for x in 1 2 3
+ java ThPool 30000
 
real	0m20.484s
user	0m9.856s
sys	0m2.232s
+ ./a.out 30000
 
real	0m0.584s
user	0m0.096s
sys	0m0.732s
+ for x in 1 2 3
+ java ThPool 30000
 
real	0m19.429s
user	0m9.152s
sys	0m1.876s
+ ./a.out 30000
 
real	0m0.601s
user	0m0.144s
sys	0m0.708s
+ for x in 1 2 3
+ java ThPool 30000
 
real	0m20.779s
user	0m10.280s
sys	0m2.332s
+ ./a.out 30000
 
real	0m0.588s
user	0m0.104s
sys	0m0.724s

 trova scusanti ...
 
Io non ho bisogno di trovare scusanti. Non ho neanche bisogno di tenere la zappa in mano, visto che te le stai dando da solo sui piedi. 
 


lol , cioe' per te la versione con il pool consisterebbe nel piazzare un pool di 30 mila?

          Vector<MyCallable> list = new Vector<MyCallable>();
 
sai spiegare perche' stai usando Vector, minchiolino? 

Il 09/12/18 14:34, Cicap ha scritto:

Vuoi usare una lista od un arrayList ?
Accomodati
 

 sai spiegare perche' stai usando Vector, minchiolino?
 
LOL :) 
 
Perche` gli fai questa domanda? Lui Java lo usa da dieci anni!!

 Vuoi usare una lista od un arrayList ?
 
LOL. La domanda era un'altra: perche` hai usato Vector. La verita` e` che vuoi confrontare Java con altri linguaggi, NON conoscendo Java. Altra zappata sui piedi.
 

import java.util.*; 
import java.util.concurrent.*; 
 
public class ThPool {
     public ThPool(int n){
         ForkJoinPool forkJoinPool = new ForkJoinPool();
         ArrayList<MyCallable> list = new ArrayList<>(n);  
 
         while(n > 0)
             list.add(new MyCallable(n--));
         try{
             forkJoinPool.invokeAll(list);  //fa partire i threads
         }
         catch(Exception err){
             err.printStackTrace();
         }
         forkJoinPool.shutdown(); //attende che i threads finiscano
     }
     public static void main(String args[]){
        new ThPool(Integer.parseInt(args[0]));
        System.exit(0);


          ForkJoinPool forkJoinPool = new ForkJoinPool();
 
Usare un Fork/Join pool a questo modo non serve assolutamente a niente.

      }
 
altra cagata, ti hanno gia' spiegato di guardati come si fanno i benchmark in java e con il jni fra i piedi. Se dopo 945644536476345763453 post non l'hai ancora capito, sei l'essere piu' tonto sulla faccia della terra.

 altra cagata, ti hanno gia' spiegato di guardati come si fanno i benchmark in java e con il jni
 
JIT


no, voglio dire che sai una sega di multithreading in java e che scrivi codice a casaccio. 
 
Siccome il programma "parla di thread" allora sostituisco tutti i list con Vector, vero enoquick? 


L'esempio che ho postato è veloce più del doppio di quello in C++. Inoltre se scommentando il println si vede la differenza rispetto a prima
 
Manco gli esempi a vostro favore ti piacciono?
 
Curati


ecco un altro arrogante. Qualsiasi roba che non pre-alloca 30000 thread va almeno il doppio della merdata che ha scritto enoquick, e il codice in questo senso non commette questo errore anche se non te ne sei accorto....
 
Sostanzialmente ecnoquick sta testando se e' piu' digeribile l'arsenico o il cianuro.

 anche se non te ne sei accorto.... 
 
e pure presuntuoso


quindi se ti sei accorto che quello e' il problema spiega perche' hai introdotto forkjoinpool. Veloce pero'.


Cosa volevi usare, Executors.newCachedThreadPool() ?
 
E' veloce ma comunque più lento del forkjoinpool
 
Comunque facevate prima a postargli quelle due righe di modifica invece di fare i maestrini 
 

Il Sun, 09 Dec 2018 12:31:36 -0600, enoquick ha scritto:
 
[snip]
 
questi test, se proprio ci vogliamo vedere qualcosa, danno la misura di 
quanto sei idiota. e mi spiace dovertelo dire ma questa volta non dai 
scampo.
 
tutti sanno che nella jvm i thread sono risorse costose, non è un caso se 
si usano normalmente i thread pool e il continuo respawn viene 
accuratamente evitato con il riciclo (vedi ad esempio gli application 
server, credi che facciano partire un nuovo thread ad ogni richiesta?).
 
il tuo test invece cosa fa? niente, crea un pool e poi lo riempie di 30 
mila thread che muoiono subito. cioè testi una cosa che giusto un idiota 
con il fischio potrebbe fare. in qualsiasi consesso tu presentassi un 
test del genere ti prenderebbero per il culo a vita, ti ricorderebbero 
come quello che testava se la macchina va più forte col freno a mano 
tirato o senza. da candidatura al premio ignobel, insomma. fortuna tua 
che qui ancora si soffermano sui dettagli marginali, quello che hai 
pubblicato andrebbe messo nel manifesto del gruppo a perenne memoria dei 
livelli di imbecillità raggiunti.
 
 
 

 E' veloce ma comunque più lento del forkjoinpool
 
ok ho capito, l'hai introdotto per fare il fico, anche se non hai la piu' pallida idea di cosa sia :D

Il 09/12/18 15:54, Giuspi ha scritto:

sulla mia macchina con il forkJoinPool
 
java
real	0m26.849s
user	0m25.076s
sys	0m3.324s
 
 
c++
real    0m0.584s
user    0m0.096s
sys    0m0.732s
 
Ti sembra piu veloce di c++?
 
 
 

 Ma anche a 1 non va cosi' male. Anzi, ti diro', siccome sostanzialmente non fa nulla e non si capisce cosa lo zuccone stia testando, puoi anche buttarlo cancellare tutto e lasciare il main vuoto :D
 
 
Il numero di thread e' cosi alto proprio per vedere i tempi di 
costruzione/distruzione th come si evince dal subject
Dove sta la famosa scalabilita di java ?
Fate i ridere i polli e neanche lo ammettete


Il 09/12/18 14:57, 4ndre4 ha scritto:

Ho usato vector perche e' la struttura sequenziale piu efficiente almeno 
in c++
Si spera che lo sia anche per java
Se non e' cosi cambia con qualcosa d'altro, tanto le cose non cambiano
 

 ti basta diminuire la size del pool di quello zuccone del OP, a qualcosa di ragionevole tipo il numero di core.
 
 
$  time java ThPoolFK 4
real	0m0.064s
user	0m0.056s
sys	0m0.000s
 
$  time ./a.out 4
real	0m0.001s
user	0m0.000s
sys	0m0.000s
 
 
Ti va bene cosi ?
 
[CUT]

Il 09/12/18 14:56, 4ndre4 ha scritto:

Veramente lo conosco dagli anni 90
Ma non e' vero che lo uso da dieci anni,l'ultimo sviluppo java che ho 
fatto e' stato nel 2008,da allora solo qualche toccatina qua e la
Quindi smettila di rompere i cosiddetti
 
 

Il 09/12/18 15:49, Cicap ha scritto:

Invece che fare il sapientone spiega spiega
Insultare sono capaci tutti
Fare pochi

 di ragionevole tipo il numero di core.
 
si ma di che stiamo parlando? è inutile impostare un pool size 
ragionevole se poi ci fai una cosa demenziale, tipo riempirlo di 30000 
thread che muoiono all'istante senza fare un cazzo e per di più con la 
pretesa di partire tutti simultaneamente.

 Fate i ridere i polli e neanche lo ammettete
 
visto che ovunque si usano i pool proprio per evitare di creare migliaia di thread, il fatto che tu voglia misurare una cosa del genere evidenzia ancora una volta la tua profonda ignoranza in materia.


no perche' nonostante ti abbia, proprio in questo thread, ricordato che i benchmark NON SI FANNO COSI' nella JVM, specie se i valori sono bassi come in questo caso (e non puoi alzarli per evidenti ragioni).
 
Hai quindi ancora una volta confermato di essere un cretino sesquipedale, impermeabile a qualsiasi spiegazione.


insultare si, dare spiegazioni tecniche come molti stanno facendo no. 
 
Ti e' gia' stato spiegato innumerevoli volte che con il JIT di mezzo bisogna fare il warmup della JVM per ottenere risultati sensati. Inoltre devi misurare la parte di codice rilevante escludendo il tempo di start up della macchina virtuale. Qualsiasi framework di benchmark lo fa.
 
A meno che i tuoi test non siano fatti apposta per un ambiente di scripting dove un idiota a caso il cui nome inizia per eno abbia deciso di usare java come linguaggio (ma anche fosse c++ non sarebbe molto meno idiota :).

 si ma di che stiamo parlando? 
 
Ma di nulla infatti. Interessante pero' la sua "comprensione" di thread e pooling :)

 anche se non hai la piu' pallida idea di cosa sia :D
 
Vabbè se dobbiamo fare assunzioni ad minchiam sul pensiero altrui, pure tu non mi sembri messo tanto meglio dello zuccone

 Se non e' cosi cambia[...]
 
Eh?! Sei tu che hai la pretesa di fare benchmarks, non gli altri. 
 

 Ma non e' vero che lo uso da dieci anni[...]
 
Guarda che lo hai detto tu. Vuoi che ti riquoto, grandissimo bugiardo? 

 Vabbè se dobbiamo fare assunzioni ad minchiam sul pensiero altrui, pure tu non mi sembri messo tanto meglio dello zuccone
 
l'hai dimostrato, inutile che ti dimeni come un serpente.

 Manco gli esempi a vostro favore ti piacciono?
 
"A vostro favore"? A favore di chi? Java non e` "a mio favore". E` un linguaggio che uso, tra gli altri. E tra quegli altri, c'e` C++. Questa appartenenza all'una o all'altra fazione, e` solo nella mente tua e di quel cretino di enoquick.
 

 ecco un altro arrogante. 
 
Io avrei termini migliori per definirlo :)
 

 Comunque facevate prima a postargli quelle due righe di modifica
 
Ma capirai quanto me ne fotte di insegnare a enoquick a programmare in Java.

 Dove sta la famosa scalabilita di java ?
 
Non e` da quello che si misura la "scalabilita`". Sei veramente imbarazzante. Io mi chiedo veramente di cosa campi.

 Invece che fare il sapientone spiega spiega
 
Ma sentitelo. Ma guardatelo. Adesso sono gli altri che fanno i "sapientoni". Lui ha la pretesa di dimostrare che un linguaggio fa schifo sulla base di una conoscenza che *NON* ha, e proponendo cagate che chiama "benchmark", e gli arroganti sarebbero gli altri. "Spiega spiega"? Vatti a studiare Java e poi ritorna, anziche` implorare spiegazioni.
 

Il 10/12/18 03:57, 4ndre4 ha scritto:

Io non sono un esperto di java ma di c++
Se commetto qualche svista in java (ma anche in c++ potrebbe 
succedere,come a  tutti) lo si fa notare e basta.
E senza usare parole offensive come fate voi tutti.
Secondo te perche' posto i source ?
Semplice,perche altre persone possono leggere ed eventualmente fare 
critiche ma costruttive.
Insultare son capaci tutti,fare meno.
 
 

 critiche ma costruttive.
 
Ma a nessun frega una ceppa di muoverti critiche costruttive. Te lo ripeto, e questa volta ficcatelo nel cervello: tu sei un arrogante spocchioso che ha sempre sbandierato l'odio verso un particolare linguaggio pur non conoscendolo affatto. Sei un arrogante spocchioso che si e` messo in testa di confrontare linguaggi che NON conosce. Sei un arrogante spocchioso che fa umorismo da quattro soldi per trarsi d'impaccio dall'angolino in cui si e` rinchiuso. Sei un arrogante spocchioso che accusa gli altri di ritrovarsi una "banda" (non capendo che, se tu sei fazioso, gli altri non lo sono necessariamente). Poi, quando paghi il prezzo per la scia di arroganza, spocchia, stupidaggine e incompetenza che ti lasci dietro, ti travesti da agnellino e reclami fair play? SEI UN IMBECILLE.

 
 
 
E di nuovo
Ti hanno eletto presidente del comitato antibenchmark di enoquick ?
E se non te ne frega niente perche posti ?
Te lo ha ordinato il dottore per curare le tue malattie psicosomatiche ?
 
 
Devo fare un appello:
signore e signori,se non ve ne frega una ceppa dei miei benchmarks 
andate altrove
Se avete voglia di insultare fatelo,tanto a me non mi fa ne caldo ne 
freddo e da ora smetto di rispondere se non a post ragionevoli tanto per 
non perdere tempo inutilmente con dei bambini dell' asilo che non sanno 
fare altre che insultare e basta.
 
 
 

 andate altrove
 
O magari smetti di farne. I "post ragionevoli", con tanto di fatti e numeri, ti sono stati messi davanti. Li hai ignorati. Buffone.

 scalabilita di java ?
 
quindi quel test demenziale in cui crei decine di migliaia di thread a 
vuoto secondo te darebbe una misura della scalabilità? 
roba da chiodi...


Sarebbe anche interessante sentire cosa sta misurando di diverso nella versione "pooled" rispetto all'altra. 
 
La verita' e' che e' di una comicita' involontaria ineguagliabile, dio lo preservi :D

 versione "pooled" rispetto all'altra.
 
per completare il quadro della sua ignoranza. prima ti chiedi che senso 
abbia creare decine di migliaia di thread che muoiono subito senza fare 
un cazzo, poi quando vedi che crea un pool della stessa dimensione tutto 
ti è più chiaro: non capisce proprio una sega nulla sul tema.