Concurrent Programming

Transcription

1 Concurrent Programming Adam Przybyłek, 2016 przybylek.wzr.pl This work is licensed under a Creative Commons Attribution 4.0 International License.

2 Task Parallel Library (TPL) scales the degree of concurrency dynamically to most efficiently use all the processors that are available handles the partitioning of the work, thread scheduling, state management, and other low-level details is based on the concept of a task, which represents an asynchronous operation System.Threading.Tasks.Task a task that does not return a value System.Threading.Tasks.Task<TResult> a task that returns a value provides support for parallel loops and regions through thesystem.threading.tasks.parallel class

3 Creating and Starting Tasks Task.Factory.StartNew Explicitly Task taska = Task.Run ( //Action () => Console.WriteLine("task A") taska.wait( Task.Factory.StartNew<int> Task<int> taskb = Task.Run<int> ( //Func<int> () => { int sum = 0; for (int i = 0; i < 100; i++) sum += i; return sum; Console.WriteLine(taskB.Result

4 Passing a Parameter to a Task Task taskc = Task.Factory.StartNew( //Action<object> (str) => Console.WriteLine(str), "task C" //state taskc.wait( string state = (string)taskc.asyncstate; Console.WriteLine(state Task<int> taskd = Task.Factory.StartNew<int>( //Func<object,int> (obj) => { int max = (int)obj; int sum = 0; for (int i = 0; i < max; i++) sum += i; return sum;, 100 //state Console.WriteLine(taskD.Result

5 Chaining Tasks Together (1) Task<int> taska = Task.Factory.StartNew( //Func<int> () => { int sum = 0; for (int i=1; i<100; i++) sum += i; return sum; Task<double> taskb = taska.continuewith<double>(//func<task,double> (prev) => { return prev.result / 100.0; Task taskc = taskb.continuewith( //Action<Task> (prev) => Console.WriteLine(prev.Result) taskc.wait(

6 Chaining Tasks Together (2) Task<int> taska = Task.Run( //Func<int> () => { return 100; Task<int> taskb = Task.Run( //Func<int> () => { return 200; Task[] work = new Task[] { taska, taskb ; Task finaltask = Task.Factory.ContinueWhenAll(work, //Action<Task[]> (tasks) => { long sum = 0; foreach (Task<int> task in tasks) sum += task.result; Console.WriteLine(sum // Perform additional processing here finaltask.wait(

7 Creating and running tasks implicitly Parallel.Invoke( () => Console.WriteLine("Action 1"), () => Console.WriteLine("Action 2"), () => Console.WriteLine("Action 3")

8 Parallel Loops for(int i = 0; i < 100; i++) { Console.WriteLine("{0^2 = {1", i, i * i Parallel.For(0, 100, i => { Console.WriteLine("{0^2 = {1", i, i * i string[] words = new string[] {"apple", "plum", "cherry"; foreach(string word in words) { char[] tmp = word.reverse().toarray( Console.WriteLine(new string(tmp) Parallel.ForEach<string>(words, word => { char[] tmp = word.reverse().toarray( Console.WriteLine(new string(tmp)

9 Using the BackgroundWorker component 1. Create an instance of the BackgroundWorker class. 2. Add a handler for the DoWork event. The handler should contain the code that you need to perform on a separate thread. Use BackgroundWorker.ReportProgress(int) to report the status of the operation. Periodically check the CancellationPending property, and if it is true, terminate the job. 3. Add a handler for the ProgressChanged event. The handler runs on the UI thread. 4. Set the WorkerReportsProgress property to true. 5. Add a handler for the RunWorkerCompleted event. The handler runs on the UI thread. 6. Call the BackgroundWorker.RunWorkerAsync() method to raise the DoWork event. 7. Optionally, call BackgroundWorker.CancelAsync() to set the CancellationPending property totrue.

10 A BackgroundWorker example private void button1_click(object s, EventArgs e) { BackgroundWorker bw = new BackgroundWorker( bw.dowork += ((object sender, DoWorkEventArgs args) => { BackgroundWorker worker = sender as BackgroundWorker; int n = (int)args.argument; //Extract the argument int i; //Perform long running process for (i=0; i<n; i++) worker.reportprogress(i+1 args.result = i; bw.progresschanged += ((object sender, ProgressChangedEventArgs args) => { //Update label in UI with progress label1.text = args.progresspercentage.tostring( bw.runworkercompleted += ((object sender, RunWorkerCompletedEventArgs args) => { //Update the user interface MessageBox.Show("Result: " + args.result bw.workerreportsprogress = true; bw.runworkerasync(100 Walkthrough: Running an Operation in the Background

11 Calling Synchronous Methods Asynchronously define a delegate type with the same signature as the method you want to call; CLR provides each delegate type with two methods, to enable asynchronous invocation of the delegate: IAsyncResult BeginInvoke(, AsyncCallback callback, object state) initiates the asynchronous call returns immediately and does not wait for the asynchronous call to complete EndInvoke(IAsyncResult) blocks until the asynchronous call has completed returns the result of the asynchronous call create a delegate object that "points to" the target method callbegininvoke

12 Waiting for an Asynchronous Method to Complete either useendinvoke to wait for an asynchronous method or poll the IAsyncResult returned by BeginInvoke to determine when the asynchronous call has completed, and then call EndInvoke or use the AsyncCallback delegate: pass a delegate for a callback method to BeginInvoke the callback method is executed on a ThreadPool thread when the asynchronous call completes callendinvoke from the callback method

13 Polling for Asynchronous Call Completion class Program { public static int Add(int x, int y) { return x + y; static void Main(string[] args) { Func<int, int, int> op = Add; IAsyncResult result; result= op.begininvoke(4, 3, null, null while (result.iscompleted == false) { // Perform additional processing here Console.Write("." int sum = op.endinvoke(result Console.WriteLine(sum

14 Executing a Callback Method When an Asynchronous Call Completes class Program { public static int Add(int x, int y) { return x + y; static void Main(string[] args) { Func<int, int, int> op = Add; IAsyncResult result = op.begininvoke(4, 3, new AsyncCallback(AddCallback), "state" // Perform additional processing here Console.ReadLine( public static void AddCallback(IAsyncResult result) { string state = (string)result.asyncstate; AsyncResult asyncresult = (AsyncResult) result; Func<int, int, int> op; op = (Func<int, int, int>) asyncresult.asyncdelegate; int sum = op.endinvoke(result Console.WriteLine("state: {0, result: {1", state, sum

15 Pre-Built Asynchronous Methods are essential for activities that are potentially blocking are provided by classes throughout the.net Standard Library come in pairs: BeginXyz to start the work EndXyz to collect the results when it is complete

16 Asynchronously Querying the DNS static void Main(string[] args) { string[] names = { " " " " ; for(int i = 0; i < names.length; i++) { Dns.BeginGetHostAddresses(names[i], MyCallback, names[i] Console.ReadLine( static void MyCallback(IAsyncResult result) { IPAddress[] ip = Dns.EndGetHostAddresses(result Console.WriteLine("{0: {1", result.asyncstate, ip[0]

17 Async methods (1) asynchronous methods that are defined by using the async and await keywords put the async keyword in a method s declaration, and this tells the compiler that you intend to use asynchronous features in the method use the await keyword in an expression that may take some time to produce a result; it indicates that the remainder of the containing method should not execute until the asynchronous operation is complete, but it also causes the containing method to return immediately return one of the following types: Task<TResult>, Task, void end with an "Async" suffix by convention

18 Async methods (2) if you apply await to a Task<T>, it becomes an await expression, and the whole expression has type T if you apply await to a Task, it becomes an await statement, and can t be assigned to anything private async void dumpwebpageasync(string uri) { WebClient webclient = new WebClient( string page = await webclient.downloadstringtaskasync(uri MessageBox.Show(page returnstask<string>

19 Accessing the Web by Using an Async Method private async void button1_click(object s, EventArgs e) { WebClient webclient = new WebClient( string url = " byte[] data = await webclient.downloaddatataskasync(url Stream stream = new MemoryStream(data Image myimage = Image.FromStream(stream picturebox1.image = myimage; stream.dispose( webclient.dispose(

20 Accessing the Web by Using Tasks private void button2_click(object sender, EventArgs e) { WebClient webclient = new WebClient( string url = " Task<byte[]> task = webclient.downloaddatataskasync(url Task nameless = task.continuewith( (prev) => { byte[] data = prev.result; Stream stream = new MemoryStream(data Image myimage = Image.FromStream(stream picturebox1.image = myimage; stream.dispose( webclient.dispose(, TaskScheduler.FromCurrentSynchronizationContext()

21 Network Programming Adam Przybyłek, 2016 przybylek.wzr.pl This work is licensed under a Creative Commons Attribution 4.0 International License.

22 TCP Services TcpClient requests data from an Internet resource TcpListener waits for incoming requests and then creates either a Socket or a TcpClient that manages the connection to the client

23 TcpTimeServer TcpListener listener = new TcpListener(IPAddress.Any, listener.start( while(true) { TcpClient newclient = listener.accepttcpclient( Task.Factory.StartNew((c) => { TcpClient client = (TcpClient)c; Stream stream = client.getstream( String time = DateTime.Now.ToString( byte[] bytetime = Encoding.ASCII.GetBytes(time stream.write(bytetime, 0, bytetime.length stream.close( client.close(, newclient //listener.stop(

24 TcpTimeClient int port = 13131; String server = "localhost"; TcpClient client = new TcpClient(server, port Stream stream = client.getstream( byte[] bytes = new byte[1024]; int n = stream.read(bytes, 0, bytes.length Console.WriteLine( Encoding.ASCII.GetString(bytes, 0, n) client.close(

25 UDP Services UdpClient provides simple methods for sending and receiving UDP datagrams IPEndPoint represents a network endpoint as an IP address and a port number

26 UdpTimeServer IPEndPoint localipendpoint = new IPEndPoint(IPAddress.Any, UdpClient myudpclient = new UdpClient(localIPEndPoint IPEndPoint remoteipendpoint; byte[] data; string msg; while (true) { remoteipendpoint = new IPEndPoint(IPAddress.Any, 0 data = myudpclient.receive(ref remoteipendpoint msg = Encoding.ASCII.GetString(data, 0, data.length Console.WriteLine("{0> {1", remoteipendpoint, msg msg = DateTime.Now.ToString( data = Encoding.ASCII.GetBytes(msg myudpclient.sendasync(data, data.length, remoteipendpoint //myudpclient.close(

27 UdpTimeClient int port = 13131; string server = "localhost"; UdpClient myudpclient = new UdpClient( myudpclient.connect(server, port string msg = "What's the time?"; byte[] data = Encoding.ASCII.GetBytes(msg myudpclient.send(data, data.length IPEndPoint remoteipendpoint = new IPEndPoint(IPAddress.Any, 0 data = myudpclient.receive(ref remoteipendpoint msg = Encoding.ASCII.GetString(data, 0, data.length Console.WriteLine(msg myudpclient.close(