DZone Snippets: threads code

Ruby Threading

jrobertson (James Robertson) — Tue, 11 Mar 2008 23:00:52 GMT

Uses Ruby (version 1.8) threading to run code in parallel which reduces the time taken for the script to complete.



require 'ping' #from core classes

@ip_prefix='192.168.1.'



def ping_ip(i)

  puts "Found #{@ip_prefix + i.to_s}" if Ping.pingecho(@ip_prefix+i.to_s,1)

end



p50 = Thread.new{(1..50).each{|i| ping_ip(i) };puts 'p50-finished'}

p100 = Thread.new{(51..100).each{|i| ping_ip(i) };puts 'p100-finished'}

p150 = Thread.new{(101..150).each{|i| ping_ip(i) }; puts 'p150-finished'}

p200 = Thread.new{(151..200).each{|i| ping_ip(i) }; puts 'p200-finished'}

p254 = Thread.new{(201..254).each{|i| ping_ip(i) }; puts 'p254-finished'}

output:



Found 192.168.1.2

Found 192.168.1.3

Found 192.168.1.8

Found 192.168.1.9

Found 192.168.1.10

Found 192.168.1.11

Found 192.168.1.12

Found 192.168.1.13

Found 192.168.1.15

Found 192.168.1.110

Found 192.168.1.21

Found 192.168.1.22

Found 192.168.1.140

p50-finished

p150-finished

Found 192.168.1.200

p200-finished

p100-finished

Found 192.168.1.254

p254-finished

This script took about 1 minute to complete, whereas the non-threaded script took around 4 minutes to complete.

Reference: Ruby Threads: RUBY THREADS [rubylearning.com]

*update 11:21pm*
I tried the same experiment again this time with 26 threads (9 pings each on average) and the script finished in under 15 seconds.

*update 11:39pm*
A separate thread for each ping seems to work best, since it only took a couple of seconds to finish.



(1..254).each{|i| Thread.new {puts 'Found ' + ip_prefix + i.to_s if Ping.pingecho(ip_prefix+i.to_s,10)}}

"Extend" the thread class in csharp

PWeaver (charlie parker) — Fri, 29 Jun 2007 16:14:22 GMT

//just inherit from the EasyThread class and override the PerformWork method

public class EasyThread: IDisposable
{
Thread WorkerThread;
public EasyThread()
{
if (WorkerThread == null)
WorkerThread = new Thread(new ThreadStart(PerformWork));
}

public void Run()
{
if (WorkerThread.IsAlive == false)
WorkerThread.Start();

if (WorkerThread.ThreadState == ThreadState.Suspended)
WorkerThread.Resume();
}

///

/// EasyThread provides a facade to inheriting from a Thread class.
/// Override the perform work method to perform your tasks.
///

protected virtual void PerformWork()
{

}

public void Pause()
{
WorkerThread.Suspend();
}

public void Quit()
{
Cleanup();
}

private void Cleanup()
{
WorkerThread.Join(0);
WorkerThread = null;
}

public void Dispose()
{
Cleanup();
}
}

ParBegin en C++ .net

jcongote (John Edgar Congote Calle) — Fri, 22 Sep 2006 20:59:45 GMT

Codigo para crear la funcion ParBegin cuyo objetivo es obtener como parametros cualquier cantidad de funciones y ejecutarlas de forma paralela, cada una de ellas en un hilo independiente.

El objetivo de esta implementacion es realizar el mismo codigo en C++ manejado esto conlleva a algunas restricciones como la imposibilidad de usar ParBegin(...) debido a que segun el documento de Migration_guide de Microsoft dentro de Visual Studio .NET 2003, la utilizacion de los 3 puntos para implementar argumentos variables dentro de una funcion genera inmediatamente que esta funcion sea no manejada y presentan la solucion dentro del mismo documento, documentacion sobre esto tambien se encuentra en el documento managedextensionsspec.doc en la pagina 35.

El uso de punteros dentro de C++ manejado no es posible, por lo tanto para pasar como argumento de una funcion, otra funcion, lo que se debe hacer es generar un delegate, pero con estoy hay un pequeño impedimento, y es que las funciones deben hacer parte de una clase, osea que no se pueden crear delegates a funciones sino a metodos.

Con las 2 caracteristicas anteriores en mente mostramos el codigo para de ParBegin para Visual C++ Manejado

Este codigo pertenece a John Edgar Congote y puede ser modificado, copiado, distribuido, ejecutado, visualizado o manipulado por cualquier medio sin previa autorizacion del autor.





#include "stdafx.h"



#using 



using namespace System;

using namespace System::Threading;



public __gc class MiHilo{

public:

	MiHilo(){

	

	};



	~MiHilo(){

	

	};



	static void funcionHilo(){

		Console::WriteLine(S"Este es un hilo....");

		Thread::Sleep(1000);	//Bloquea el hilo durante 1 segundo.

		Console::WriteLine(S"Saliendo del hilo...");

	}

};







void ParBegin([ParamArray] ThreadStart * args[]){

	int cont;

	for (cont=0;contLength;cont++){		

		Thread *oThread = new Thread(args[cont]);

		oThread->Start();

	}	

}





int _tmain(void)

{ 



	/*

	

	Los argumentos que se pasan a la funcion es el arreglo de delegados

	que los hilos van a ejecutar.



	Hay que recordar que ThreadStart es un delegate definido en .NET



	*/

	

	ThreadStart * args[] = {new ThreadStart(0,&MiHilo::funcionHilo),new ThreadStart(0,&MiHilo::funcionHilo),new ThreadStart(0,&MiHilo::funcionHilo)};



	Console::WriteLine(S"Entrando a ParBegin");

	ParBegin(args);

	Console::WriteLine(S"Saliendo de ParBegin");

	Thread::Sleep(2000); //Durmiendo 2 Segundos

	Console::WriteLine(S"Finalizando Programa");

	return 0;

}