代碼性能優化

時間  2019-11-18
標籤 代碼 性能 優化 欄目 系統性能 简体版
原文   原文鏈接

隔了好久沒寫東西了,主要是最近比較忙,更主要的是最近比較懶……html

其實這篇很早就想寫了c++

工做和生活中常常能夠看到一些程序猿,寫代碼的時候只關注代碼的邏輯性,而不考慮運行效率正則表達式

其實這對大多數程序猿來講都是沒有問題的性能優化

不過做爲一隻有理想的CodeMonkey,我仍是但願給你們分享一些性能優化心得ide

曾經在網上聽過這樣一句話性能

程序的可讀性和性能是成反比的優化

我很是贊同這句話,因此對於那些極度影響閱讀的性能優化我就不在這裏贅述了ui

今天主要說的就是一些舉手之勞便可完成的性能優化spa

 減小重複代碼

這是最基本的優化方案,儘量減小那些重複作的事,讓他們只作一次3d

比較常見是這種代碼,一樣的Math.Cos(angle) 和Math.Sin(angle)都作了2次

private Point RotatePt(double angle, Point pt)
{
     Point pRet = new Point();
     angle = -angle;
     pRet.X = (int)((double)pt.X * Math.Cos(angle) - (double)pt.Y * Math.Sin(angle));
     pRet.Y = (int)((double)pt.X * Math.Sin(angle) + (double)pt.Y * Math.Cos(angle));
     return pRet;
}
View Code

優化後

private Point RotatePt3(double angle, Point pt)
{
    Point pRet = new Point();
    angle = -angle;
    double SIN_ANGLE = Math.Sin(angle);
    double COS_ANGLE = Math.Cos(angle);
    pRet.X =(int)(pt.X * COS_ANGLE - pt.Y * SIN_ANGLE);
    pRet.Y = (int)(pt.X * SIN_ANGLE + pt.Y * COS_ANGLE);
    return pRet;
}
View Code

還有另外一種 ,在方法中實例化一個對象, 可是這個對象實際上是能夠複用的

public static string ConvertQuot(string html)
{
    Regex regex = new Regex("&(quot|#34);", RegexOptions.IgnoreCase);
    return regex.Replace(html, "\"");
}
View Code

優化後

readonly static Regex ReplaceQuot = new Regex("&(quot|#34);", RegexOptions.IgnoreCase | RegexOptions.Compiled);
public static string ConvertQuot(string html)
{
    return ReplaceQuot.Replace(html, "\"");
}
View Code

還有一種是沒必要要的初始化,好比調用out參數以前,是不須要初始化的

public bool Check(int userid)
{
    var user = new User();
    if(GetUser(userid,out user))
    {
        return user.Level > 1;
    }
    return false;
}
View Code

這裏的new User()就是沒必要要的操做,

優化後

public bool Check(int userid)
{
    User user;
    if(GetUser(userid,out user))
    {
        return user.Level > 1;
    }
    return false;
}
View Code

不要迷信正則表達式

正好在第一個栗子裏說到了正在表達式(Regex)對象就順便一塊兒說了

不少人覺得正則表達式很快,很是快,超級的快

雖然正則表達式是挺快的,不過千萬不要迷信他,不信你看下面的例子

//方法1
public static string ConvertQuot1(string html)
{
    return html.Replace(""", "\"").Replace(""", "\"");
}

readonly static Regex ReplaceQuot = new Regex("&(quot|#34);", RegexOptions.IgnoreCase | RegexOptions.Compiled);
//方法2
public static string ConvertQuot2(string html)
{
    return ReplaceQuot.Replace(html, "\"");
}
View Code

有多少人認爲正則表達式比較快的？

 

結果爲10w次循環的時間 ,即便是10個Replace連用,也比Regex好,因此不要迷信他

//方法1
public static string ConvertQuot1(string html)
{
    return html.Replace("0", "").Replace("1", "").Replace("2", "").Replace("3", "").Replace("4", "").Replace("5", "").Replace("6", "").Replace("7", "").Replace("8", "").Replace("9", "");
}

readonly static Regex ReplaceQuot = new Regex("[1234567890]", RegexOptions.IgnoreCase | RegexOptions.Compiled);
//方法2
public static string ConvertQuot2(string html)
{
    return ReplaceQuot.Replace(html, "");
}
View Code

ConvertQuot1:3518
ConvertQuot2:12479

最後給大家看一個真實的,杯具的例子

Htmlstring = Regex.Replace(Htmlstring, @"<(.[^>]*)>", "", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"([\r\n])[\s]+", "", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"-->", "", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"<!--.*", "", RegexOptions.IgnoreCase);

