稳扎稳打Silverlight(26) - 2.0线程之Lock, Interlocked, EventWaitHandle, Monitor

[索引页]
[×××]

稳扎稳打Silverlight(26) - 2.0线程之Lock, Interlocked, EventWaitHandle, Monitor, ThreadStaticAttribute

作者： webabcd


介绍
Silverlight 2.0 使用Lock, Interlocked, EventWaitHandle, Monitor来实现线程同步
    Lock - 确保代码块完成运行，而不会被其他线程中断
    Interlocked - 为多个线程共享的变量提供原子级的操作
    EventWaitHandle - 通知其他线程是否可入的类
    Monitor - 提供同步访问对象的机制
    ThreadStaticAttribute - 所指定的静态变量对每个线程都是唯一的


在线DEMO
http://webabcd.blog.51cto.com/1787395/342779


示例
1、Lock.xaml

<UserControl x:Class="Silverlight20.Thread.Lock"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
        <StackPanel HorizontalAlignment="Left" Margin="5">

                <TextBlock x:Name="txtMsg" />

        </StackPanel>
</UserControl>

 

Lock.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Silverlight20.Thread
{
         public partial class Lock : UserControl
        {
                 // 需要被 lock 的静态变量
                 private static readonly object objLock = new object();

                 private static int i;

                 public Lock()
                {
                        InitializeComponent();

                        i = 0;

                         for ( int x = 0; x < 100; x++)
                        {
                                 // 开 100 个线程去操作静态变量 i
                                System.Threading.Thread thread = new System.Threading.Thread( new System.Threading.ThreadStart(DoWork));
                                thread.Start();
                        }

                        System.Threading.Thread.Sleep(3000);
                         // 3 秒后 100 个线程都应该执行完毕了，取得 i 的结果
                         // 做了并发处理的结果为 100 ，去掉 lock 可得到不做并发处理的结果
                        txtMsg.Text = i.ToString();
                }

                 private void DoWork()
                {
                         try
                        {
                                 // lock() - 确保代码块完成运行，而不会被其他线程中断。其参数必须为一个引用类型的对象
                                 lock (objLock)
                                {
                                         int j = i + 1;

                                         // 模拟多线程并发操作静态变量 i 的情况
                                        System.Threading.Thread.Sleep(10);

                                        i = j;
                                }
                        }
                         finally
                        {
                                 // code
                        }
                }
        }
}

 

 

2、Interlocked.xaml

<UserControl x:Class="Silverlight20.Thread.Interlocked"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
        <StackPanel HorizontalAlignment="Left" Margin="5">

                <TextBlock x:Name="txtMsg" />

        </StackPanel>
</UserControl>

 

Interlocked.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Silverlight20.Thread
{
         public partial class Interlocked : UserControl
        {
                 private static int i;

                 public Interlocked()
                {
                        InitializeComponent();

                        i = 0;

                         for ( int x = 0; x < 100; x++)
                        {
                                 // 开 100 个线程去操作静态变量 i
                                System.Threading.Thread thread = new System.Threading.Thread( new System.Threading.ThreadStart(DoWork));
                                thread.Start();
                        }

                        System.Threading.Thread.Sleep(1000);
                         // 1 秒后 100 个线程都应该执行完毕了，取得 i 的结果
                        txtMsg.Text = i.ToString();
                }

                 private void DoWork()
                {
                         try
                        {
                                 // Interlocked - 为多个线程共享的变量提供原子级的操作（避免并发问题）

                                 // i 加 1
                                System.Threading.Interlocked.Increment( ref i);

                                 // i 减 1
                                System.Threading.Interlocked.Decrement( ref i);

                                 // i 加 1
                                System.Threading.Interlocked.Add( ref i, 1);

                                 // 如果 i 等于 100 ，则将 i 赋值为 101
                                System.Threading.Interlocked.CompareExchange( ref i, 101, 100);    

                                 // 将 i 赋值为 1000
                                 // System.Threading.Interlocked.Exchange(ref i, 1000);
                        }
                         finally
                        {
                                 // code
                        }
                }
        }
}

 

 

未完待续>>

 

 

OK
[×××]

 

转载于:https://blog.51cto.com/webabcd/343912