Beispiel zur sequentiellen und parallelen Ausführung von Tasks @ tutorials.de: Tutorials, Forum & Hilfe

**Thomas Darimont** · 19.08.07 22:28

Hallo,

hier mal ein Beispiel für ein kleines Task-Executions System zur sequentiellen und parallelen Ausführung von Tasks. Dabei kann man den Code der innerhalb eines Tasks ausgeführt wird über zwei Arten bereit Stellen. Zum einen kann man ein delegate (siehe Runnable) definieren und dieses an einen generischen Task übergeben oder von Task ableiten und die Execute Methode überschreiben.

Viel Spaß

Das Beispiel:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
    public class TastExecutorExample
    {
        public static void Main(string[] args)
        {
            ITaskExecutor taskExecutor = new TaskExecutor();
 
            Stopwatch stopWatch = new Stopwatch();
 
         int numberOfTasks = 5;
 
            Console.WriteLine("Sequential Task Execution");
            stopWatch.Start();
            for (int i = 0; i < numberOfTasks; i++)
            {
                //Example for custom Tasks
                ITask<int, int> task = new CustomTask();
                task.Argument = i;
                taskExecutor.Execute(task);
                Console.WriteLine(task + " result -> " + task.Result);
            }
            stopWatch.Stop();
            Console.WriteLine("Execution took: " + stopWatch.Elapsed.Seconds + " seconds");
 
            Console.WriteLine("###############################");
            Console.WriteLine("Parallel Task Execution:");
            taskExecutor.TaskExecutionStrategy = new ThreadPoolTaskExecutionStrategy();
 
            Runnable<ITask<int, int>> runnable = delegate(ITask<int, int> task)
            {
                for (int i = 0; i < 5; i++)
                {
                    Console.WriteLine(task + ": " + i);
                    Thread.Sleep(1000);
                }
                task.Result = task.Argument * task.Argument;
            };
 
            stopWatch.Reset();
            stopWatch.Start();
            IList<IFuture<ITask<int, int>>> futures = new List<IFuture<ITask<int, int>>>();
            for (int i = 0; i < numberOfTasks ; i++)
            {
                //Example for generic Tasks
                ITask<int, int> task = new Task<int, int>(runnable);
                task.Argument = i;
                futures.Add(taskExecutor.Schedule(task));
            }
 
            foreach (IFuture<ITask<int, int>> future in futures)
            {
                ITask<int, int> task = future.Get();
                Console.WriteLine(task + " result -> " + task.Result);
            }
            stopWatch.Stop();
            Console.WriteLine("Execution took: " + stopWatch.Elapsed.Seconds + " seconds");
 
            Console.WriteLine("##################");
            Console.WriteLine("Get Single result with no timeout");
 
            ITask<int, int> singleTask = new Task<int, int>(runnable);
            singleTask.Argument = 11;
            Console.WriteLine(taskExecutor.Schedule(singleTask).Get() + ": " + singleTask.Result); 
 
            Console.WriteLine("##################");
            Console.WriteLine("Get Single result with timeout 3s");
            singleTask = new Task<int, int>(runnable);
            singleTask.Argument = 11;
            try
            {
                Console.WriteLine(taskExecutor.Schedule(singleTask).Get(3000) + ": " + singleTask.Result);
                Console.WriteLine("Should never be reached");
            }
            catch (TimeoutException timeoutException)
            {
                Console.WriteLine(timeoutException.Message);
            }
            finally
            {
                Console.WriteLine("###");
            }
 
        }
    }
}

Das ITask interface:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
 public interface ITask
    {
        Guid Id
        {
            get;
        }
 
        bool IsScheduled
        {
            get;
            set;
        }
 
 
        void Schedule();
    }
}

Hier mal ein selbst definierter Task:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
namespace De.Tutorials.Training
{
 public class CustomTask : Task<int, int>
    {
        protected override void Execute()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine(this + ": " + i);
                Thread.Sleep(1000);
            }
            this.Result = this.Argument * this.Argument;
        }
    }
}

Unser Runnable delegate:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
public delegate void Runnable<TTask>(TTask task) where TTask : ITask;
}

Unser generisches ITask interface

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
public interface ITask<TArgument, TResult> : ITask
    {
        TArgument Argument
        {
            get;
            set;
        }
 
 
        TResult Result
        {
            get;
            set;
        }
 
 
        Runnable<ITask<TArgument, TResult>> Run
        {
            get;
            set;
        }
    }
}

