金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > 编程 > socket的解决方法,static的用法详解

socket的解决方法,static的用法详解

发布时间:2019-11-01 10:16编辑:编程浏览(198)

    [mysqladmin]
    socket=/storage/db/mysql/mysql.sock

      9、非静态类可以包含静态的方法、字段、属性或事件;

    public static bool QueueUserWorkItem(WaitCallback callBack):将方法排入队列以便执行。此方法在有线程池线程变得可用时执行。

    mysql,mysqldump,Mysqladmin,php连接mysql服务常会提示下面错误:

    一、静态类

    CLR线程池分为工作者线程(workerThreads)I/O线程(completionPortThreads)两种:

    ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/var/lib/mysql/mysql.sock' (2)

    图片 1

    图片 2图片 3

    3、php连接mysql服务提示"Can't connect to local MySQL server through socket..."的解决方法
      有时候mysql服务正常运行,用户名密码也完全正确,使用php的mysql_connect函数却连接不了mysql,调用php的mysql_error()函数提示“Can't connect to local MySQL server through socket '/var/lib/mysql/mysql.sock'”,这是我们需要修改/etc/php.ini文件。
    在/etc/php.ini文件中"[MySQL]"项下找到"mysql.default_socket",并设置其值指向正确的mysql服务socket文件即可,如:

      [3] 静态类的本质,是一个抽象的密封类,所以不能被继承,也不能被实例化。

    Program

    [mysqldump]
    socket=/storage/db/mysql/mysql.sock

      [4] C#编译器会自动把它标记为sealed。这个关键字将类指定为不可扩展;换言之,不能从它派生出其他类。

    Program

    • 将连接参数“host”的值由“localhost”改成“127.0.0.1”;
    • 按下面方法,在“/etc/mysql.cnf”中指定“sock文件”位置。

      3、类加载的时候,所有的静态成员就会被创建在“静态存储区”里面,一旦创建直到程序退出,才会被回收。

    Program

    [mysqld]
    datadir=/storage/db/mysql
    socket=/storage/db/mysql/mysql.sock

      静态类与非静态类的重要区别在于静态类不能实例化,也就是说,不能使用 new 关键字创建静态类类型的变量。在声明一个类时使用static关键字,具有两个方面的意义:首先,它防止程序员写代码来实例化该静态类;其次,它防止在类的内部声明任何实例字段或方法。

    线程池同步操作

    [mysql]
    socket=/storage/db/mysql/mysql.sock

      [2] 使用私有构造器的类中,是允许有实例成员的,编译器不允许静态类有任何实例成员。

    2、不必管理和维护生存周期短暂的线程,不用在创建时为其分配资源,在其执行完任务之后释放资源。

    4、python连接mysql提示"Can't connect to local MySQL server through socket..."的解决方法:
      在连接mysql数据库函数中指定socket文件,如下:

      2、静态成员只被创建一次,所以静态成员只有一份,实例成员有多少个对象,就有多少份。

     

    1、查看mysql服务的socket文件位置:
      mysql socket文件的位置是在/etc/my.cnf中设置的,cat /etc/my.cnf内容如下:

      1、静态类可以有静态构造函数,静态构造函数不可继承;
      2、静态构造函数可以用于静态类,也可用于非静态类;
      3、静态构造函数无访问修饰符、无参数,只有一个 static 标志;
      4、静态构造函数不可被直接调用,当创建类实例或引用任何静态成员之前,静态构造函数被自动执行,并且只执行一次。

    Program

     

      7、可以创建这个类的对象,制定对象的成员在静态方法中操作。

    using System;
    using System.Diagnostics;
    using System.Threading;
    
    namespace ConsoleApp1
    {
        class Program
        {
            static void Main(string[] args)
            {
                const int numberOfOperations = 300;
                var sw = new Stopwatch();
                sw.Start();
                UseThreads(numberOfOperations);
                sw.Stop();
                Console.WriteLine("Execution time using threads: {0}", sw.ElapsedMilliseconds);
    
                sw.Reset();
                sw.Start();
                UseThreadPool(numberOfOperations);
                sw.Stop();
                Console.WriteLine("Execution time using threadPool: {0}", sw.ElapsedMilliseconds);
            }
    
            static void UseThreads(int numberOfOperations)
            {
                using (var countdown = new CountdownEvent(numberOfOperations))
                {
                    Console.WriteLine("Scheduling work by creating threads");
                    for (int i = 0; i < numberOfOperations; i++)
                    {
                        var thread = new Thread(() => {
                            Console.Write("{0},", Thread.CurrentThread.ManagedThreadId);
                            Thread.Sleep(TimeSpan.FromSeconds(0.1));
                            countdown.Signal();
                        });
                        thread.Start();
                    }
                    countdown.Wait();
                    Console.WriteLine();
                }
            }
    
            static void UseThreadPool(int numberOfOperations)
            {
                using (var countdown = new CountdownEvent(numberOfOperations))
                {
                    Console.WriteLine("Starting work on a threadpool");
                    for (int i = 0; i < numberOfOperations; i++)
                    {
                        ThreadPool.QueueUserWorkItem(_ => {
                            Console.Write("{0},", Thread.CurrentThread.ManagedThreadId);
                            Thread.Sleep(TimeSpan.FromSeconds(0.1));
                            countdown.Signal();
                        });
                    }
                    countdown.Wait();
                    Console.WriteLine();
                }
            }
        }
    }
    
    1. php pdo连接mysql提示"Can't connect to local MySQL server through socket..."的解决方法:
        同样在连接字符串添加mysql socket文件的位置即可,如下:

      3、静态方法不可以直接访问实例成员,可以在实例函数调用的情况下,实例成员做为参数传给静态方法;

    图片 4图片 5

    2、修改my.cnf文件:
    在/etc/my.cnf文件中添加如下内容,并重启mysqls服务,即可解决mysql,mysqldump,mysqladmin的“Can't connect to local MySQL server through socket '/var/lib/mysql/mysql.sock'”问题:

      1、静态方法是不属于特定对象的方法;

    using System;
    using System.Threading;
    
    namespace ConsoleApp1
    {
    
        class Program
        {
            static void Main(string[] args)
            {
                ThreadPool.SetMaxThreads(1000, 1000);
                Console.WriteLine("Main thread run");
                PrintMessage("Start");
                Run();
                Console.ReadKey();
            }
    
            private static void Run()
            {
                CancellationTokenSource cts = new CancellationTokenSource();
    
                // 这里用Lambda表达式的方式和使用委托的效果一样的,只是用了Lambda后可以少定义一个方法。
                // 这在这里就是让大家明白怎么lambda表达式如何由委托转变的
                ////ThreadPool.QueueUserWorkItem(o => Count(cts.Token, 1000));
                ThreadPool.QueueUserWorkItem(callback, cts.Token);
    
                Console.WriteLine("Press Enter key to cancel the operationn");
                Console.ReadLine();
    
                // 传达取消请求            
                cts.Cancel();
                Console.ReadLine();
            }
    
            private static void callback(object state)
            {
                Thread.Sleep(1000);
                PrintMessage("Asynchoronous Method Start");
                CancellationToken token = (CancellationToken)state;
                Count(token, 1000);
            }
    
            // 执行的操作,当受到取消请求时停止数数
            private static void Count(CancellationToken token, int countto)
            {
                for (int i = 0; i < countto; i++)
                {
                    if (token.IsCancellationRequested)
                    {
                        Console.WriteLine("Count is canceled");
                        break;
                    }
    
                    Console.WriteLine(i);
                    Thread.Sleep(300);
                }
    
                Console.WriteLine("Cout has done");
            }
    
            // 打印线程池信息
            private static void PrintMessage(String data)
            {
                int workthreadnumber;
                int iothreadnumber;
    
                // 获得线程池中可用的线程,把获得的可用工作者线程数量赋给workthreadnumber变量
                // 获得的可用I/O线程数量给iothreadnumber变量
                ThreadPool.GetAvailableThreads(out workthreadnumber, out iothreadnumber);
    
                Console.WriteLine("{0}n CurrentThreadId is {1}n CurrentThread is background :{2}n WorkerThreadNumber is:{3}n IOThreadNumbers is: {4}n",
                    data,
                    Thread.CurrentThread.ManagedThreadId,
                    Thread.CurrentThread.IsBackground.ToString(),
                    workthreadnumber.ToString(),
                    iothreadnumber.ToString());
            }
        }
    }
    

    [mysqld]
    datadir=/storage/db/mysql
    socket=/storage/db/mysql/mysql.sock
    user=mysql

      2、静态类与私有构造函数区别:

    ThreadPoolDemo

    #!/usr/bin/python
    from MySQLdb import connect
    conn = connect(db="pzy", user="root", host="localhost", unix_socket="/storage/db/mysql/mysql.sock")
    cur = conn.cursor()
    count=cur.execute("show databases")
    print 'there has %s dbs' % count
    conn.commit()
    conn.close()

      1、静态类的主要特性:

    using System;
    using System.Threading;
    
    namespace ConsoleApp1
    {
        class ThreadPoolDemo
        {
            static object lockobj = new object();
            static int Count = 0;
            ManualResetEvent manualEvent;
            public ThreadPoolDemo(ManualResetEvent manualEvent)
            {
                this.manualEvent = manualEvent;
            }
            public void DisplayNumber(object a)
            {
    
                lock (lockobj)
                {
                    Count++;
                    Console.WriteLine("当前运算结果:{0},Count={1},当前子线程id:{2} 的状态:{3}", a, Count, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState);
                }
                //Console.WriteLine("当前运算结果:{0}", a);
                //Console.WriteLine("当前运算结果:{0},当前子线程id:{1} 的状态:{2}", a,Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState);
                //这里是方法执行时间的模拟,如果注释该行代码,就能看出线程池的功能了
                Thread.Sleep(2000);
                //Console.WriteLine("当前运算结果:{0},Count={1},当前子线程id:{2} 的状态:{3}", a, Count, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState);
                //这里是释放共享锁,让其他线程进入
                manualEvent.Set();
    
    
            }
        }
    }
    

    [client]
    socket=/storage/db/mysql/mysql.sock

    三、静态方法

    通过CLR线程池所建立的线程总是默认为后台线程,优先级数为ThreadPriority.Normal。

    其中socket等于的路径就是socket文件的位置,我们只要修改my.cnf文件,告诉mysql,mysqldump,mysqladmin等mysql服务的socket位置在哪里就可以。

      11、静态方法和属性不能访问其包含类型中的非静态字段和事件,并且不能访问任何对象的实例成员;

    public static bool QueueUserWorkItem(WaitCallback callBack,Object state):将方法排入队列以便执行,并指定包含该方法所用数据的对象。此方法在有线程池线程变得可用时执行。

     

      [3] 使用静态类的优点在于,编译器能够执行检查以确保不致偶然地添加实例成员,编译器将保证不会创建此 类的实例。

    QueueUserWorkItem方法中使用的的WaitCallback参数表示一个delegate,它的声明如下:

    当使用host参数为“localhost”连接Mysql服务时,会优先使用“sock文件”进行连接,而不是使用“IP:端口”进行连接,而Mysql尝试使用“sock文件”进行连接时,却无法获取“sock文件”的位置。
     
    要解决此错误,有两种解决方法:

      [1] 私有构造器方式仍然可以从类的内部对类进行实例化,而静态类禁止从任何地方实例化类,其中包括从类自身内部。

    • 通过ThreadPool.QueueUserWorkItem()方法;
    • 通过委托;

     

      [5] 如果一个类下面的所有成员,都需要被共享,那么可以把这个类定义为静态类。

    public delegate void WaitCallback(Object state)

    <?php
    $dsn = "mysql:host=localhost;dbname=pzy;unix_socket=/storage/db/mysql/mysql.sock";
    $db = new PDO($dsn, 'root', '');
    $rs = $db->query("SELECT * FROM qrtest");
    while($row = $rs->fetch()){
    print_r($row);
    }
    ?>

    二、静态成员

      线程池的最大值一般默认为1000、2000。当大于此数目的请求时,将保持排队状态,直到线程池里有线程可用。

    本文由金沙国际官网发布于编程,转载请注明出处:socket的解决方法,static的用法详解

    关键词:

上一篇:线程安全类型,谷歌瓦片地图纠偏

下一篇:没有了