C#多线程Lock锁定的使用例子(多线程线程同步)

这个例子是一个模拟多个人在多台提款机上同时提取一个账户的款的情况。

在存取的过程中 可能 A线程取了100   而B线程那边还看见账户上没少掉那100快,所以导致数据不统一,赋值出现问题。

下面代码则可以测试出加上Lock锁定 与 不加的区别。

 

先上两个图。

第一个(加了Lock的程序):

 

加了的 数据每一条都是完整无错的,因为他们执行Lock包含的代码时,是一个线程一个线程的执行,而不是一拥而上 都在混乱的执行,那变量就会造成不稳定的情况。

 

下面是不加Lock的代码。

仔细看选中行 与 下一行的余额数目。。

按理说下一行 余额应该是509的,可是 却条到了下下行。。10个线程都在取钱 对变量进行操作。。所以会出现这个问题。

 

这就是Lock的好处。

下面贴代码

 

Form1窗体代码

引入命名控件:

using System.Threading;


完整代码:

namespace ThreadExample
{
    public partial class Form1 : Form
    {
        Thread thread1, thread2;
        Class1 class1;
        public Form1()
        {
            InitializeComponent();
            class1 = new Class1(this);
        }

        private void btn_Start_Click(object sender, EventArgs e)
        {
            txt_Text.Text = "";
            class1.shouldStop = false;
            thread1 = new Thread(class1.Method1);
            thread1.IsBackground = true;
            thread2 = new Thread(class1.Method2);
            thread2.IsBackground = true;
            thread1.Start("a method start\n");
            thread2.Start();
        }

        private delegate void AddMessageDelegate(string message);
        public void AddMessage(string message)
        {
            if (txt_Text.InvokeRequired)
            {
                AddMessageDelegate d = AddMessage;
                txt_Text.Invoke(d, message);
            }
            else
                txt_Text.AppendText(message);
        }

        private void btn_Stop_Click(object sender, EventArgs e)
        {
            class1.shouldStop = true;
            thread1.Join(0);
            thread2.Join(0);
        }
    }
}


 

 

Account.cs代码:

引入命名空间:

using System.Threading;


完整代码:

namespace LockExample
{
    class Account
    {
        private object lockObj = new object();
        int balance;    //余额
        Random r = new Random();
        Form1 form1;
        public Account(int initial, Form1 form1)
        {
            this.form1 = form1;
            this.balance = initial;
        }

        /// <summary>
        /// 取款
        /// </summary>
        /// <param name="amount">取款金额</param>
        /// <returns>余额</returns>
        private int Withdraw(int amount)
        {
            if (balance < 0)
                form1.AddListBoxItem("余额:" + balance + " 已经为负值了,还想取呵!");
            //lock (lockObj)
            {
                if (balance >= amount)
                {
                    string str = Thread.CurrentThread.Name + "取款---";
                    str += string.Format("取款前余额:{0,-6}取款:{1,-6}", balance, amount);
                    balance = balance - amount;
                    str += "取款后余额:" + balance;
                    form1.AddListBoxItem(str);
                    return amount;
                }
                else
                    return 0;
            }
        }

        /// <summary>
        /// 自动取款
        /// </summary>
        public void DoTransactions()
        {
            for (int i = 0; i < 100; i++)
            {
                Withdraw(r.Next(1,100));
            }
        }
    }
}


参考:http://www.wxzzz.com/Program/ThreadLock
 

  • 2
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
C#中,我们可以使用线程同步技术来确保多个线程之间的正确协调和互斥访问共享资源。以下是一些常用的线程同步技术: 1. 互斥(Mutex):互斥是一种最基本的线程同步机制,它确保在任何时候只有一个线程可以访问被保护的资源。通过`lock`关键字或`Mutex`类来实现互斥。 ```csharp private static readonly object lockObject = new object(); lock (lockObject) { // 访问共享资源的代码 } ``` 2. 信号量(Semaphore):信号量是一种计数器,它限制同时访问某个资源的线程数量。通过`Semaphore`类来实现信号量。 ```csharp private static Semaphore semaphore = new Semaphore(2, 2); // 允许同时两个线程访问 semaphore.WaitOne(); // 请求访问资源 try { // 访问共享资源的代码 } finally { semaphore.Release(); // 释放资源 } ``` 3. 事件(Event):事件是一种线程间的通信机制,它允许一个或多个线程等待某个操作完成。通过`ManualResetEvent`或`AutoResetEvent`类来实现事件。 ```csharp private static ManualResetEvent eventObject = new ManualResetEvent(false); // 初始状态为非终止状态 // 线程1等待事件 eventObject.WaitOne(); // 线程2触发事件 eventObject.Set(); ``` 4. 互斥体(Monitor):互斥体是一种特殊的内核对象,它提供了一种同步机制,确保只有一个线程可以进入临界区。通过`Monitor`类来实现互斥体。 ```csharp private static readonly object lockObject = new object(); Monitor.Enter(lockObject); try { // 访问共享资源的代码 } finally { Monitor.Exit(lockObject); } ``` 这些线程同步技术可以帮助你在多线程环境中实现线程安全和资源互斥访问。根据实际需求,选择适合的同步机制来确保线程间的正确协调。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Andrew_wx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值