Unsere Task Implementierung:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
public class Task<TArgument, TResult> : ITask<TArgument, TResult>
    {
 
        #region ITask Member
 
        public Task()
        {
            this.id = Guid.NewGuid();
            this.run = delegate(ITask<TArgument, TResult> task)
            {
                Execute();
            };
        }
 
        public Task(Runnable<ITask<TArgument, TResult>> run)
            : this()
        {
            this.run = run;
        }
 
        public bool IsScheduled
        {
            get { return isScheduled; }
            set { isScheduled = value; }
        }private bool isScheduled;
 
 
        public Guid Id
        {
            get { return id; }
        }private Guid id;
 
        public TArgument Argument
        {
            get { return argument; }
            set { argument = value; }
        } private TArgument argument;
 
        protected virtual void Execute()
        {
            //noop
        }
 
        public void Schedule()
        {
            this.Run(this);
        }
 
        public TResult Result
        {
            get { return result; }
            set { result = value; }
        }
        private TResult result;
 
        public Runnable<ITask<TArgument, TResult>> Run
        {
            get { return run; }
            set { run = value; }
        }private Runnable<ITask<TArgument, TResult>> run;
 
        public override string ToString()
        {
            return string.Format("Task ID:{0}", id);
        }
 
        public override bool Equals(object obj)
        {
            if (null == obj)
            {
                return false;
            }
 
            if (this == obj)
            {
                return true;
            }
 
            if (!GetType().IsAssignableFrom(obj.GetType()))
            {
                return false;
            }
            return id.Equals(((ITask)obj).Id);
        }
 
        public override int GetHashCode()
        {
            return this.id.GetHashCode();
        }
 
        #endregion
    }
}

Unser TaskExecutor interface:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
 public interface ITaskExecutor
    {
        ITaskExecutionStrategy TaskExecutionStrategy
        {
            get;
            set;
        }
 
        void Execute(ITask task);
 
        IFuture<TTask> Schedule<TTask>(TTask task) where TTask : ITask;
    }
}

Unsere TaskExecutor Implementierung:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
 public class TaskExecutor : ITaskExecutor
    {
        public ITaskExecutionStrategy TaskExecutionStrategy
        {
            get { return taskExecutionStrategy; }
            set { taskExecutionStrategy = value; }
        } private ITaskExecutionStrategy taskExecutionStrategy = new DefaultTaskExecutionStrategy();
 
 
        public virtual void Execute(ITask task)
        {
            TaskExecutionStrategy.Execute(task);
        }
 
        public virtual IFuture<TTask> Schedule<TTask>(TTask task) where TTask : ITask
        {
            return TaskExecutionStrategy.Schedule(task);
        }
    }
}

Unser ITaskExecutionStrategyinterface:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
 public interface ITaskExecutionStrategy
    {
        void Execute(ITask task);
        IFuture<TTask> Schedule<TTask>(TTask task) where TTask : ITask;
    }
 
}

Unsere DefaultTaskExecutionStrategy Implementierung:
(Führt den angegeben Task synchron im Thread des Aufrufers aus)

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
public class DefaultTaskExecutionStrategy : ITaskExecutionStrategy
    {
 
        #region ITaskExecutionStrategy Member
 
        public virtual void Execute(ITask task)
        {
            if (null != task)
            {
                task.Schedule();
            }
        }
 
        public virtual IFuture<TTask> Schedule<TTask>(TTask task) where TTask : ITask
        {
            throw new NotImplementedException("Scheduling not implemented for single threaded task execution");
        }
 
        #endregion
    }
}

Unsere ThreadPoolTaskExecutionStrategy:
(Führt den Task asynchron in einem neuen Thread aus)

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
public class ThreadPoolTaskExecutionStrategy : DefaultTaskExecutionStrategy
    {
        internal IDictionary<Guid, object> currentTasksSet = new Dictionary<Guid, object>();
        internal IDictionary<Guid, Thread> taskIdToExecutingThreadMap = new Dictionary<Guid, Thread>();
        internal object tasksLock = new object();
 
 
        public override void Execute(ITask task)
        {
            ThreadPool.QueueUserWorkItem(delegate(object target)
            {
                lock (tasksLock)
                {
                    if (currentTasksSet.ContainsKey(task.Id))
                    {
                        throw new Exception("Task: " + task + " has already scheduled...");
                    }
                    else
                    {
                        currentTasksSet.Add(task.Id, null);
                        task.IsScheduled = true;
                    }
 
                    taskIdToExecutingThreadMap.Add(task.Id, Thread.CurrentThread);
                }
 
                base.Execute(task);
 
                lock (tasksLock)
                {
                    if (taskIdToExecutingThreadMap.ContainsKey(task.Id))
                    {
                        taskIdToExecutingThreadMap.Remove(task.Id);
                    }
 
                    if (currentTasksSet.ContainsKey(task.Id))
                    {
                        currentTasksSet.Remove(task.Id);
                    }
                }
            });
        }
 
        public override IFuture<TTask> Schedule<TTask>(TTask task)
        {
            this.Execute(task);
            return new Future<TTask>(task, this);
        }
    }
}

