mysql 資料庫連結狀態確認實驗(推薦)

2022-10-02 14:01:45

1.起因：

在做一個小系統的時候，我想資料量互動不大，就都用一個連結執行算了，還能節省點資源，但是實際情況遇到了如下問題，在使用的過程中，有些資料操作會被轉移到其他執行緒，這樣；我這個簡單的想法遇到了問題，因為一個現場在使用這個連結的時候，其他執行緒也會同步插入執行資料操作，這樣一個連結就會面臨共用的衝突，怎麼辦呢，有如下三種方案：

1.1.資料兩次一次一聯，一用，一釋放。

1.2.強制是資料庫的執行放到一個現場，那麼得把所有的執行引數放到佇列中，有資料支援的執行緒按照佇列的順序執行。也可以在使用的時候把連結索起來。這樣強制的使資料的處理序列。

1.3.做一個內部的連結物件使用池，池中的物件可供服用，解決重複連結的問題，提供多個物件解決現場使用衝突的問題。

我選擇了方案三，做了如下實驗，記錄如下

2.實驗

2.1 確認資料連結狀態，使用完的資料連結是什麼狀態呢？

2.1.1 目的：我想根據連結的狀態判斷連結是在使用中，還是可以給別人使用；就是在可以使用的情況下，我就用該連結執行，否則使用或者建立其他的連結。

程式碼。

using System;
using System.Data;
 
namespace 資料庫連結狀態確認
{
    /// <summary>
    /// 確認資料庫通常執行完成是什麼狀態
    /// </summary>
    public class Test1:Singleton<Test1>
    {
        public void main()
        {
            test1();
        }
        private void test1()
        {
            DBmsqlSub dBmsqlSub = new DBmsqlSub();
            string sql = "insert into tb1(v1) values(2)";
            dBmsqlSub.ExecuteNonQuery(sql);
            ConnectionState connectionState = dBmsqlSub.getState();
            Console.WriteLine(connectionState);
            dBmsqlSub.Close();
        }
    }
}

結果，整理使用後的連結狀態是open,那是不是open的時候就可以供別人使用了呢，要是在執行的時候也是open狀態，那我就沒有判定已經了。

資料庫連結狀態確認
id0
index:1 isuser:False setuser:False
Open

2.2 資料庫在執行的時候，是不是有一個執行中的狀態呢？

程式碼

using System;
using System.Threading.Tasks;
 
namespace 資料庫連結狀態確認
{
    /// <summary>
    /// 目的：確認執行中的資料狀態
    /// </summary>
    class Test2:Singleton<Test2>
    {
        public void main() {
            DBmsqlSub dBmsqlSub = new DBmsqlSub();
            Task.Factory.StartNew(test2Exe, (Object)dBmsqlSub);
            Task.Factory.StartNew(test2Exe, (Object)dBmsqlSub);
            Task.Factory.StartNew(test2State, dBmsqlSub);
        }
        private void test2Exe(object dBmsqlSub)
        {
            int index = 1;
            while (true)
            {
                index++;
                string sql = "insert into tb1(v1) values(" + index + ")";
                ((DBmsqlSub)dBmsqlSub).ExecuteNonQuery(sql);
                Task.Delay(200);
            }
        }
        private void test2State(object dBmsqlSub)
        {
            while (true)
            {
                Console.WriteLine(((DBmsqlSub)dBmsqlSub).getState());
            }
        }
    }
}

行結果執：即使執行中，物件的連結狀態依然是open，那麼用連結狀態作為連結是否可用的計劃泡湯了，那就只能用自新增的物件來控制連結是否可用了。

Open
Open
Open
Open
id0
Open
Open
Open
Open
Open
Open

2.3 測試3：新增物件的狀態，控制連結是否可用

2.3.1 程式碼

using MySqlConnector;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace 資料庫連結狀態確認
{
    class Test3:Singleton<Test3>
    {
        public void main() {
            test1();
            //test1();
        }
        private void test1() {
            Task.Factory.StartNew(test2Exe);
            Task.Factory.StartNew(test2Exe);
            Task.Factory.StartNew(test2Exe);
        }
        private void test2Exe()
        {
            int index = 1;
            while (true)
            {
                index++;
                string sql = "insert into tb1(v1) values(" + index + ")";
                DBmsql.getMy().ExecuteNonQuery(sql);
            }
        }
 
        private object MySqlDataReader(DBmsqlSub dBmsqlSub)
        {
            throw new NotImplementedException();
        }
 
        private void test2State(object dBmsqlSub)
        {
            while (true)
            {
                Console.WriteLine(((DBmsqlSub)dBmsqlSub).getState());
            }
        }
    }
}

2.3.2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace 資料庫連結狀態確認
{
    class DBmsql : Singleton<DBmsql>
    {
        List<DBmsqlSub> dBmsqlSubs = new List<DBmsqlSub>();
        /// <summary>
        /// 執行sql命令
        /// </summary>
        /// <param name="CommandText"></param>
        public void ExecuteNonQuery(String CommandText)
        {
            getDBmsqlSub().ExecuteNonQuery(CommandText);
        }
 
        /// <summary>
        /// 插入資料，並返回插入資料的id
        /// </summary>
        /// <param name="CommandText"></param>
        /// <returns></returns>
        public int insertReturn(string CommandText)
        {
            int ret = getDBmsqlSub().insertReturn(CommandText);
            return ret;
        }
        /// <summary>
        /// 執行並返回一個物件
        /// </summary>
        /// <param name="CommandText"></param>
        /// <returns></returns>
        public object ExecuteScalar(string CommandText)
        {
            object o = getDBmsqlSub().ExecuteScalar(CommandText);
            return o;
        }
        /// <summary>
        /// 獲取資料處理物件
        /// </summary>
        /// <returns></returns>
        private DBmsqlSub getDBmsqlSub()
        {
            DBmsqlSub ret = null;
 
            lock (dBmsqlSubs)
            {
                //避免兩個同時取到允許的狀態
                foreach (DBmsqlSub dBmsqlSub in dBmsqlSubs)
                {
                    if (!dBmsqlSub.IsUrse())
                    {
                        ret = dBmsqlSub;
                        dBmsqlSub.setIsUser(true);
                        Console.WriteLine("get:" + ret.id);
                        break;
                    }
                }
                //避免兩個同時建立物件，產生結果列表的錯誤
                if (ret == null&& dBmsqlSubs.Count<90)
                {
                    DBmsqlSub dBmsqlSub = new DBmsqlSub();
                    dBmsqlSubs.Add(dBmsqlSub);
                    dBmsqlSub.setIsUser(true);
                    ret = dBmsqlSub;
                    Console.WriteLine("get:" + ret.id);
                }
            }
            return ret;
        }
    }
}

