C# 线程安全与 lock锁

如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。 
  或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。 
  线程安全问题都是由全局变量及静态变量引起的。 
  若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时对一个变量执行读写操作,一般都需要考虑线程同步,否则就可能影响线程安全。

lock的目的是防止多线程执行的时候出现并发操作问题,加上lock的引用类型的对象,在其锁定的区域内,在一个时刻只允许一个线程操作。

lock只能锁定一个引用类型变量,也就是锁定一个地址

class Program

    {
        static void Main(string[] args)
        {
        threda t=new threda();
        threda.obj.i = 10;
        Thread th1 = new Thread(new ThreadStart(t.hhh));
        th1.Name = "th1";
        th1.Start();

        Thread th2 = new Thread(new ThreadStart(t.hhh));
        th2.Name = "th2";
        th2.Start();
        }
    }

class threda
    {
        public static sss obj = new sss();

        public void hhh()
        {
            lock (obj)
            {
                for (int i = 0; i < 7; i++)
                {
                    Thread.Sleep(500);

                    if (obj.i >0)
                    {
                        obj.i--;
                        Console.WriteLine("当前线程名:"+Thread.CurrentThread.Name+", obj.i= " + obj.i);
                    }
                }
            }
        }

    }

    class sss
    {
       public int i ;
    }

加锁和不加锁运行的结果有区别 :

加锁后:i的值会一个个递减,不会出现跳跃,不会出现重复输出,一直到0值;

不加锁:i的值输出会出现跳跃,不连续递减,可能还会出现-1值输出;

原因:加锁后,一个时刻只能有一个线程执行被锁区域的代码,两个线程都是有先后顺序执行的,所以不会出现间断输出。

时间: 2024-12-20 19:27:22

C# 线程安全与 lock锁的相关文章

线程高级篇-Lock锁和Condition条件

浅谈Synchronized: synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程 便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况: 1).获取锁的线程执行完该代码块,然后线程释放对锁的占有; 2).线程执行发生异常,此时JVM会让线程自动释放锁; 3).调用wait方法,在等待的时候立即释放锁,方便其他的线程使用锁. Lock的特性: 1).Lo

JAVA基础再回首(二十五)——Lock锁的使用、死锁问题、多线程生产者和消费者、线程池、匿名内部类使用多线程、定时器、面试题

JAVA基础再回首(二十五)--Lock锁的使用.死锁问题.多线程生产者和消费者.线程池.匿名内部类使用多线程.定时器.面试题 版权声明:转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917 我们来继续学习多线程 Lock锁的使用 虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock Lock void lock():获取锁 v

java 线程 Lock 锁使用Condition实现线程的等待(await)与通知(signal)

一.Condition 类 在前面我们学习与synchronized锁配合的线程等待(Object.wait)与线程通知(Object.notify),那么对于JDK1.5 的 java.util.concurrent.locks.ReentrantLock 锁,JDK也为我们提供了与此功能相应的类java.util.concurrent.locks.Condition.Condition与重入锁是通过lock.newCondition()方法产生一个与当前重入锁绑定的Condtion实例,我们

Lock锁_线程_线程域

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锁_线程_线程

使用Lock锁实现线程同步

Lock锁:对需要上锁的地方上锁1) JDK1.5后新增的功能2)与Synchronized相比,Lock 可提供多种锁方案,更灵活3) Java.util.concurrent.lock 中的Lock是一个接口,它的实现类是一个Java类,而不是作为语言的特性(关键字)来实现注意:如果同步代码有异常,要将unLock0放到finally 中 使用步骤1)创建Lock对象2)调用lock0方法上锁3)调用unlock0方法解锁 Lock与synchronized的区别1) Lock是显示锁(手动

Java深入学习12:线程按目标顺序执行以及Lock锁和Condiiton接口

Java深入学习12:线程按目标顺序执行以及Lock锁和Condiiton接口 一.一个多线程问题,有三类线程,分别是A.B.C,如如实现ABCABCABCABCABC,顺次执行. 方案1.代码如下 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Thr

java 线程七-Lock锁

JDK1.5中提供了多线程升级解决方案. 将同步synchronized替换成显式Lock操作. 将Object中的wait,notify,notifyAll,替换成了condition对象.该对象可以通过Lock锁进行获取. 一个Lock锁可以生成多个condition对象. 该示例中实现了本方只唤醒对方的操作. import java.util.concurrent.locks.*; class Resource { private String name; private int num=

java.util.concurrent.locks lock锁【2】

Lock 锁介绍 JDK1.5以前,我们实现线程同步都是通过synchroized关键字进行方法或者语句块锁定,以保证该关键字作用域内的操作都是原子性操作. JDK1.5以后,提供的并发包提供了更强大的功能和更为灵活,最为关键的是需要手工释放锁,需要unlock必须在finally方法内.这是非常值得注意的事情. 介绍一下Lock接口.实现类有3个,分别是 普通锁,读写锁-写锁,读写锁-读锁. API文档给出了相近的说明和demo. Lock l = ...; l.lock(); try { /

线程同步(互斥锁与信号量的作用与区别)

“信号量用在多线程多任务同步的,一个线程完成了某一个动作就通过信号量告诉别的线程,别的线程再进行某些动作(大家都在semtake的时候,就阻塞在 哪里).而互斥锁是用在多线程多任务互斥的,一个线程占用了某一个资源,那么别的线程就无法访问,直到这个线程unlock,其他的线程才开始可以利用这 个资源.比如对全局变量的访问,有时要加锁,操作完了,在解锁.有的时候锁和信号量会同时使用的” 也就是说,信号量不一定是锁定某一个资源,而是流程上的概念,比如:有A,B两个线程,B线程要等A线程完成某一任务以后