Unser IFuture interface:
Damit können wir auf das beenden eines Tasks warten)

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
 public interface IFuture<TTask>
    {
        TTask Get();
        TTask Get(long timeOutInMilliSeconds);
    }
}

Unsere Future Implementierung:

Code csharp:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
 
namespace De.Tutorials.Training
{
  public class Future<TTask> : IFuture<TTask> where TTask : ITask
    {
        private TTask task;
        private ThreadPoolTaskExecutionStrategy threadPoolTaskExecutionStrategy;
 
        public Future(TTask task, ThreadPoolTaskExecutionStrategy threadPoolTaskExecutionStrategy)
        {
            this.task = task;
            this.threadPoolTaskExecutionStrategy = threadPoolTaskExecutionStrategy;
        }
 
        public TTask Get()
        {
            return this.Get(0);
        }
 
        public TTask Get(long timeOutInMilliSeconds)
        {
            bool resultAvailable = false;
            Stopwatch stopWatch = new Stopwatch();
 
            if (timeOutInMilliSeconds > 0)
            {
                stopWatch.Start();
            }
 
            bool gotTimeout = false;
 
            while (!resultAvailable)
            {
                lock (threadPoolTaskExecutionStrategy.tasksLock)
                {
                    resultAvailable = !threadPoolTaskExecutionStrategy.currentTasksSet.ContainsKey(task.Id) && task.IsScheduled;
 
                    if (stopWatch.ElapsedMilliseconds > timeOutInMilliSeconds)
                    {
                        if (threadPoolTaskExecutionStrategy.taskIdToExecutingThreadMap.ContainsKey(task.Id))
                        {
                            Thread executingThread = threadPoolTaskExecutionStrategy.taskIdToExecutingThreadMap[task.Id];
                            threadPoolTaskExecutionStrategy.taskIdToExecutingThreadMap.Remove(task.Id);
                            executingThread.Abort();
                        }
 
                        gotTimeout = true;
                        break;
                    }
                }
                Thread.Sleep(200);
            }
 
            this.threadPoolTaskExecutionStrategy = null;
            TTask result = this.task;
            this.task = default(TTask);
            if (gotTimeout)
            {
                throw new TimeoutException(string.Format("Task Id:{0} did not complete before timeout", result.Id));
            }
            return result;
        }
 
    }
}

Beispiellauf:

Code :