2.3.3

using MySqlConnector;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace 資料庫連結狀態確認
{
    public class Constand {
        public static string mesConnStr = "server=localhost;port=3306;database=db1;user id=root;password=123456;Charset=utf8;";
    }
    class DBmsqlSub
    {
        static int index = 0;
        public int id = 0;
        private bool isUser = false;
        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
        MySqlConnection mConn;
        MySqlCommand mCmd;
        public void setIsUser(bool value) {
            lock (this) {
                Console.WriteLine("index:" + index + " isuser:" + isUser+" setuser:"+ value);
                isUser = value;
            }
        }
 
        public MySqlDataReader MySqlDataReader { get; private set; }
 
        public DBmsqlSub()
        {
            id = index++;
            try
            {
                mConn = new MySqlConnection(Constand.mesConnStr);
                mConn.Open();
                mCmd = new MySqlCommand();
                mCmd.Connection = mConn;
            }
            catch (Exception e)
            {
                logger.Error(e.ToString());
            }
        }
        ~DBmsqlSub()
        {
            mConn.Close();
        }
        public void Close()
        {
            mConn.Close();
        }
        public bool isOpen()
        {
            if (mConn.State == ConnectionState.Closed)
            {
                mConn.Open();
            }
            if (mConn.State == ConnectionState.Open)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public MySqlCommand getCmd()
        {
            return mCmd;
        }
        /// <summary>
        /// 如果沒有連結，就直接連結
        /// </summary>
        private void conn()
        {
            if (mConn.State != ConnectionState.Open)
            {
                mConn.Open();
            }
        }
 
        /// <summary>
        /// 執行sql命令
        /// </summary>
        /// <param name="CommandText"></param>
        public void ExecuteNonQuery(String CommandText)
        {
            //setIsUser(true);
            mCmd.CommandText = CommandText;
            try
            {
                Console.WriteLine("id"+id);
                mCmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                logger.Error(ex.ToString());
            }
            finally {
                setIsUser(false);
            }
        }
 
        /// <summary>
        /// 插入資料，並返回插入資料的id
        /// </summary>
        /// <param name="CommandText"></param>
        /// <returns></returns>
        public int insertReturn(string CommandText)
        {
            setIsUser(true);
            int ret = 0;
            MySqlTransaction sqlTransaction = mConn.BeginTransaction();
            try
            {
                mCmd.CommandText = CommandText;
                object o = mCmd.ExecuteScalar();
                sqlTransaction.Commit();
                ret = int.Parse(o.ToString());
            }
            catch (Exception e)
            {
                logger.Error(e.ToString());
                sqlTransaction.Rollback();
            }
            finally
            {
                setIsUser(false);
            }
            return ret;
        }
        /// <summary>
        /// 執行並返回一個物件
        /// </summary>
        /// <param name="CommandText"></param>
        /// <returns></returns>
        public object ExecuteScalar(string CommandText)
        {
            setIsUser(true);
            object o = null;
            mCmd.CommandText = CommandText;
            try
            {
                o = mCmd.ExecuteScalar();
            }
            catch (Exception ex)
            {
                logger.Error(ex.ToString());
            }
            finally
            {
                setIsUser(false);
            }
            return o;
        }
        public MySqlDataReader ExecuteReader(string CommandText)
        {
            setIsUser(true);
            MySqlDataReader mySqlDataReader = null;
            mCmd.CommandText = CommandText;
            try
            {
                mySqlDataReader  = mCmd.ExecuteReader();
                //mConn.Close();
            }
            catch (Exception ex)
            {
                logger.Error(ex.ToString());
            }
            finally
            {
                setIsUser(false);
            }
            return mySqlDataReader;
        }
        public ConnectionState getState() {
            return mConn.State;
        }
        public bool IsUrse() {
            return isUser;
        }
    }
}

2.3.4

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace 資料庫連結狀態確認
{
    /// <summary>
    /// 單件構象基礎類別
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Singleton<T> where T : new()
    {
        static T t = default(T);
        public static T getMy()
        {
            if (t == null)
            {
                t = new T();
            }
            return t;
        }
    }
}

執行結果：可用看出是幾個連結物件在被迴圈的使用，也基本達到了直接的初衷，用盡可能少的連結，完成多執行緒的呼叫情景。

id2
index:5 isuser:True setuser:False
index:5 isuser:False setuser:True
index:5 isuser:True setuser:False
get:3
id3
index:5 isuser:False setuser:True
get:4
id4
index:5 isuser:True setuser:False
index:5 isuser:False setuser:True
get:2
id2
index:5 isuser:True setuser:False
index:5 isuser:False setuser:True
get:3
id3

到此這篇關於mysql 資料庫連結狀態確認實驗的文章就介紹到這了,更多相關mysql 資料庫連結狀態內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！