多线程遇上委托以及静态

作者: 小米或者黄大仙_fcb5 | 来源:发表于2021-04-23 14:17 被阅读0次

这是一段很有意思的代码：

 public class HomeController : Controller
    {
        public delegate string TestDelegateNoResult();

        public ActionResult Index()
        {
            TestDelegateNoResult testDelegateNoResult = new TestDelegateNoResult(new TestLock().Addition);
            //这里实现的是调用部分 尝试在循环内以：
            // 1. thread 委托调用 2.thread 实例化调用 3.task 委托调用 4.task 实例化调用
            // 4种情况分别调用Addition方法

            for (int i = 0; i < 10; i++)
            {
                new Thread(() =>
                {
                    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                    //System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                }).Start();
                //Task.Run(() =>
                //{
                //    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                //    System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                //});
            }
            return View();
        }
    }


    public class TestLock
    {
        private object obj = new object();
        private static object static_object = new object();
        private static int staticTotal = 0;
        private int total = 0;
        // 这是一个尝试用非静态锁 obj，静态锁 static_object
        // 静态变量staticTotal，非静态变量total 查看累加后数值及使用线程情况的方法
        public string Addition()
        {
            lock (static_object) // obj
            {
                for (int i = 0; i <= 50; i++)
                {
                    staticTotal += i; // total
                    Thread.Sleep(5);
                }
                return staticTotal.ToString() + " thread:" + Thread.CurrentThread.ManagedThreadId;
            }
        }
    }

来看看我都得到了什么结果呢？

使用Task，委托，lock static object，计算total：1275 thread:4
使用Task，委托，lock static object，计算total：2550 thread:3
使用Task，委托，lock static object，计算total：3825 thread:4
使用Task，委托，lock static object，计算total：5100 thread:3
使用Task，委托，lock static object，计算total：6375 thread:5
使用Task，委托，lock static object，计算total：7650 thread:6
使用Task，委托，lock static object，计算total：8925 thread:7
使用Task，委托，lock static object，计算total：10200 thread:8
使用Task，委托，lock static object，计算total：11475 thread:9
使用Task，委托，lock static object，计算total：12750 thread:10

使用Task，委托，lock static object，计算static total：1275 thread:3
使用Task，委托，lock static object，计算static total：2550 thread:4
使用Task，委托，lock static object，计算static total：3825 thread:3
使用Task，委托，lock static object，计算static total：5100 thread:5
使用Task，委托，lock static object，计算static total：6375 thread:6
使用Task，委托，lock static object，计算static total：7650 thread:7
使用Task，委托，lock static object，计算static total：8925 thread:8
使用Task，委托，lock static object，计算static total：10200 thread:9
使用Task，委托，lock static object，计算static total：11475 thread:10
使用Task，委托，lock static object，计算static total：12750 thread:4

使用Task，委托，lock object，计算static total：1275 thread:4
使用Task，委托，lock object，计算static total：2550 thread:3
使用Task，委托，lock object，计算static total：3825 thread:4
使用Task，委托，lock object，计算static total：5100 thread:5
使用Task，委托，lock object，计算static total：6375 thread:6
使用Task，委托，lock object，计算static total：7650 thread:7
使用Task，委托，lock object，计算static total：8925 thread:8
使用Task，委托，lock object，计算static total：10200 thread:9
使用Task，委托，lock object，计算static total：11475 thread:10
使用Task，委托，lock object，计算static total：12750 thread:3

使用Task，委托，lock object，计算total：1275 thread:3
使用Task，委托，lock object，计算total：2550 thread:4
使用Task，委托，lock object，计算total：3825 thread:3
使用Task，委托，lock object，计算total：5100 thread:4
使用Task，委托，lock object，计算total：6375 thread:5
使用Task，委托，lock object，计算total：7650 thread:7
使用Task，委托，lock object，计算total：8925 thread:6
使用Task，委托，lock object，计算total：10200 thread:8
使用Task，委托，lock object，计算total：11475 thread:9
使用Task，委托，lock object，计算total：12750 thread:10

使用Task，实例化调用，lock static object，计算total：1275 thread:4
使用Task，实例化调用，lock static object，计算total：1275 thread:3
使用Task，实例化调用，lock static object，计算total：1275 thread:4
使用Task，实例化调用，lock static object，计算total：1275 thread:3
使用Task，实例化调用，lock static object，计算total：1275 thread:6
使用Task，实例化调用，lock static object，计算total：1275 thread:7
使用Task，实例化调用，lock static object，计算total：1275 thread:5
使用Task，实例化调用，lock static object，计算total：1275 thread:8
使用Task，实例化调用，lock static object，计算total：1275 thread:9
使用Task，实例化调用，lock static object，计算total：1275 thread:10

使用Task，实例化调用，lock static object，计算static total：1275 thread:3
使用Task，实例化调用，lock static object，计算static total：2550 thread:4
使用Task，实例化调用，lock static object，计算static total：3825 thread:3
使用Task，实例化调用，lock static object，计算static total：5100 thread:5
使用Task，实例化调用，lock static object，计算static total：6375 thread:6
使用Task，实例化调用，lock static object，计算static total：7650 thread:7
使用Task，实例化调用，lock static object，计算static total：8925 thread:8
使用Task，实例化调用，lock static object，计算static total：10200 thread:9
使用Task，实例化调用，lock static object，计算static total：11475 thread:10
使用Task，实例化调用，lock static object，计算static total：12750 thread:4

//这个每次都不一样，这里列跑两次的数据
//1
使用Task，实例化调用，lock object，计算static total：7617 thread:4
使用Task，实例化调用，lock object，计算static total：7810 thread:3
使用Task，实例化调用，lock object，计算static total：8161 thread:7
使用Task，实例化调用，lock object，计算static total：8214 thread:10
使用Task，实例化调用，lock object，计算static total：8264 thread:8
使用Task，实例化调用，lock object，计算static total：8268 thread:5
使用Task，实例化调用，lock object，计算static total：8268 thread:9
使用Task，实例化调用，lock object，计算static total：8268 thread:6
使用Task，实例化调用，lock object，计算static total：10596 thread:4
使用Task，实例化调用，lock object，计算static total：10596 thread:3
//2
使用Task，实例化调用，lock object，计算static total：8882 thread:4
使用Task，实例化调用，lock object，计算static total：8882 thread:3
使用Task，实例化调用，lock object，计算static total：8882 thread:5
使用Task，实例化调用，lock object，计算static total：8882 thread:7
使用Task，实例化调用，lock object，计算static total：8882 thread:8
使用Task，实例化调用，lock object，计算static total：8882 thread:10
使用Task，实例化调用，lock object，计算static total：8882 thread:9
使用Task，实例化调用，lock object，计算static total：8882 thread:6
使用Task，实例化调用，lock object，计算static total：11350 thread:3
使用Task，实例化调用，lock object，计算static total：11350 thread:4

使用Task，实例化调用，lock object，计算total：1275 thread:6
使用Task，实例化调用，lock object，计算total：1275 thread:4
使用Task，实例化调用，lock object，计算total：1275 thread:8
使用Task，实例化调用，lock object，计算total：1275 thread:10
使用Task，实例化调用，lock object，计算total：1275 thread:9
使用Task，实例化调用，lock object，计算total：1275 thread:5
使用Task，实例化调用，lock object，计算total：1275 thread:3
使用Task，实例化调用，lock object，计算total：1275 thread:7
使用Task，实例化调用，lock object，计算total：1275 thread:6
使用Task，实例化调用，lock object，计算total：1275 thread:4

使用Thread，委托，lock static object，计算total：1275 thread:5
使用Thread，委托，lock static object，计算total：2550 thread:6
使用Thread，委托，lock static object，计算total：3825 thread:8
使用Thread，委托，lock static object，计算total：5100 thread:9
使用Thread，委托，lock static object，计算total：6375 thread:10
使用Thread，委托，lock static object，计算total：7650 thread:11
使用Thread，委托，lock static object，计算total：8925 thread:12
使用Thread，委托，lock static object，计算total：10200 thread:13
使用Thread，委托，lock static object，计算total：11475 thread:14
使用Thread，委托，lock static object，计算total：12750 thread:15

使用Thread，委托，lock static object，计算static total：1275 thread:5
使用Thread，委托，lock static object，计算static total：2550 thread:6
使用Thread，委托，lock static object，计算static total：3825 thread:8
使用Thread，委托，lock static object，计算static total：5100 thread:10
使用Thread，委托，lock static object，计算static total：6375 thread:13
使用Thread，委托，lock static object，计算static total：7650 thread:14
使用Thread，委托，lock static object，计算static total：8925 thread:15
使用Thread，委托，lock static object，计算static total：10200 thread:16
使用Thread，委托，lock static object，计算static total：11475 thread:17
使用Thread，委托，lock static object，计算static total：12750 thread:18

使用Thread，委托，lock object，计算static total：1275 thread:6
使用Thread，委托，lock object，计算static total：2550 thread:7
使用Thread，委托，lock object，计算static total：3825 thread:8
使用Thread，委托，lock object，计算static total：5100 thread:9
使用Thread，委托，lock object，计算static total：6375 thread:10
使用Thread，委托，lock object，计算static total：7650 thread:11
使用Thread，委托，lock object，计算static total：8925 thread:12
使用Thread，委托，lock object，计算static total：10200 thread:13
使用Thread，委托，lock object，计算static total：11475 thread:14
使用Thread，委托，lock object，计算static total：12750 thread:15

使用Thread，委托，lock object，计算total：1275 thread:5
使用Thread，委托，lock object，计算total：2550 thread:6
使用Thread，委托，lock object，计算total：3825 thread:8
使用Thread，委托，lock object，计算total：5100 thread:9
使用Thread，委托，lock object，计算total：6375 thread:10
使用Thread，委托，lock object，计算total：7650 thread:11
使用Thread，委托，lock object，计算total：8925 thread:12
使用Thread，委托，lock object，计算total：10200 thread:13
使用Thread，委托，lock object，计算total：11475 thread:14
使用Thread，委托，lock object，计算total：12750 thread:15


使用Thread，实例化调用，lock static object，计算total：1275 thread:5
使用Thread，实例化调用，lock static object，计算total：1275 thread:6
使用Thread，实例化调用，lock static object，计算total：1275 thread:7
使用Thread，实例化调用，lock static object，计算total：1275 thread:10
使用Thread，实例化调用，lock static object，计算total：1275 thread:14
使用Thread，实例化调用，lock static object，计算total：1275 thread:15
使用Thread，实例化调用，lock static object，计算total：1275 thread:16
使用Thread，实例化调用，lock static object，计算total：1275 thread:17
使用Thread，实例化调用，lock static object，计算total：1275 thread:18
使用Thread，实例化调用，lock static object，计算total：1275 thread:19

使用Thread，实例化调用，lock static object，计算static total：1275 thread:5
使用Thread，实例化调用，lock static object，计算static total：2550 thread:6
使用Thread，实例化调用，lock static object，计算static total：3825 thread:7
使用Thread，实例化调用，lock static object，计算static total：5100 thread:9
使用Thread，实例化调用，lock static object，计算static total：6375 thread:10
使用Thread，实例化调用，lock static object，计算static total：7650 thread:11
使用Thread，实例化调用，lock static object，计算static total：8925 thread:12
使用Thread，实例化调用，lock static object，计算static total：10200 thread:13
使用Thread，实例化调用，lock static object，计算static total：11475 thread:14
使用Thread，实例化调用，lock static object，计算static total：12750 thread:15

//每次结果不一样
//1
使用Thread，实例化调用，lock object，计算static total：9696 thread:5
使用Thread，实例化调用，lock object，计算static total：10188 thread:10
使用Thread，实例化调用，lock object，计算static total：10338 thread:8
使用Thread，实例化调用，lock object，计算static total：10338 thread:6
使用Thread，实例化调用，lock object，计算static total：10438 thread:13
使用Thread，实例化调用，lock object，计算static total：10438 thread:15
使用Thread，实例化调用，lock object，计算static total：10438 thread:14
使用Thread，实例化调用，lock object，计算static total：10438 thread:12
使用Thread，实例化调用，lock object，计算static total：10438 thread:11
使用Thread，实例化调用，lock object，计算static total：10438 thread:16
//2
使用Thread，实例化调用，lock object，计算static total：9568 thread:5
使用Thread，实例化调用，lock object，计算static total：9470 thread:6
使用Thread，实例化调用，lock object，计算static total：9616 thread:8
使用Thread，实例化调用，lock object，计算static total：10063 thread:10
使用Thread，实例化调用，lock object，计算static total：10063 thread:15
使用Thread，实例化调用，lock object，计算static total：10063 thread:18
使用Thread，实例化调用，lock object，计算static total：10063 thread:17
使用Thread，实例化调用，lock object，计算static total：10063 thread:20
使用Thread，实例化调用，lock object，计算static total：10113 thread:16
使用Thread，实例化调用，lock object，计算static total：10113 thread:19

使用Thread，实例化调用，lock object，计算total：1275 thread:7
使用Thread，实例化调用，lock object，计算total：1275 thread:5
使用Thread，实例化调用，lock object，计算total：1275 thread:11
使用Thread，实例化调用，lock object，计算total：1275 thread:6
使用Thread，实例化调用，lock object，计算total：1275 thread:13
使用Thread，实例化调用，lock object，计算total：1275 thread:12
使用Thread，实例化调用，lock object，计算total：1275 thread:10
使用Thread，实例化调用，lock object，计算total：1275 thread:16
使用Thread，实例化调用，lock object，计算total：1275 thread:15
使用Thread，实例化调用，lock object，计算total：1275 thread:14

好，现在来分析一下以上的结果
1.很显然发现，使用task会存在线程复用的情况，thread线程一直是往上增的，而且发现线程用完就退出了，而task线程结束之后会有一段时间的等待（task是基于threadpool），发现没有任务需要执行然后才退出，这就是task相比thread更强大的线程管理功能：task不会让线程无限的创建，并且会让部分任务阻塞等待其他任务执行完成。

2.很奇怪的一点：当使用委托方法调用时，无论是不是用的静态锁，是不是用的静态变量做数据累加，计算出来的total/statictotal都没有存在相同的情况。我本来理解的是，假如使用的是非静态锁，那么都可能会存在多线程同时修改计数器的情况，参考实例化直接调用的并使用非静态锁打印出来的数据，应该是statictotal或total都有出现数值一样（说明他们有同时进入房间），但是委托调用的结果出乎了我的意料。

微软对委托调用的解释

这就说得通了，由于这个委托是在线程调用之前实例化的，创建线程去调用委托的时候相当于是多个线程调用同一个委托，在调用时依旧是顺序调用的，那么就不存在异步抢占资源的情况。
那假如我在线程中再去对委托实例化呢？
让我们把调用部分代码改成这样：

 public ActionResult Index()
        {
            TestDelegateNoResult testDelegateNoResult;
            for (int i = 0; i < 10; i++)
            {
                new Thread(() =>
                {
                    // 在线程中实例化
                    testDelegateNoResult = new TestDelegateNoResult(new TestLock().Addition);
                    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                    //System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                }).Start();
                //Task.Run(() =>
                //{
                //    System.Diagnostics.Debug.WriteLine(testDelegateNoResult());
                //    System.Diagnostics.Debug.WriteLine(new TestLock().Addition());
                //});
            }
            return View();
        }

再来看看得到的结果：

使用Thread，委托调用，lock object，计算static total： 11726 thread:7
使用Thread，委托调用，lock object，计算static total： 11871 thread:9 // 出现重复
使用Thread，委托调用，lock object，计算static total： 11871 thread:10
使用Thread，委托调用，lock object，计算static total： 11921 thread:11
使用Thread，委托调用，lock object，计算static total： 12167 thread:12
使用Thread，委托调用，lock object，计算static total： 12366 thread:16
使用Thread，委托调用，lock object，计算static total： 12216 thread:13
使用Thread，委托调用，lock object，计算static total： 12366 thread:14
使用Thread，委托调用，lock object，计算static total： 12366 thread:15
使用Thread，委托调用，lock object，计算static total： 12019 thread:8

使用Thread，委托调用，lock statc object，计算static total：1275 thread:7
使用Thread，委托调用，lock statc object，计算static total：2550 thread:8
使用Thread，委托调用，lock statc object，计算static total：3825 thread:9
使用Thread，委托调用，lock statc object，计算static total：5100 thread:10
使用Thread，委托调用，lock statc object，计算static total：6375 thread:11
使用Thread，委托调用，lock statc object，计算static total：7650 thread:12
使用Thread，委托调用，lock statc object，计算static total：8925 thread:13
使用Thread，委托调用，lock statc object，计算static total：10200 thread:14
使用Thread，委托调用，lock statc object，计算static total：11475 thread:15
使用Thread，委托调用，lock statc object，计算static total：12750 thread:16

每次实例化的时候相当于创建了一个新的委托，就是多个线程调用多个委托，运行得到的结果就和实例化调用时得到的结果一致了

3.静态锁情况下，分别计算total和statictotal的结果，发现statictotal是累加的，而total始终为同一个值。
实例化调用的时候，非静态的变量每次都会被初始化，而静态的变量它会保留之前一次更新的数值。
因此，statictotal会从上一次的更新开始累加而total每次都从0开始累加

另外，提醒一个关于lock需要注意的地方:
文档地址：https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/lock-statement

lock

我关于这两句话的理解是，对于可以被公共访问的实例，大家共享了资源因此lock无效。实例化的时候，lock不同的对象，则锁无效。
接下来尝试lock this、lock type、lock string：
1.lock this: 每次被实例化之后 this为不同的对象因此锁无效

使用Thread，实例化调用，lock this，计算static total：11199 thread: 12
使用Thread，实例化调用，lock this，计算static total：11536 thread: 13
使用Thread，实例化调用，lock this，计算static total：11877 thread: 14
使用Thread，实例化调用，lock this，计算static total：11927 thread: 15
使用Thread，实例化调用，lock this，计算static total：11877 thread: 16
使用Thread，实例化调用，lock this，计算static total：12220 thread: 19
使用Thread，实例化调用，lock this，计算static total：11877 thread: 17
使用Thread，实例化调用，lock this，计算static total：12122 thread: 18
使用Thread，实例化调用，lock this，计算static total：12320 thread: 20
使用Thread，实例化调用，lock this，计算static total：12320 thread: 21

2.lock type: 每次type都能确认是同一个值，因此锁是有用的

使用Thread，实例化调用，lock type，计算static total：1275 thread:7
使用Thread，实例化调用，lock type，计算static total：2550 thread:8
使用Thread，实例化调用，lock type，计算static total：3825 thread:9
使用Thread，实例化调用，lock type，计算static total：5100 thread:10
使用Thread，实例化调用，lock type，计算static total：6375 thread:11
使用Thread，实例化调用，lock type，计算static total：7650 thread:12
使用Thread，实例化调用，lock type，计算static total：8925 thread:13
使用Thread，实例化调用，lock type，计算static total：10200 thread:14
使用Thread，实例化调用，lock type，计算static total：11475 thread:15
使用Thread，实例化调用，lock type，计算static total：12750 thread:16

但是！请注意，但是！
我们试试这样调用：
System.Diagnostics.Debug.WriteLine(new TestLock().BFunction());
System.Diagnostics.Debug.WriteLine(new TestLock().Addition());

用type给两个方法加锁
进入BFunction之后，锁住BFunction同时，也将Addition锁死了

BFunction sleep over
BFunction sleep over
BFunction sleep over
1275 thread:7
2550 thread:8
3825 thread:9
5100 thread:10
6375 thread:11
7650 thread:12
8925 thread:13
10200 thread:14
11475 thread:15
12750 thread:16

3.lock string：每次访问的时候string都重置了，因此能确认是同一个值，因此锁是有用的

使用Thread，实例化调用，lock string，计算static total：1275 thread:7
使用Thread，实例化调用，lock string，计算static total：2550 thread:8
使用Thread，实例化调用，lock string，计算static total：3825 thread:9
使用Thread，实例化调用，lock string，计算static total：5100 thread:10
使用Thread，实例化调用，lock string，计算static total：6375 thread:11
使用Thread，实例化调用，lock string，计算static total：7650 thread:12
使用Thread，实例化调用，lock string，计算static total：8925 thread:13
使用Thread，实例化调用，lock string，计算static total：10200 thread:14
使用Thread，实例化调用，lock string，计算static total：11475 thread:15
使用Thread，实例化调用，lock string，计算static total：12750 thread:16

但是！但是！lock string和lock type一样都可能存在多个地方使用同样的锁的情况
会造成资源锁死。

总结一下：
1.其实大家不要去看lock中锁定的是什么，只要关心多线程锁定的对象是不是为同一个对象，假如锁定的对象确认是同一个对象，则锁是有效的，否则锁即为无效（lock（this）或者lock非静态的实例）。
2.锁必须注意作用域，必须防止在其他地方是否可能使用了相同的锁，以至于把别人的资源锁死的情况(lock (type/string))。

多线程遇上委托以及静态

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读