Sequential Task Execution
Task ID:a0642399-486a-414e-8c28-3b303f314680: 0
Task ID:a0642399-486a-414e-8c28-3b303f314680: 1
Task ID:a0642399-486a-414e-8c28-3b303f314680: 2
Task ID:a0642399-486a-414e-8c28-3b303f314680: 3
Task ID:a0642399-486a-414e-8c28-3b303f314680: 4
Task ID:a0642399-486a-414e-8c28-3b303f314680: result -> 0
Task ID:fb9e2730-d146-4d1b-add1-e824e55397bc: 0
Task ID:fb9e2730-d146-4d1b-add1-e824e55397bc: 1
Task ID:fb9e2730-d146-4d1b-add1-e824e55397bc: 2
Task ID:fb9e2730-d146-4d1b-add1-e824e55397bc: 3
Task ID:fb9e2730-d146-4d1b-add1-e824e55397bc: 4
Task ID:fb9e2730-d146-4d1b-add1-e824e55397bc: result -> 1
Task ID:129f1138-bed9-445f-8e91-f1ec408bd5e1: 0
Task ID:129f1138-bed9-445f-8e91-f1ec408bd5e1: 1
Task ID:129f1138-bed9-445f-8e91-f1ec408bd5e1: 2
Task ID:129f1138-bed9-445f-8e91-f1ec408bd5e1: 3
Task ID:129f1138-bed9-445f-8e91-f1ec408bd5e1: 4
Task ID:129f1138-bed9-445f-8e91-f1ec408bd5e1: result -> 4
Task ID:730fbea2-bcb9-45ab-b69f-bf3c938819af: 0
Task ID:730fbea2-bcb9-45ab-b69f-bf3c938819af: 1
Task ID:730fbea2-bcb9-45ab-b69f-bf3c938819af: 2
Task ID:730fbea2-bcb9-45ab-b69f-bf3c938819af: 3
Task ID:730fbea2-bcb9-45ab-b69f-bf3c938819af: 4
Task ID:730fbea2-bcb9-45ab-b69f-bf3c938819af: result -> 9
Task ID:e4765815-956a-4ab6-b12b-102043c4568f: 0
Task ID:e4765815-956a-4ab6-b12b-102043c4568f: 1
Task ID:e4765815-956a-4ab6-b12b-102043c4568f: 2
Task ID:e4765815-956a-4ab6-b12b-102043c4568f: 3
Task ID:e4765815-956a-4ab6-b12b-102043c4568f: 4
Task ID:e4765815-956a-4ab6-b12b-102043c4568f: result -> 16
Execution took: 25 seconds
###############################
Parallel Task Execution:
Task ID:3d437e72-5492-4c77-b348-96b9e6878dda: 0
Task ID:e9c4969c-4d57-4820-8f77-130032de787a: 0
Task ID:3d437e72-5492-4c77-b348-96b9e6878dda: 1
Task ID:e9c4969c-4d57-4820-8f77-130032de787a: 1
Task ID:1e1abf9d-8f01-4da0-8b5f-b36c3b05bfd1: 0
Task ID:268d30f1-44b9-461b-b723-290ca5733c80: 0
Task ID:e9c4969c-4d57-4820-8f77-130032de787a: 2
Task ID:1e1abf9d-8f01-4da0-8b5f-b36c3b05bfd1: 1
Task ID:3d437e72-5492-4c77-b348-96b9e6878dda: 2
Task ID:f742cabe-89e1-407f-adad-46e70d8a7932: 0
Task ID:268d30f1-44b9-461b-b723-290ca5733c80: 1
Task ID:f742cabe-89e1-407f-adad-46e70d8a7932: 1
Task ID:e9c4969c-4d57-4820-8f77-130032de787a: 3
Task ID:1e1abf9d-8f01-4da0-8b5f-b36c3b05bfd1: 2
Task ID:3d437e72-5492-4c77-b348-96b9e6878dda: 3
Task ID:268d30f1-44b9-461b-b723-290ca5733c80: 2
Task ID:3d437e72-5492-4c77-b348-96b9e6878dda: 4
Task ID:f742cabe-89e1-407f-adad-46e70d8a7932: 2
Task ID:e9c4969c-4d57-4820-8f77-130032de787a: 4
Task ID:1e1abf9d-8f01-4da0-8b5f-b36c3b05bfd1: 3
Task ID:268d30f1-44b9-461b-b723-290ca5733c80: 3
Task ID:f742cabe-89e1-407f-adad-46e70d8a7932: 3
Task ID:1e1abf9d-8f01-4da0-8b5f-b36c3b05bfd1: 4
Task ID:3d437e72-5492-4c77-b348-96b9e6878dda result -> 0
Task ID:e9c4969c-4d57-4820-8f77-130032de787a result -> 1
Task ID:268d30f1-44b9-461b-b723-290ca5733c80: 4
Task ID:f742cabe-89e1-407f-adad-46e70d8a7932: 4
Task ID:1e1abf9d-8f01-4da0-8b5f-b36c3b05bfd1 result -> 4
Task ID:268d30f1-44b9-461b-b723-290ca5733c80 result -> 9
Task ID:f742cabe-89e1-407f-adad-46e70d8a7932 result -> 16
Execution took: 7 seconds
##################
Get Single result with no timeout
Task ID:68314aa9-90ca-4b5d-a932-86586ca32260: 0
Task ID:68314aa9-90ca-4b5d-a932-86586ca32260: 1
Task ID:68314aa9-90ca-4b5d-a932-86586ca32260: 2
Task ID:68314aa9-90ca-4b5d-a932-86586ca32260: 3
Task ID:68314aa9-90ca-4b5d-a932-86586ca32260: 4
Task ID:68314aa9-90ca-4b5d-a932-86586ca32260: result ->121
##################
Get Single result with timeout 3s
Task ID:6bddecbf-f8be-4460-93c1-af2907b17639: 0
Task ID:6bddecbf-f8be-4460-93c1-af2907b17639: 1
Task ID:6bddecbf-f8be-4460-93c1-af2907b17639: 2
Task ID:6bddecbf-f8be-4460-93c1-af2907b17639: 3
Task Id:6bddecbf-f8be-4460-93c1-af2907b17639 did not complete before timeout
###
Drücken Sie eine beliebige Taste . . .