Htmlstring = Regex.Replace(Htmlstring, @"&(quot|#34);", "\"", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(amp|#38);", "&", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(lt|#60);", "<", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(gt|#62);", ">", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(nbsp|#160);", " ", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(iexcl|#161);", "\xa1", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(cent|#162);", "\xa2", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(pound|#163);", "\xa3", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&(copy|#169);", "\xa9", RegexOptions.IgnoreCase);
Htmlstring = Regex.Replace(Htmlstring, @"&#(\d+);", "", RegexOptions.IgnoreCase);
View Code

合理使用正則表達式

上面說了正則表達式的效率不高,並非說就不要用他了,至少正則表達式的做用不只僅如此而已

若是必定要用正則表達式的話也須要注意,能靜態全局公用的儘可能全局公用

readonly static Regex regex = new Regex("[1234567890]", RegexOptions.Compiled);
View Code

注意他的第二個參數RegexOptions.Compiled 註釋是  指定將正則表達式編譯爲程序集。這會產生更快的執行速度，但會增長啓動時間。

通俗的說就是加了這個枚舉,會使得初始化Regex對象變慢,可是執行字符串查找的時候更快, 不使用的話,初始化不少,查詢比較慢

以前測過相差蠻大的 ,代碼就不比較了,有興趣的能夠本身試試相差多少

另外還有一些枚舉項,不肯定是否對性能有影響,不過仍是按規則使用會比較好

  • RegexOptions.IgnoreCase    // 指定不區分大小寫的匹配,  若是表達式中沒有字母,則不須要設定
  • RegexOptions.Multiline         // 多行模式。更改 ^ 和 $ 的含義….  若是表達式中沒有^和$,則不須要設定
  • RegexOptions.Singleline       // 指定單行模式。更改點 (.) 的含義….  若是表達式中沒有.,則不須要設定

讓編譯器預處理常量的計算

編譯器在編譯程序段的時候 若是發現有一些運算是常量對常量的,那麼他會在編譯期間就計算完成,這樣可使程序在執行時不用重複計算了

不過編譯器有的時候也不是那麼聰明的

這個時候就須要咱們幫助一下了

給他加一個括號,讓他知道應該先計算常量,這樣就能夠在編譯期間進行運算了

字符串比較

這個可能不少人知道了,但仍是提一下

string s = "";
1) if(s == ""){}
2) if(s == string.Empty){}
3) if (string.IsNullOrEmpty(s)) { }
4) if(s != null && s.Length ==0) {} 
5) if((s+"").Length == 0){}
View Code

1,2最慢 3較快 4,5最快

1,2幾乎沒區別 4,5幾乎沒區別

不過這個只適用於比較null和空字符串,若是是連續的空白就是string.IsNullOrWhiteSpace最快了,不過這個方法2.0裏面沒有

