线程----轻量级同步Interlocked

字段与属性：

字段通常都是为类的方法所使用，而属性则常用于表示类的状态(比如StringBuilder的  Length)，类的能力(比如StringBuilder的 Capacity)，方法进行的状态或者阶段

 

对象的原子性：

对象的状态是一个整体，如果一个字段改变。其他的字段也要同时做出相应的改变。简单  的来说，就是要么不改，要么全改

 

对象的常量性：

对象的状态一旦确定，就不能再次更改了。如果想再次更改，需要重新构造一个对象

 

 轻量级同步Interlocked

 为什么说它是轻量级呢？因为它仅对×××数据（即int类型，long也行）进行同步。如果你学过操作系统里面的PV操作（即信号量），那么你对它已经了解了一般。它实现的正是如同信号量的功能。下面是它提供的方法：

 

Interlocked.Increment(ref value)	数值加一（原子性操作）
Interlocked.Decrement(ref value)	数值减一（原子性操作）
Interlocked.Exchange(ref value1, value2)	交换：把值2赋给值1；返回新值
Interlocked.CompareExchange(ref value1, value2, value3)	实现比较和交换两种功能：值1和值3比较，如果相同，把值2给值1，不相同则不作任何操作；返回原值（多用于判断条件）（示例3中会用到）

案例（Interlocked.Increment(ref value)）

启动20个任务，每个任务让共享数据字段递增10000次

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            State s = new State();
            Demo d = new Demo(s);
            Task[] t = new Task[20];
            //开启20个任务
            for (int i = 0; i < 20; i++)
            {
                t[i] = new Task(d.Start);
                t[i].Start();
            }
            //等待20个任务完成
            for (int i = 0; i < 20; i++)
            {
                t[i].Wait();
            }
            Console.WriteLine(s._i);
            Console.ReadKey();
        }

    }
    //共享数据类
    class State
    {
        public int _i;
        public void Increment()
        {
           Interlocked.Increment(ref _i);
        }
    }
    //任务
    class Demo
    {
        private State state;
        public Demo(State s)
        {
            state = s;
        }
        public void Start()
        {
            for (int i = 0; i < 10000; i++)
            {
                state.Increment();
            }
        }
    }
}