Gruß Tom

deepgreen · 19.08.07 22:41

Schaut gut aus, aber ich hätte eine blöde Frage.

Wo braucht man sowas?
Besser gesagt, bei welcher Anwendung?

**Thomas Darimont** · 19.08.07 22:50

Hallo,

och da gibts viele Anwendungen für

Stell dir mal vor du hast ne 1000x1000 Matrix und möchtest jeweils für ein 4x4 Kästchen eine Berechnung anstellen die von allen anderen "Kästchen" unabhängig ist.
Du kannst nun hingehen und das ganze einfach sequentiell Single-Threaded ein Kästchen nach dem anderen durchrechnen lassen. Oder, was in diesem Fall cleverer wäre du, könntest die Berechnung parallelisieren. Das heißt du verteilst die Berechnung auf mehrere Threads. Jeder Thread berechnet dann für sich ein kleines Stück von dem großen ganzen. Die einzelnen Berechnungsergebnisse die während des ganzen Prozesses anfallen werden an einer zentralen Stelle zusammen gefügt. Genau das kannst du mit dem oben gezeigten Framework machen.

Im groben und ganzen gehts hier einfach um die Beschleungung von Vorgängen durch Parallelisierung.
Ein weiteres Beispiel währe die Verarbeitung von großen Dateimengen. Stell dir mal vor du hättest ein Verzeichnis in dem lauter Nachrichten als Textdateien liegen. Diese würdest du nun gerne verarbeiten. Das kannst du hier auch wieder naiv sequentiell -eine nach der anderen machen oder aber du machst das ganze parallel und verarbeitest gleichzeitig mehrere Nachrichten auf einmal. Damit wird der Verarbeitungsprozess um ein vielfaches beschleunigt! Parallele Verarbeitung kann aber auch manchmal ganz schön kompliziert sein. Nämlich genau dann, wenn die einzelnen Aufgaben (Tasks) nicht isoliert sondern noch von anderne Aufgaben (oder Ergebnissen von anderen Tasks) abhängig sind. Hier fällt dann großer Synchronisationsaufwand an, der sich jedoch in den meisten Fällen mit großen Geschwindigkeitsvorteilen bezahlt macht.

Gruß Tom

deepgreen · 20.08.07 07:35

Verstehe, das könnte durchaus sinnvoll sein.

Ein Kollege von mir muss Wirtschaftsdaten konvertieren und bei ihm dauert es mehrere Tage bis sein Rechner alles fertig hat.

Wenn man jetzt eine parallele Verarbeitung einführt, könnte er gleichzeitig NACE4 und CN8 und SITC5 durchführen.

Nur zur Info, eine ist eine DVD mit einigen Millionen Datensätze, die anhand einer Tabellenvorgabe umgerechnet werden müssen.

Ich werde ihm darauf mal ansprechen, zwar wird er das Ganze nicht jetzt umstellen, aber für zukünftige Projekte durchaus interessant.

Danke für die Info.

**Thomas Darimont** · 25.12.07 13:49

Hallo,

mit Parallel Extensions für .Net 3.5 ist das Parallelisieren von Codeabschnitten kinderleicht

http://www.microsoft.com/downloads/d...displaylang=en

Endlich hat auch ein Task und Future Konzept seinen Weg ins .net Framework gefunden

Code csharp:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.ComponentModel;
using System.Threading.Tasks;
 
