静态方法与实例方法,多线程,性能

Question

你能帮忙解释一下多线程如何访问静态方法吗？多个线程是否能够同时访问静态方法？

对我来说,如果一个方法是静态的,那将使它成为所有线程共享的单一资源似乎是合乎逻辑的.因此,一次只能有一个线程使用它.我创建了一个控制台应用程序来测试它.但是根据我的测试结果,似乎我的假设不正确.

在我的测试Worker中,构建了许多对象.每个Worker都有许多密码和密钥.每个Worker都有一个实例方法,用它的密钥散列它的密码.还有一个静态方法具有完全相同的实现,唯一的区别是它是静态的.Worker创建所有对象后,将开始时间写入控制台.然后DoInstanceWork引发一个事件,所有Worker对象将它们排队useInstanceMethod到线程池.当所有方法或所有Worker对象都已完成时,它们完成所需的时间将从开始时间计算并写入控制台.然后将开始时间设置为当前时间并DoStaticWork引发事件.这次所有Worker对象都将它们排队useStaticMethod到线程池.当所有这些方法调用完成时,它们完成所有完成所花费的时间再次计算并写入控制台.

我期待对象使用其实例方法所花费的时间是使用静态方法所花费时间的1/8.1/8因为我的机器有4个核心和8个虚拟线程.但事实并非如此.事实上,使用静态方法所花费的时间实际上要快一些.

这是怎么回事？引擎盖下发生了什么？每个线程都获得它自己的静态方法副本吗？

这是控制台应用程序 -

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Threading;

namespace bottleneckTest
{
    public delegate void workDelegate();

    class Program
    {
        static int num = 1024;
        public static DateTime start;
        static int complete = 0;
        public static event workDelegate DoInstanceWork;
        public static event workDelegate DoStaticWork;
        static bool flag = false;

        static void Main(string[] args)
        {
            List<Worker> workers = new List<Worker>();
            for( int i = 0; i < num; i++){
                workers.Add(new Worker(i, num));
            }
            start = DateTime.UtcNow;
            Console.WriteLine(start.ToString());
            DoInstanceWork();
            Console.ReadLine();
        }
        public static void Timer()
        {
            complete++;
            if (complete == num)
            {
                TimeSpan duration = DateTime.UtcNow - Program.start;
                Console.WriteLine("Duration:  {0}", duration.ToString());
                complete = 0;
                if (!flag)
                {
                    flag = true;
                    Program.start = DateTime.UtcNow;
                    DoStaticWork();
                }
            }
        }
    }
    public class Worker
    {
        int _id;
        int _num;
        KeyedHashAlgorithm hashAlgorithm;
        int keyLength;
        Random random;
        List<byte[]> _passwords;
        List<byte[]> _keys;
        List<byte[]> hashes;

        public Worker(int id, int num)
        {
            this._id = id;
            this._num = num;
            hashAlgorithm = KeyedHashAlgorithm.Create("HMACSHA256");
            keyLength = hashAlgorithm.Key.Length;
            random = new Random();
            _passwords = new List<byte[]>();
            _keys = new List<byte[]>();
            hashes = new List<byte[]>();
            for (int i = 0; i < num; i++)
            {
                byte[] key = new byte[keyLength];
                new RNGCryptoServiceProvider().GetBytes(key);
                _keys.Add(key);

                int passwordLength = random.Next(8, 20);
                byte[] password = new byte[passwordLength * 2];
                random.NextBytes(password);
                _passwords.Add(password);
            }
            Program.DoInstanceWork += new workDelegate(doInstanceWork);
            Program.DoStaticWork += new workDelegate(doStaticWork);
        } 
        public void doInstanceWork()
        {
            ThreadPool.QueueUserWorkItem(useInstanceMethod, new WorkerArgs() { num = _num, keys = _keys, passwords = _passwords });
        }
        public void doStaticWork()
        {
            ThreadPool.QueueUserWorkItem(useStaticMethod, new WorkerArgs() { num = _num, keys = _keys, passwords = _passwords });
        }
        public void useInstanceMethod(object args)
        {
            WorkerArgs workerArgs = (WorkerArgs)args;
            for (int i = 0; i < workerArgs.num; i++)
            {
                KeyedHashAlgorithm hashAlgorithm = KeyedHashAlgorithm.Create("HMACSHA256");
                hashAlgorithm.Key = workerArgs.keys[i];
                byte[] hash = hashAlgorithm.ComputeHash(workerArgs.passwords[i]);
            }
            Program.Timer();
        }
        public static void useStaticMethod(object args)
        {
            WorkerArgs workerArgs = (WorkerArgs)args;
            for (int i = 0; i < workerArgs.num; i++)
            {
                KeyedHashAlgorithm hashAlgorithm = KeyedHashAlgorithm.Create("HMACSHA256");
                hashAlgorithm.Key = workerArgs.keys[i];
                byte[] hash = hashAlgorithm.ComputeHash(workerArgs.passwords[i]);
            }
            Program.Timer();
        }
        public class WorkerArgs
        {
            public int num;
            public List<byte[]> passwords;
            public List<byte[]> keys;
        }
    }
}

Answer 1

方法是代码 - 线程同时访问该代码没有问题,因为代码没有通过运行来修改; 它是一个只读资源(抛开抖动).在多线程情况下需要仔细处理的是同时访问数据(更具体地说,在修改数据时可能).方法是否static或实例方法与是否需要以某种方式进行序列化以使其线程安全无关.