多线程学习笔记——lock

一. 为什么要lock，lock了什么？

当我们使用线程的时候，效率最高的方式当然是异步，即各个线程同时运行，其间不相互依赖和等待。但当不同的线程都需要访问某个资源的时候，就需要同步机制了，也就是说当对同一个资源进行读写的时候，我们要使该资源在同一时刻只能被一个线程操作，以确保每个操作都是有效即时的，也即保证其操作的原子性。lock是C#中最常用的同步方式，格式为lock(objectA){codeB} 。


lock(objectA){codeB} 看似简单，实际上有三个意思，这对于适当地使用它至关重要：
1. objectA被lock了吗？没有则由我来lock，否则一直等待，直至objectA被释放。
2. lock以后在执行codeB的期间其他线程不能调用codeB，也不能使用objectA。
3. 执行完codeB之后释放objectA，并且codeB可以被其他线程访问。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;


namespace 多线程_lock
{
    public partial class Form1 : Form
    {
        const int test1ArrSize = 50000;
        ParaLockTest test1 = new ParaLockTest(test1ArrSize);
        int T1CountNum = 0, T2CountNum = 0, TMainCountNum = 0, ExCountNum = 0;
        int TotalCount = 0;


        public Form1()
        {
            InitializeComponent();
        }


        private void button1_Click(object sender, EventArgs e)
        {
            T1CountNum = T2CountNum = TMainCountNum = ExCountNum = 0;
            TotalCount = 0;
            Thread T1 = new Thread(Write1);
            Thread T2 = new Thread(Write2);
            T1.IsBackground = true;
            T2.IsBackground = true;
            T1.Start();
            T2.Start();
            WriteMain();
            //T1.Abort();
            //T2.Abort();
            //if (T1.IsAlive == true || T2.IsAlive == true)
            //{
            //    MessageBox.Show("T1/T2没结束");
            //}
            if (T1.ThreadState==ThreadState.Running|| T2.ThreadState == ThreadState.Running)
            {
                Thread.Sleep(1000);//等待所有线程都运行完
            }
            CountResult();
            textBox1.Text += "  1:" + T1CountNum.ToString() + "  2:" + T2CountNum.ToString() +
                "  3:" + TMainCountNum.ToString() + "  Ex:" + ExCountNum.ToString() +
                "  TotalCount:" + TotalCount.ToString() + Environment.NewLine;
        }


        private void Form1_Load(object sender, EventArgs e)
        {


        }


        private void Write1()
        {
            SetArr(1);
        }


        private void Write2()
        {
            SetArr(2);
        }


        private void WriteMain()
        {
            SetArr(3);
        }


        private void SetArr(int value)
        {
            lock (this)
            {
                for (int i = 0; i < test1ArrSize; i++)
                {
                    test1.Para_Arr1[i] = value;
                }
            }
        }


        private void CountResult()
        {
            for (int i = 0; i < test1ArrSize; i++)
            {
                switch (test1.Para_Arr1[i])
                {
                    case 1:
                        T1CountNum++;
                        break;
                    case 2:
                        T2CountNum++;
                        break;
                    case 3:
                        TMainCountNum++;
                        break;
                    default:
                        ExCountNum++;
                        break;
                }
                TotalCount++;
            }
        }
    }


    class ParaLockTest
    {
        public ParaLockTest(int ArrSize)
        {
            Para_Arr1 = new int[ArrSize];
        }


        int[] Para_Arr;


        public int[] Para_Arr1
        {
            get
            {
                return Para_Arr;
            }


            set
            {
                Para_Arr = value;
            }
        }
    }
}

试了试，能保证不同线程对同一数组的操作是互斥的。

参考

http://www.cnblogs.com/apsnet/archive/2012/07/08/2581475.html

这里面是调用其它类的方法时，保证对象某个方法在同一时刻只能由一个线程访问。