namespace De.Tutorials.Training
{
    public class ParallelExecutionExample
    {
        public static void Main(string[] args)
        {
            Future<int> future = Future.Create<int>(() => { Thread.Sleep(500); return 4711; });
            while (!future.IsCompleted)
            {
                Console.WriteLine("Sleep...");
                Thread.Sleep(100);
            }
            Console.WriteLine(future.Value);
 
            Console.WriteLine("###");
            
            Enumerable.Range(1, 100).AsParallel<int>(10).ForAll<int>(delegate(int number)
            {
                Thread.Sleep(500);
                Console.WriteLine("{0}: {1}",Thread.CurrentThread.ManagedThreadId,number); 
            });
 
            Console.WriteLine("###");
 
            Parallel.Do(
                delegate() { Console.WriteLine("{0}: {1}", Thread.CurrentThread.ManagedThreadId, "A"); },
                delegate() { Console.WriteLine("{0}: {1}", Thread.CurrentThread.ManagedThreadId, "B"); },
                delegate() { Console.WriteLine("{0}: {1}", Thread.CurrentThread.ManagedThreadId, "C"); });
 
            Console.WriteLine("###");
 
            Parallel.For(0, 100, i =>
            {
                Thread.Sleep(500);
                Console.WriteLine("{0}: {1}",Thread.CurrentThread.ManagedThreadId,i); 
            });
        }
    }
}

Ausgabe:

Code :

Sleep...
Sleep...
Sleep...
Sleep...
Sleep...
Sleep...
4711
###
1: 3
7: 1
6: 2
1: 4
6: 8
7: 6
8: 10
6: 9
1: 5
7: 7
8: 11
9: 13
1: 18
6: 14
7: 22
8: 12
9: 26
10: 28
1: 19
6: 15
7: 23
8: 29
9: 27
10: 33
11: 35
1: 20
6: 16
7: 24
8: 30
12: 42
11: 40
10: 34
9: 36
1: 21
6: 17
7: 25
8: 31
12: 43
9: 37
10: 45
13: 49
11: 41
1: 50
7: 66
6: 58
8: 32
11: 76
13: 74
10: 46
14: 80
12: 44
9: 38
1: 51
7: 67
6: 59
11: 77
13: 75
8: 81
12: 91
10: 47
14: 89
9: 39
1: 52
7: 68
6: 60
8: 82
13: 95
11: 78
12: 92
10: 48
14: 90
9: 99
1: 53
7: 69
6: 61
8: 83
13: 96
11: 79
12: 93
9: 100
1: 54
7: 70
6: 62
8: 84
13: 97
12: 94
7: 71
1: 55
6: 63
8: 85
13: 98
7: 72
1: 56
6: 64
8: 86
7: 73
1: 57
6: 65
8: 87
8: 88
###
4: A
5: B
5: C
###
5: 0
4: 8
15: 16
16: 24
5: 1
4: 9
15: 17
17: 32
16: 25
18: 40
4: 10
5: 2
15: 18
19: 48
17: 33
16: 26
18: 41
4: 11
5: 3
15: 19
19: 49
20: 56
17: 34
16: 27
18: 42
4: 12
5: 4
21: 64
15: 20
19: 50
22: 72
17: 35
20: 57
16: 28
18: 43
5: 5
4: 13
21: 65
23: 80
15: 21
19: 51
22: 73
20: 58
17: 36
16: 29
18: 44
4: 14
5: 6
21: 66
23: 81
15: 22
19: 52
22: 74
20: 59
17: 37
16: 30
18: 45
4: 15
5: 7
21: 67
24: 88
23: 82
15: 23
19: 53
22: 75
20: 60
17: 38
16: 31
18: 46
4: 96
24: 89
21: 68
23: 83
19: 54
22: 76
20: 61
17: 39
18: 47
4: 97
24: 90
21: 69
23: 84
19: 55
22: 77
20: 62
4: 98
24: 91
23: 85
21: 70
22: 78
20: 63
4: 99
21: 71
24: 92
23: 86
22: 79
23: 87
24: 93
24: 94
24: 95
Drücken Sie eine beliebige Taste . . .

Gruß Tom

tut orials.de	tut verbinden	tut dir helfen	tut kooperieren
©2000-2012 tutorials.de Alle Rechte vorbehalten	tut informieren » Impressum » Nutzungsregeln » Netiquette » Team » Redaktion	» Tutorials » Videotutorials » Showroom » Events & Contests » Chat » RSS-Feed » Blogs	» der-webdesigner.net » DesignerInAction » Design Nation » Directorforum » Flashhilfe » PHP-Resource » PHPwelt » PSD-Tutorials

Themen-Optionen

Anzeige

Ähnliche Themen

Strategie zur parallelen Datenübertragung

Parallelen - Illustrator CS

Zeitgesteuerte Ausführung von Tasks.

Einlesen von der parallelen Schnittstelle

Ein halben Parallelen Spot (rund)?

E-Mail:

Abonnieren Abbestellen