因此2.0能夠這樣 (s+」").trim() == 0

這裏的關鍵就是 s + 「」  這個操做能夠把null轉換爲」"

注意第二個參數只能是」"或string.Empty 這樣的累加幾乎是不消耗時間的,若是第二個參數是」 「(一個空格)這個時間就遠遠不止了

字符串拼接

字符串累加,這個道理和Regex同樣,不要盲目崇拜StringBuilder

在大量(或不肯定的)string拼接的時候,StringBuilder確實能夠起到提速的做用

而少數幾個固定的string累加的時候就不須要StringBuilder 了,畢竟StringBuilder 的初始化也是須要時間的

ps: 這段我確實記得我是寫過的來着,不知道怎麼的,發出來的時候就不見了…..

此外還有一個string.Concat方法,該方法能夠小幅度的優化程序的速度,幅度很小

他和string.Join的區別在於沒有間隔符號(我以前經常使用string.Join(「」,a,b,c,d),不要告訴我只有我一我的這麼幹)

另外一種常常遇到的字符串拼接

public string JoinIds(List<User> users)
{
    StringBuilder sb = new StringBuilder();
    foreach (var user in users)
    {
        sb.Append("'");
        sb.Append(user.Id);
        sb.Append("',");
    }
    sb.Length = sb.Length - 1;
    return sb.ToString();
}
View Code

對於這種狀況有2中優化的方案

對於3.5以上能夠直接使用Linq輔助,這種方案代碼少,可是性能相對差一些

public string JoinIds(List<User> users)
{
    return "'" + string.Join("','", users.Select(it => it.Id)) + "'";
}
View Code

對於非3.5或對性能要求極高的場合

public string JoinIds(List<User> users)
{
    var ee = users.GetEnumerator();
    StringBuilder sb = new StringBuilder();
    if (ee.MoveNext())
    {
        sb.Append("'");
        sb.Append(ee.Current.Id);
        sb.Append("'");
        while (ee.MoveNext())
        {
            sb.Append(",'");
            sb.Append(ee.Current.Id);
            sb.Append("'");
        }
    }
    return sb.ToString();
}
View Code

bool類型的判斷返回

這種現象常見於新手中

//寫法1
if(state == 1)
{
    return true;
}
else
{
    return false;
}
//寫法2
return state == 1 ? true : false;
//優化後
return state == 1;
View Code

類型的判斷

通常類型的判斷有2種形式

1,這種屬於代碼比較好寫,可是性能比較低, 緣由就是GetType()的時候消耗了不少時間

Type type = obj.GetType();
switch (type.Name)
{
    case "Int32":
        break;
    case "String":
        break;
    case "Boolean":
        break;
    case "DateTime":
        break;
    ...
    ...
    default:
        break;
}
View Code

2,這種屬性寫代碼麻煩,可是性能很高的類型

if (obj is string)
{

}
else if (obj is int)
{

}
else if (obj is DateTime)
{

}
...
...
else
{

}
View Code

其實有個中間之道,既能夠保證性能又能夠比較好寫

IConvertible conv = obj as IConvertible;
if (conv != null)
{
    switch (conv.GetTypeCode())
    {
        case TypeCode.Boolean:
            break;
        case TypeCode.Byte:
            break;
        case TypeCode.Char:
            break;
        case TypeCode.DBNull:
            break;
        case TypeCode.DateTime:
            break;
        case TypeCode.Decimal:
            break;
        case TypeCode.Double:
            break;
        case TypeCode.Empty:
            break;
        case TypeCode.Int16:
            break;
        case TypeCode.Int32:
            break;
        ...
        ...
        default:
            break;
    }
}
else
{
    //處理其餘類型
}
View Code

大部分狀況下 這個是能夠用的 若是你本身有個類型實現了IConvertible,而後返回TypeCode.Int32 就再也不這個討論範圍以內了

使用枚舉做爲索引

下面這個是一個真實的例子,爲了突出重點,作了部分修改,刪除了多餘的分支,源代碼中不僅4個

enum TemplateCode
{
    None = 0,
    Head = 1,
    Menu = 2,
    Foot = 3,
    Welcome = 4,
}

public string GetHtml(TemplateCode tc)
{
    switch (tc)
    {
        case TemplateCode.Head:
            return GetHead();
        case TemplateCode.Menu:
            return GetMenu();
        case TemplateCode.Foot:
            return GetFoot();
        case TemplateCode.Welcome:
            return GetWelcome();
        default:
            throw new ArgumentOutOfRangeException("tc");
    }
}
View Code

優化後

readonly static Func<string>[] GetTemplate = InitTemplateFunction();

private static Func<string>[] InitTemplateFunction()
{
    var arr = new Func<string>[5];
    arr[1] = GetHead;
    arr[2] = GetMenu;
    arr[3] = GetFoot;
    arr[4] = GetWelcome;
    return arr;
} 

public string GetHtml(TemplateCode tc)
{
    var index = (int)tc;
    if (index >= 1 && index <= 4)
    {
        return GetTemplate[index]();
    }
    throw new ArgumentOutOfRangeException("tc");
}
View Code

不過有的時候,枚舉不必定都是連續的數字,那麼也可使用Dictionary

readonly static Dictionary<TemplateCode, Func<string>> TemplateDict = InitTemplateFunction();

private static Dictionary<TemplateCode, Func<string>> InitTemplateFunction()
{
    var ditc = new Dictionary<TemplateCode, Func<string>>();
    ditc.Add(TemplateCode.Head, GetHead);
    ditc.Add(TemplateCode.Menu, GetMenu);
    ditc.Add(TemplateCode.Foot, GetFoot);
    ditc.Add(TemplateCode.Welcome, GetWelcome);
    return ditc;
} 

public string GetHtml(TemplateCode tc)
{
    Func<string> func;
    if (TemplateDict.TryGetValue(tc,out func))
    {
        return func();
    }
    throw new ArgumentOutOfRangeException("tc");
}
View Code

這種優化在分支比較多的時候很好用,少的時候做用有限

字符類型Char,分支判斷時的處理技巧

這部份內容比較複雜,並且適用範圍有限,若是平時用不到的就能夠忽略了

在處理字符串對象的時候,有時會須要判斷char的值而後作進一步的操做

public string Show(char c)
{
    if (c >= '0' && c <= '9')
    {
        return "數字";
    }
    else if (c >= 'a' && c <= 'z')
    {
        return "小寫字母";
    }
    else if (c >= 'A' && c <= 'Z')
    {
        return "大寫字母";
    }
    else if (c == '/' || c == '\\' || c == '|'
        || c == '$' || c == '#' || c == '+'
        || c == '%' || c == '&' || c == '-'
        || c == '^' || c == '*' || c == '=')
    {
        return "特殊符號";
    }
    else if (c == ',' || c == '.' || c == '!'
        || c == ':' || c == ';' || c == '?'
        || c == '"' || c == '\'')
    {
        return "標點符號";
    }
    else
    {
        return "其餘";
    }
}
View Code

這裏有一種空間換時間的優化方式, 雖然說是空間換時間,可是實際浪費的空間不會不少,由於char最多隻有65536長度

readonly static byte[] CharMap = InitCharMap();

private static byte[] InitCharMap()
{
    var arr = new byte[char.MaxValue];
    for (char i = '0'; i <= '9'; i++)
    {
        arr[i] = 1;
    }
    for (char i = 'a'; i <= 'z'; i++)
    {
        arr[i] = 2;
    }
    for (char i = 'A'; i <= 'Z'; i++)
    {
        arr[i] = 3;
    }
    arr['/'] = 4;
    arr['\\'] = 4;
    arr['|'] = 4;
    arr['$'] = 4;
    arr['#'] = 4;
    arr['+'] = 4;
    arr['%'] = 4;
    arr['&'] = 4;
    arr['-'] = 4;
    arr['^'] = 4;
    arr['*'] = 4;
    arr['='] = 4;

    arr[','] = 5;
    arr['.'] = 5;
    arr['!'] = 5;
    arr[':'] = 5;
    arr[';'] = 5;
    arr['?'] = 5;
    arr['"'] = 5;
    arr['\''] = 5;
    return arr;
}

public string Show(char c)
{
    switch (CharMap[c])
    {
        case 0:
            return "其餘";
        case 1:
            return "數字";
        case 2:
            return "小寫字母";
        case 3:
            return "大寫字母";
        case 4:
            return "特殊符號";
        case 5:
            return "標點符號";
        default:
            return "其餘";
    }
}
View Code

原先僅特殊符號一部分就須要判斷12次,修改事後只判斷一次就能夠獲得結果了

這方面的例子在Json組件中也有使用

 摘取部分blqw.Json的代碼 
/// <summary>
/// <para>包含1: 能夠爲頭的字符</para>
/// <para>包含2: 能夠爲單詞的字符</para>
/// <para>包含4: 能夠爲數字的字符</para>
/// <para>等於8: 空白字符</para>
/// <para>包含16:轉義字符</para>
/// <para></para>
/// </summary>
private readonly static byte[] _WordChars = new byte[char.MaxValue];
private readonly static sbyte[] _UnicodeFlags = new sbyte[123];
private readonly static sbyte[, ,] _DateTimeWords;
static UnsafeJsonReader()
{
    for (int i = 0; i < 123; i++)
    {
        _UnicodeFlags[i] = -1;
    }

    _WordChars['-'] = 1 | 4;
    _WordChars['+'] = 1 | 4;

    _WordChars['$'] = 1 | 2;
    _WordChars['_'] = 1 | 2;
    for (char c = 'a'; c <= 'z'; c++)
    {
        _WordChars[c] = 1 | 2;
        _UnicodeFlags[c] = (sbyte)(c - 'a' + 10);
    }
    for (char c = 'A'; c <= 'Z'; c++)
    {
        _WordChars[c] = 1 | 2;
        _UnicodeFlags[c] = (sbyte)(c - 'A' + 10);
    }

    _WordChars['.'] = 1 | 2 | 4;
    for (char c = '0'; c <= '9'; c++)
    {
        _WordChars[c] = 4;
        _UnicodeFlags[c] = (sbyte)(c - '0');
    }

    //科學計數法
    _WordChars['e'] |= 4;
    _WordChars['E'] |= 4;

    _WordChars[' '] = 8;
    _WordChars['\t'] = 8;
    _WordChars['\r'] = 8;
    _WordChars['\n'] = 8;


    _WordChars['t'] |= 16;
    _WordChars['r'] |= 16;
    _WordChars['n'] |= 16;
    _WordChars['f'] |= 16;
    _WordChars['0'] |= 16;
    _WordChars['"'] |= 16;
    _WordChars['\''] |= 16;
    _WordChars['\\'] |= 16;
    _WordChars['/'] |= 16;


    string[] a =  { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec" };
    string[] b =  { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
    _DateTimeWords = new sbyte[23, 21, 25];

    for (sbyte i = 0; i < a.Length; i++)
    {
        var d = a[i];
        _DateTimeWords[d[0] - 97, d[1] - 97, d[2] - 97] = (sbyte)(i + 1);
    }

    for (sbyte i = 0; i < b.Length; i++)
    {
        var d = b[i];
        _DateTimeWords[d[0] - 97, d[1] - 97, d[2] - 97] = (sbyte)-(i + 1);
    }
    _DateTimeWords['g' - 97, 'm' - 97, 't' - 97] = sbyte.MaxValue;
}

摘取部分blqw.Json的代碼
View Code

我寫的文章,除了純代碼,其餘的都是想表達一種思想,一種解決方案.但願各位看官不要侷限於文章中的現成的代碼,要多關注整個文章的主題思路,謝謝!

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程