go读取服务器设备地址

❶ GoPro连电脑总是读取不出来是为什么

电脑读不到USB的处理方法如下：1、右击“我的电脑”，选择“属性---硬件---设备管理器”。或者通过“控制面板---系统---硬件---设备管理器”。2、点击“设备管理器”按钮进入。找到“通用串行总线程控制器”。3、将“通用串行总线程控制器”下的项目选中后，选择上面的卸载按钮，或者直接右击鼠标选择“卸载”。4、卸载后，点击其中的任何一个选项，选择上面的“扫描检测硬件改动”按钮，系统将自动安装卸载的驱动。5、插上不能使用的硬件，系统将自动检测安装驱动。一般这时，硬件就可以使用了。

❷ Pe 启动,进入命令行选项,执行go是什么意思

Windows PreInstallation Environment（Windows PE）直接从字面上翻译就是“Windows预安装环境”，微软在2002年7月22日发布，它的原文解释是：“Windows预安装环境（Windows PE）是带有限服务的最小Win32子系统，基于以保护模式运行的Windows XP Professional内核。它包括运行Windows安装程序及脚本、连接网络共享、自动化基本过程以及执行硬件验证所需的最小功能。”换句话说，你可把Windows PE看作是一个只拥有最少核心服务的Mini操作系统。微软推出这么一个操作系统当然是因为它拥有与众不同的系统功能，如果要用一句话来解释，我认为与Win9X/2000/XP相比，Windows PE的主要不同点就是：它可以自定义制作自身的可启动副本，在保证你需要的核心服务的同时保持最小的操作系统体积，同时它又是标准的32位视窗API的系统平台。当然，现在这么说也许难以理解，没有关系，下面让我们来仔细研究它。

Windows PE概览

即使有刚才的解释，你一定还是对这个全新概念的Mini操作系统一头雾水，没关系，在这里我将演示一下其运行的全过程，相信看过之后你或许就会有大致的了解。大多数人获得的Windows PE光盘（包括我手上这张ISO镜像光盘）应该是一张“Windows XP OPK”CD，意思就是Windows XP OEM预安装工具包CD。实际上，Windows XP OPK CD是Windows PE 32位版本的一个可引导副本，也就是说，这张CD已经是个用Windows PE定义制作的操作系统了，我们可直接用它来引导系统。先看看这张CD的目录结构吧，总共有352MB，是不是有些大呢？其实由于这是个副本（至少包含了不少驱动程序），大小是由当时自定义制作决定的，若是Windows PE的32位非自定义版本，其在磁盘上的镜像大约为120MB。

1.引导Windows PE

笔者考虑到网络环境等问题，主要的使用环境是VMware虚拟机和Virtual PC虚拟机，不过这两种虚拟机环境与实际PC环境几乎没有区别（就是说如果你不清楚虚拟机也没关系，就当是在真实PC上直接运行）。

将BIOS中设置成光驱引导，并开始启动系统，当屏幕画面上出现“Press any key boot from cd”时，按任意键从光驱上的Windows PE引导启动。如果你的存储设备驱动不被支持，在启动时按下F6键可加载特殊设备的驱动。当启动到桌面时系统会做一些如调整分辨率的工作，最后打开默认的CMD命令行解释工具，大家看看，是货真价实的图形操作环境哦。

可以看到桌面上空空如也，不要指望可以拿鼠标点来点去，毕竟是个什么应用程序都没有安装；另外尽管光盘上带有的可执行的命令行工具有限，但明显可以自己添加，看看这是什么？没错，是我们最熟悉的扫雷游戏（现在知道题头所指了吧，呵呵），拿鼠标先玩玩吧，这是笔者从大家熟悉的WinXP操作系统中加入的（方法很简单，用ISO工具直接拷入刚才的镜像文件就可以了）。

那么还是先回到CMD命令行工具中吧。默认的目录是\I386\system32\，输入命令行“dir *.exe /w”可查看有哪些可运行的程序。下面我们实际研究一下对个人用户有实际意义的Windows PE特性的操作。

在光盘镜像中可同时看到32位和64位操作系统的工具，对于个人用户来讲，你可用它直接引导没有安装任何系统的机器，并在其上实现32位系统的许多功能，这在后面会一一道来。

2.Windows PE对网络的支持

刚才dir时我们看到了ping命令，熟悉这个命令的读者应该都知道，只有安装了TCP/IP协议才能使用，那么不管三七二十一，先来ping自己试试吧，在CMD中键入“ping 127.0.0.1”，回车搞定，显然是可ping通的，这证明TCP/IP协议确实已在运行。再试一试光盘上另一个命令IPConfig，键入运行，看到IP地址已经自动分配好了。既然网络确实已经连接，那让我们来实际操作使用吧（这里可能有不少从视窗系统开始接触计算机的朋友会对操作不知所措，其实并没有想象中那么困难，你可以在CMD中使用命令工具带“/？”参数来查询具体使用方法，如果你机器上本来就装有XP，那么在帮助中心查询就更方便了，多实验一下，掌握命令行以后你会发现方便很多）。

现在我的物理机和虚拟机构成了一个虚拟网络，使用光盘镜像中的net命令，在虚拟机中键入“net view”查看已连接的服务器，这里显示的服务器“XQ-B6QAS26953 EC”，名字表示虚拟机已通过网络连接了我的物理机器。我的物理机器上有一个名为TUKU的文件夹已经共享，所以再键入“net use e:\XQ-B6QAS26953EC\TUKU”，意思是将物理机器上的共享目录TUKU镜像为虚拟机器上的E盘，成功后可在虚拟机里自由地访问共享目录，这时就可通过这个来做远程安装等工作。net命令还有不少参数，自己可以查阅并多加尝试，才可以发挥Windows PE强大的网络环境功能，如果只是简单地访问服务器，上面的两个命令参数基本足够了。不过这里要记住用Windows PE的机器可访问其他操作系统的机器，而逆操作是不能的，这是由于Windows PE本身的限制，我们后面再讲这个问题。事实说明，Windows PE启动后就可以使用网络环境。

3.利用Windows PE创建、删除、格式化和管理NTFS文件系统分区

对于个人用户来说这个功能很是实用和方便。但不少朋友在dir完以后就叫苦，怎么只有format.com，没有fdisk啊，根本没办法分区嘛。其实这是个误解，Windows XP中针对磁盘管理工作有专用的命令行工具DiskPart.exe，它是一种文本模式命令解释程序，能让你通过使用脚本或从命令提示符直接输入来管理对象（磁盘、分区或卷），Windows PE使用的当然也是DiskPart。

在CMD模式下键入“diskpart”并回车进入DiskPart命令行解释。键入“list disk”，显示有两块硬盘，分别为磁盘0和磁盘1。键入“select disk=0”执行，意思是选择指定磁盘，并将焦点转移到此磁盘，接下来的操作就都是针对它的（后面的操作都是一样，在磁盘、分区或卷上使用DiskPart命令前，必须首先将对象列表，然后选择要给予焦点的对象，只有对象拥有焦点时，键入的任何DiskPart命令才对该对象进行操作）。键入“detail disk”可以查看磁盘0的细节信息，现在磁盘0整个是一个活动分区C，格式为FAT32，容量为16G。下面我们以实际操作将磁盘0分为两个区，分别为NTFS格式的8G主分区C和FAT32格式8G逻辑分区D，而将磁盘1整个转为FAT32格式的分区E来演示Windows PE对磁盘的管理操作：

（1）执行“select disk=0”，将焦点转到磁盘0。执行“select partition 1”，将焦点转到磁盘0的分区活动C上面。

（2）执行“delete partition”将原来的分区C删除。

（3）执行“create partition primary size=8000”回车，在磁盘0上建立一个新的8000MB的主分区，焦点会自动转到新建立的分区上。

（4）接着执行“create partition extended”回车，将磁盘0上剩余的磁盘空间建立为扩展分区。

（5）完成上一步后再执行“create partition logic”回车，将刚建立的扩展分区创建为一个逻辑分区。

（6）至此，我们就已经把原来一个活动分区C的磁盘0创建为有一个主分区和一个逻辑分区了，不过这两个分区还没有驱动器号，执行“select partition 1”将焦点转到主分区1，然后执行“assign letter=C”，将驱动器号C：分配给主分区。执行“active”回车将主分区设为活动使其可以引导系统。

（7）接下来执行“select partition 3”将焦点转到逻辑分区，执行“assign”回车，意思是系统将下一个可用的驱动器号分配给逻辑分区，由于驱动器号D、E均被占用（D为磁盘1分区占用，E为光驱占用），所以系统将F分配给了逻辑分区。不过没关系，我们先不管驱动器号的顺序，到这里我们对磁盘0的操作就结束了，剩下的目标是将磁盘1的活动分区D转换为分区E。

（8）执行“select disk 1”将焦点转到磁盘1，执行“select partition 1”将焦点转到活动分区D。

（9）由于磁盘1的D分区是活动的主分区，所以设其驱动器号为E，显然是要将它重新建立为一个非主分区的驱动器，那么它就不会占据驱动器号D而将它让给磁盘0的逻辑分区了。执行“delete partition”删除原来分区D，执行“create partition extended”将磁盘1上所有的磁盘空间建立为扩展分区。

（10）完成上步后再执行“create partition logic”将刚建立的扩展分区创建为一个逻辑分区。

（11）最后执行“assign”自动分配驱动器号，系统仍然把D分配给了它（不过在机器重新启动后系统会自动调整将D分配给磁盘0的逻辑分区，磁盘1的逻辑分区会使用驱动器E，而光驱就顺延到F了，重启一次系统这些改变都会自动实现）。

（12）现在我们对机器上硬盘的重新分区工作就结束了，执行“exit”退出DiskPart命令行解释工具，然后执行“format c: /fs:ntfs”，将刚才建立的DISK 0主分区格式化为NTFS文件格式的分区，同理执行“format d: /fs:fat32”、“format f: /fs:fat32”将分区D、F格式化，我们最终的操作就完成了。

（13）完成后执行“exit”重新启动机器，可以再次进入“DiskPart”来查看分区情况是否正确。

上面的操作基本包括了对磁盘的创建、删除、格式化和管理，如果你再仔细读读帮助说明，保证你在掌握它强大的功能以后不再想使用Fdisk去管理磁盘。实际上你如果在使用Windows XP，这些知识都非常实用。此外“DiskPart”工具最方便的地方是支持脚本，在这里就不详细说明了。

上面我们已经将Windows PE特性的基本操作都实践了一下，应该可以体会到Windows PE对个人的方便之处，但是就像上文所说的那样，Windows PE只是有限功能的Mini操作系统，要正确使用Windows PE，当然也要了解它的一些限制。

1.为了防止将它用作盗版操作系统，在连续使用24小时后Windows PE将自动退出并重启。

2.你可从Windows PE计算机通过网络直接访问服务器和共享。但不能从网络上的另一个位置访问Windows PE计算机上的任何文件或文件夹。Windows PE通过TCP/IP及其上的NetBIOS获得到达文件服务器的网络连接，不支持其他方法（如IPX/SPX网络协议）。

3.因为涉及反盗版，所以只能从Windows XP Professional CD建立Windows PE的自定义版本。而不能从Windows XP Home Edition或Windows 2002 Server操作系统家族的任何成员建立。

4.Windows PE太大，不能放在软盘上。Windows PE仅包括可用Win32 API的子集（包括I/O（磁盘和网络）和核心Win32 API）。如果Win32下运行的服务基于Win32 API子集，则它在Windows PE是否可用需具体分析。这里不详细列出Windows PE不支持的API了，反正rundll32.exe和shell.dll等是不被支持的，想要在Windows PE下面玩Quake的朋友还是趁早放弃。

Windows PE的作用

不少朋友看到这儿无论是否有收获，肯定都会想Windows PE到底对自己有什么明确的作用，这里不妨总结一二。

1.方便易用的启动工具盘

通过刚才的叙述，大家可以看出，Windows PE启动相当快捷，而且对启动环境要求不高；最可贵的是，虽然名为启动盘，其功能却几乎相当于安装了一个Windows XP的“命令行版本”——别忘了网络支持哦。因此，对于个人计算机用户，只要将其刻录在一张光盘上，便可放心地去解决初始化系统之类的问题；而对小型网络环境（如网吧等）用户来说，这一功能尤其实用。

2.有趣的硬盘使用功能

自定义的Windows PE不仅可放到那些可移动存储设备如CD上，还可以放在硬盘上使用。因为许多朋友会认为将Windows PE的自定义版本放在硬盘上没有什么意义，其实不然。把Windows PE放在硬盘上应该是最为有趣的地方，且不说你的操作系统损坏无法进入的情况下启动硬盘上的Windows PE可以方便地修复，关键是由于Windows PE在硬盘上，所以在Windows PE环境下安装应用程序就有了可能。呵呵，撇开题外话不讲，这里看一下如何把自定义的Windows PE放到硬盘上吧（只能在硬盘上放置Windows PE的32位版本）。

首先要安装恢复控制台：

（1）将Windows XP Professional CD放在CD-ROM驱动器中，这里指定其为cd_drive。

（2）在命令行CMD窗口中运行cd_drive\i386\winnt32.exe /cmdcons。

然后将Windows PE自定义可引导副本放置在硬盘上，如下操作：

（1）在目标硬盘上，创建“C:\Minint”的目录（这里必须将目录命名为“Minint”）。

（2）将Windows PE“根目录\i386”下的所有内容复制到C:\Minint。

（3）从Windows PE根目录下将Winbom.ini复制到目标硬盘的根目录。

（4）在目标硬盘上，将“C:\Cmdcons\txtsetup.sif”的只读属性改为读/写。

（5）在目标硬盘上，将“C:\Minint\txtsetup.sif”复制到“C:\Cmdcons”进行覆盖。

（6）重新启动目标计算机。在“引导”菜单上，选择引导到“命令控制台”，计算机将使用Windows PE引导。

3.Windows XP OPK CD的本职工作

上面说了其实我们拿到的是Windows PE的一个可执行副本，即Windows XP OPK（Windows XP OEM预安装工具包）CD。从名字都知道它原来的本职工作是为了方便OEM工作的。如果你在Windows操作系统环境下打开光盘，它就会自动运行Autorun为你的系统安装一个“Windows安装管理器”的工具包。利用它，你可以轻易制造出带有计算机厂商OEM标志的Windows安装镜像。虽然这是Windows XP OPK CD的主要本职工作，但显然对我们个人没什么意义，当然，如果你想把手上的Windows安装CD都打上自己独有的印记，并在朋友的机器上安装时炫一下，那么使用它是个好主意。当然自己的“印记”绝非OEM标志那么简单，实际上你还可任意设定Windows PE携带的软件，并可设置这些软件在Windows PE启动时运行；理想的情形下你甚至可以为自定义的Windows PE版本加上类似于Windows Explorer的图形外壳程序

❸ pokemong go为什么无法从服务器获取游戏数据

1.下载pokemongo以及google框架 不再赘述。

2.下载神行者(虚拟定位)和云墙(VPN)和360超级root(ROOT)

3.360超级root(或者其他root获取系统root权限)

4.(关键步骤!!!)

android不能开启系统设置中的“允许模拟地点”，否则游戏中会出现fail to detect location

《搜索微信虚拟定位教程》 按照左边链接教程设置神行者的高级模式

设置好后查看360超级root中——root管理中是否有神行者(没有就添加上，在没有就重启试试)

5.打开云墙VPN加速，打开神行者定位

6.打开游戏试试吧~~~~

❹ golang 读取服务器时间 延迟问题怎么解决

简单减少slave同步延案架构做优化尽量让主库DDL快速执行主库写数据安全性较高比sync_binlog=1innodb_flush_log_at_trx_commit = 1 类设置slave则需要高数据安全完全讲sync_binlog设置0或者关闭binloginnodb_flushlog设置0提高sql执行效率另外使用比主库更硬件设备作slave
mysql-5.6.3已经支持线程主复制原理丁奇类似丁奇表做线程Oracle使用数据库(schema)单位做线程同库使用同复制线程
sync_binlog=1
This makes MySQL synchronize the binary log’s contents to disk each time it commits a transaction
默认情况并每写入都binlog与硬盘同步操作系统或机器(仅仅MySQL服务器)崩溃能binlog语句丢 失要想防止种情况使用sync_binlog全局变量(1安全值慢)使binlog每Nbinlog写入与硬盘 同步即使sync_binlog设置1,现崩溃能表内容binlog内容间存致性使用InnoDB表MySQL服务器 处理COMMIT语句整事务写入binlog并事务提交InnoDB两操作间现崩溃重启事务InnoDB滚仍 存binlog用--innodb-safe-binlog选项增加InnoDB表内容binlog间致性(注释：MySQL 5.1需要--innodb-safe-binlog；由于引入XA事务支持该选项作废）该选项提供更程度安全使每事务 binlog(sync_binlog =1)(默认情况真)InnoDB志与硬盘同步该选项效崩溃重启滚事务MySQL服务器binlog剪切滚 InnoDB事务确保binlog反馈InnoDB表确切数据等并使服务器保持与主服务器保持同步(接收 滚语句)
innodb_flush_log_at_trx_commit （管用）
抱怨Innodb比MyISAM慢 100倍概忘调整值默认值1意思每事务提交或事务外指令都需要志写入（flush）硬盘费特别使用电 池供电缓存（Battery backed up cache）设2于运用特别MyISAM表转意思写入硬盘写入系统缓存志仍每秒flush硬 盘所般丢失超1-2秒更新设0更快点安全面比较差即使MySQL挂能丢失事务数据值2整操作系统 挂才能丢数据

❺ Pokemon go怎么在电脑上玩 用电脑怎么玩Pokemon go

Pokémon Go的火爆程度自不用多说，国外网友Travis D总结了在Win10 PC上玩这款游戏的办法。
教程：如何在电脑上玩《Pokémon Go》
没错，你只需要一台Windows 10电脑，台式机当然也行，这里并不需要你抱着主机或者拿着笔记本走来走去，看看如何骗过任天堂服务器。
首先，准备如下软件——
1，Bluestacks（安卓模拟器）
2，Kingroot
3，Lucky Patcher
4，Fake GPS 4.6
5，Pokemon GO 1~3点击转到官网地址自行下载，4~5推荐国内酷安网下载。
破解步骤如下——
1，安装Bluestacks(蓝叠)，重启电脑后禁用摄像头，方法是，进入注册表编辑器，定位到HKEY_LOCAL_MACHINE\SOFTWARE\BlueStacks\Guests\Android\Config，点击camera，修改键值1为0，保存退出。
2，使用Bluestacks安装Kingroot。
3，运行Kingroot，滑到底部，点击“Try it”，等待进度读到100%即root成功后，重启安卓。
4，使用Bluestacks安装Lucky Patcher。
5，运行Lucky Patcher，点击Grant——Rebuild/Install——SD，然后找到你下载的Fake GPS 4.6.apk，进行安装（即将其安装为系统应用）。
6，Fake GPS安装成功后弹出重启请求，点击否。
7，关闭所有标签，只保留Bluestacks安卓欢迎页面。
8，手动重启安卓设备。
9，使用Bluestacks安装Pokemon GO。
10，运行Lucky Patcher，点击搜索，点击右上角的过滤，展示系统应用。
11，点击Fake GPS并运行，确保是EXPERT mode（专业模式）。
12，在地图上找到一个你想开始的地方，然后点击右侧的Play按钮。
13，好了，现在地图应该自动关闭了，接下来就打开Pokemon GO，然后登陆谷歌账户，如果提示要读取位置，一定记得点击No。
注意事项—— 1，确保Win10的位置服务关闭，在设置——隐私里；确保bluestacks中GPS启用高精度，关闭谷歌位置服务。
不懂的可以加官方微博: Chinaar平台

❻ 如何使用Go建开发高负载WebSocket服务器

Mail.Ru有很多有状态的系统。 用户电子邮件存储是其中之一。 跟踪系统中的状态变化和系统事件有几种方法。 这主要是通过定期系统轮询或关于其状态变化的系统通知。

两种方式都有利弊。 但是当涉及邮件时，用户收到新邮件的速度越快越好。

邮件轮询涉及每秒大约50,000个HTTP查询，其中60％返回304状态，这意味着邮箱没有变化。

因此，为了减少服务器上的负载并加快邮件传递给用户，决定通过编写发布-订阅服务器，一方面将接收有关状态更改的通知，另一方面则会收到这种通知的订阅。

先前

第一个方案显示了以前的样子。 浏览器定期轮询API，并查询有关Storage（邮箱服务）的更改。

第二个方案描述了新架构。 浏览器与通知API建立WebSocket连接，通知API是Bus服务器的客户端。收到新的电子邮件后，Storage会向Bus（1）发送一条通知，由Bus发送到订阅者。 API确定连接以发送接收到的通知，并将其发送到用户的浏览器（3）。

所以今天我们将讨论API或WebSocket服务器。 我们的服务器将有大约300万个在线连接。

实现方式

让我们看看如何使用Go函数实现服务器的某些部分，而无需任何优化。

在进行net/http ，我们来谈谈我们如何发送和接收数据。 站在WebSocket协议（例如JSON对象） 之上的数据在下文中将被称为分组 。

我们开始实现包含通过WebSocket连接发送和接收这些数据包的Channel结构。

channel 结构

// Packet represents application level data.
type Packet struct {
...
}

// Channel wraps user connection.
type Channel struct {
conn net.Conn // WebSocket connection.
send chan Packet // Outgoing packets queue.
}

func NewChannel(conn net.Conn) *Channel {
c := &Channel{
conn: conn,
send: make(chan Packet, N),
}

go c.reader()
go c.writer()

return c
}

注意这里有reader和writer连个goroutines。 每个goroutine都需要自己的内存栈， 根据操作系统和Go版本可能具有2到8 KB的初始大小。

在300万个在线连接的时候，我们将需要24 GB的内存 （堆栈为4 KB）用于维持所有连接。 这还没有计算为Channel结构分配的内存，传出的数据包ch.send和其他内部字段消耗的内存。

I/O goroutines

我们来看看“reader”的实现：

func (c *Channel) reader() {
// We make a buffered read to rece read syscalls.
buf := bufio.NewReader(c.conn)

for {
pkt, _ := readPacket(buf)
c.handle(pkt)
}
}

这里我们使用bufio.Reader来减少read() syscalls的数量，并读取与buf缓冲区大小一样的数量。 在无限循环中，我们期待新数据的到来。 请记住： 预计新数据将会来临。 我们稍后会回来。

我们将离开传入数据包的解析和处理，因为对我们将要讨论的优化不重要。 但是， buf现在值得我们注意：默认情况下，它是4 KB，这意味着我们需要另外12 GB内存。 “writer”有类似的情况：

func (c *Channel) writer() {
// We make buffered write to rece write syscalls.
buf := bufio.NewWriter(c.conn)

for pkt := range c.send {
_ := writePacket(buf, pkt)
buf.Flush()
}
}

我们遍历c.send ，并将它们写入缓冲区。细心读者已经猜到的，我们的300万个连接还将消耗12 GB的内存。

HTTP

我们已经有一个简单的Channel实现，现在我们需要一个WebSocket连接才能使用。

注意：如果您不知道WebSocket如何工作。客户端通过称为升级的特殊HTTP机制切换到WebSocket协议。 在成功处理升级请求后，服务器和客户端使用TCP连接来交换二进制WebSocket帧。 这是连接中的框架结构的描述。

import (
"net/http"
"some/websocket"
)

http.HandleFunc("/v1/ws", func(w http.ResponseWriter, r *http.Request) {
conn, _ := websocket.Upgrade(r, w)
ch := NewChannel(conn)
//...
})

请注意， http.ResponseWriter为bufio.Reader和bufio.Writer （使用4 KB缓冲区）进行内存分配，用于*http.Request初始化和进一步的响应写入。

无论使用什么WebSocket库，在成功响应升级请求后， 服务器在responseWriter.Hijack()调用之后，连同TCP连接一起接收 I/O缓冲区。

提示：在某些情况下， go:linkname 可用于 通过调用 net/http.putBufio{Reader,Writer} 将缓冲区返回到 net/http 内 的 sync.Pool 。

因此，我们需要另外24 GB的内存来维持300万个链接。

所以，我们的程序即使什么都没做，也需要72G内存。

优化

我们来回顾介绍部分中谈到的内容，并记住用户连接的行为。 切换到WebSocket之后，客户端发送一个包含相关事件的数据包，换句话说就是订阅事件。 然后（不考虑诸如ping/pong等技术信息），客户端可能在整个连接寿命中不发送任何其他信息。

连接寿命可能是几秒到几天。

所以在最多的时候，我们的Channel.reader()和Channel.writer()正在等待接收或发送数据的处理。 每个都有4 KB的I/O缓冲区。

现在很明显，某些事情可以做得更好，不是吗？

Netpoll

你还记得bufio.Reader.Read()内部，Channel.reader()实现了在没有新数据的时候conn.read()会被锁。如果连接中有数据，Go运行时“唤醒”我们的goroutine并允许它读取下一个数据包。 之后，goroutine再次锁定，期待新的数据。 让我们看看Go运行时如何理解goroutine必须被“唤醒”。 如果我们看看conn.Read（）实现 ，我们将在其中看到net.netFD.Read（）调用 ：

// net/fd_unix.go

func (fd *netFD) Read(p []byte) (n int, err error) {
//...
for {
n, err = syscall.Read(fd.sysfd, p)
if err != nil {
n = 0
if err == syscall.EAGAIN {
if err = fd.pd.waitRead(); err == nil {
continue
}
}
}
//...
break
}
//...
}

Go在非阻塞模式下使用套接字。 EAGAIN表示，套接字中没有数据，并且在从空套接字读取时不会被锁定，操作系统将控制权返还给我们。

我们从连接文件描述符中看到一个read()系统调用。 如果读取返回EAGAIN错误 ，则运行时会使pollDesc.waitRead（）调用 ：

// net/fd_poll_runtime.go

func (pd *pollDesc) waitRead() error {
return pd.wait('r')
}

func (pd *pollDesc) wait(mode int) error {
res := runtime_pollWait(pd.runtimeCtx, mode)
//...
}

如果我们深入挖掘 ，我们将看到netpoll是使用Linux中的epoll和BSD中的kqueue来实现的。 为什么不使用相同的方法来进行连接？ 我们可以分配一个读缓冲区，只有在真正有必要时才使用goroutine：当套接字中有真实可读的数据时。

在github.com/golang/go上， 导出netpoll函数有问题 。

摆脱goroutines

假设我们有Go的netpoll实现 。 现在我们可以避免使用内部缓冲区启动Channel.reader() goroutine，并在连接中订阅可读数据的事件：

ch := NewChannel(conn)

// Make conn to be observed by netpoll instance.
poller.Start(conn, netpoll.EventRead, func() {
// We spawn goroutine here to prevent poller wait loop
// to become locked ring receiving packet from ch.
go Receive(ch)
})

// Receive reads a packet from conn and handles it somehow.
func (ch *Channel) Receive() {
buf := bufio.NewReader(ch.conn)
pkt := readPacket(buf)
c.handle(pkt)
}

使用Channel.writer()更容易，因为只有当我们要发送数据包时，我们才能运行goroutine并分配缓冲区：

func (ch *Channel) Send(p Packet) {
if c.noWriterYet() {
go ch.writer()
}
ch.send <- p
}

请注意，当操作系统在 write() 系统调用时返回 EAGAIN 时，我们不处理这种情况 。 对于这种情况，我们倾向于Go运行时那样处理。 如果需要，它可以以相同的方式来处理。

从ch.send （一个或几个）读出传出的数据包后，writer将完成其操作并释放goroutine栈和发送缓冲区。

完美！ 通过摆脱两个连续运行的goroutine中的堆栈和I/O缓冲区，我们节省了48 GB 。

资源控制

大量的连接不仅涉及高内存消耗。 在开发服务器时，我们会经历重复的竞争条件和死锁，常常是所谓的自动DDoS，这种情况是当应用程序客户端肆意尝试连接到服务器，从而破坏服务器。

例如，如果由于某些原因我们突然无法处理ping/pong消息，但是空闲连接的处理程序会关闭这样的连接（假设连接断开，因此没有提供数据），客户端会不断尝试连接，而不是等待事件。

如果锁定或超载的服务器刚刚停止接受新连接，并且负载均衡器（例如，nginx）将请求都传递给下一个服务器实例，那压力将是巨大的。

此外，无论服务器负载如何，如果所有客户端突然想要以任何原因发送数据包（大概是由于错误原因），则先前节省的48 GB将再次使用，因为我们将实际恢复到初始状态goroutine和并对每个连接分配缓冲区。

Goroutine池

我们可以使用goroutine池来限制同时处理的数据包数量。 这是一个go routine池的简单实现：

package gopool

func New(size int) *Pool {
return &Pool{
work: make(chan func()),
sem: make(chan struct{}, size),
}
}

func (p *Pool) Schele(task func()) error {
select {
case p.work <- task:
case p.sem <- struct{}{}:
go p.worker(task)
}
}

func (p *Pool) worker(task func()) {
defer func() { <-p.sem }
for {
task()
task = <-p.work
}
}

现在我们的netpoll代码如下：

pool := gopool.New(128)

poller.Start(conn, netpoll.EventRead, func() {
// We will block poller wait loop when
// all pool workers are busy.
pool.Schele(func() {
Receive(ch)
})
})

所以现在我们读取数据包可以在池中使用了空闲的goroutine。

同样，我们将更改Send() ：

pool := gopool.New(128)

func (ch *Channel) Send(p Packet) {
if c.noWriterYet() {
pool.Schele(ch.writer)
}
ch.send <- p
}

而不是go ch.writer() ，我们想写一个重用的goroutine。 因此，对于N goroutines池，我们可以保证在N请求同时处理并且到达N + 1我们不会分配N + 1缓冲区进行读取。 goroutine池还允许我们限制新连接的Accept()和Upgrade() ，并避免大多数情况下被DDoS打垮。

零拷贝升级

让我们从WebSocket协议中偏离一点。 如前所述，客户端使用HTTP升级请求切换到WebSocket协议。 协议是样子：

GET /ws HTTP/1.1
Host: mail.ru
Connection: Upgrade
Sec-Websocket-Key: A3xNe7sEB9HixkmBhVrYaA==
Sec-Websocket-Version: 13
Upgrade: websocket

HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Sec-Websocket-Accept: ksu0wXWG+YmkVx+KQR2agP0cQn4=
Upgrade: websocket

也就是说，在我们的例子中，我们需要HTTP请求和header才能切换到WebSocket协议。 这个知识点和http.Request的内部实现表明我们可以做优化。我们会在处理HTTP请求时抛弃不必要的内存分配和复制，并放弃标准的net/http服务器。

例如， http.Request 包含一个具有相同名称的头文件类型的字段，它通过将数据从连接复制到值字符串而无条件填充所有请求头。 想象一下这个字段中可以保留多少额外的数据，例如大型Cookie头。

但是要做什么呢？

WebSocket实现

不幸的是，在我们的服务器优化时存在的所有库都允许我们对标准的net/http服务器进行升级。 此外，所有库都不能使用所有上述读写优化。 为使这些优化能够正常工作，我们必须使用一个相当低级别的API来处理WebSocket。 要重用缓冲区，我们需要procotol函数看起来像这样：

func ReadFrame(io.Reader) (Frame, error)
func WriteFrame(io.Writer, Frame) error

如果我们有一个这样的API的库，我们可以从连接中读取数据包，如下所示（数据包写入看起来差不多）：

// getReadBuf, putReadBuf are intended to
// reuse *bufio.Reader (with sync.Pool for example).
func getReadBuf(io.Reader) *bufio.Reader
func putReadBuf(*bufio.Reader)

// readPacket must be called when data could be read from conn.
func readPacket(conn io.Reader) error {
buf := getReadBuf()
defer putReadBuf(buf)

buf.Reset(conn)
frame, _ := ReadFrame(buf)
parsePacket(frame.Payload)
//...
}

简而言之，现在是制作我们自己库的时候了。

github.com/gobwas/ws

为了避免将协议操作逻辑强加给用户，我们编写了WS库。 所有读写方法都接受标准的io.Reader和io.Writer接口，可以使用或不使用缓冲或任何其他I/O包装器。

除了来自标准net/http升级请求之外， ws支持零拷贝升级 ，升级请求的处理和切换到WebSocket，而无需内存分配或复制。 ws.Upgrade()接受io.ReadWriter （ net.Conn实现了这个接口）。 换句话说，我们可以使用标准的net.Listen()并将接收到的连接从ln.Accept()立即传递给ws.Upgrade() 。 该库可以复制任何请求数据以供将来在应用程序中使用（例如， Cookie以验证会话）。

以下是升级请求处理的基准 ：标准net/http服务器与net.Listen()加零拷贝升级：

BenchmarkUpgradeHTTP 5156 ns/op 8576 B/op 9 allocs/op
BenchmarkUpgradeTCP 973 ns/op 0 B/op 0 allocs/op

切换到ws和零拷贝升级节省了另外24 GB内存 - 这是由net/http处理程序请求处理时为I/O缓冲区分配的空间。

概要

让我们结合代码告诉你我们做的优化。

• 读取内部缓冲区的goroutine是非常昂贵的。 解决方案 ：netpoll（epoll，kqueue）; 重用缓冲区。

• 写入内部缓冲区的goroutine是非常昂贵的。 解决方案 ：必要时启动goroutine; 重用缓冲区。

• DDOS，netpoll将无法工作。 解决方案 ：重新使用数量限制的goroutines。

• net/http不是处理升级到WebSocket的最快方法。 解决方案 ：在连接上使用零拷贝升级。

这就是服务器代码的样子：

• import (


• "net"


• "github.com/gobwas/ws"


• )



• ln, _ := net.Listen("tcp", ":8080")



• for {


• // Try to accept incoming connection inside free pool worker.


• // If there no free workers for 1ms, do not accept anything and try later.


• // This will help us to prevent many self-ddos or out of resource limit cases.


• err := pool.ScheleTimeout(time.Millisecond, func() {


• conn := ln.Accept()


• _ = ws.Upgrade(conn)



• // Wrap WebSocket connection with our Channel struct.


• // This will help us to handle/send our app's packets.


• ch := NewChannel(conn)



• // Wait for incoming bytes from connection.


• poller.Start(conn, netpoll.EventRead, func() {


• // Do not cross the resource limits.


• pool.Schele(func() {


• // Read and handle incoming packet(s).


• ch.Recevie()


• })


• })


• })


• if err != nil {


• time.Sleep(time.Millisecond)


• }


• }



结论


过早优化是万恶之源。 Donald Knuth

当然，上述优化是有意义的，但并非所有情况都如此。 例如，如果可用资源（内存，CPU）和在线连接数之间的比例相当高（服务器很闲），则优化可能没有任何意义。 但是，您可以从哪里需要改进以及改进内容中受益匪浅。

❼ 我想脱挂机 如果查看服务器的IP地址

if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[p_getlinkinfo]') and OBJECTPROPERTY(id, N'IsProcere') = 1)
drop procere [dbo].[p_getlinkinfo]
GO

/*--获取连接SQL服务器的信息

所有连接本机的:操作的数据库名,计算机名,用户名,网卡物理地址,IP地址,程序名
--邹建 2003.11--*/

/*--调用示例
--显示所有本机的连接信息
exec p_getlinkinfo

--显示所有本机的连接信息,包含ip地址
exec p_getlinkinfo @includeip=1

--显示连接指定数据库的信息
exec p_getlinkinfo '客户资料'
--*/
create proc p_getlinkinfo
@dbname sysname=null, --要查询的数据库名,默认查询所有数据库的连接信息
@includeip bit=0 --是否显示IP地址,因为查询IP地址比较费时,所以增加此控制
as
declare @dbid int
set @dbid=db_id(@dbname)

create table #tb(id int identity(1,1),dbname sysname,hostname nchar(128),loginname nchar(128),net_address nchar(12),net_ip nvarchar(15),prog_name nchar(128))
insert into #tb(hostname,dbname,net_address,loginname,prog_name)
select distinct hostname,db_name(dbid),net_address,loginame,program_name from master..sysprocesses
where hostname<>'' and (@dbid is null or dbid=@dbid)

if @includeip=0 goto lb_show --如果不显示IP地址,就直接显示

declare @sql varchar(500),@hostname nchar(128),@id int
create table #ip(hostname nchar(128),a varchar(200))
declare tb cursor local for select distinct hostname from #tb
open tb
fetch next from tb into @hostname
while @@fetch_status=0
begin
set @sql='ping '+@hostname+' -a -n 1 -l 1'
insert #ip(a) exec master..xp_cmdshell @sql
update #ip set hostname=@hostname where hostname is null
fetch next from tb into @hostname
end

update #tb set net_ip=left(a,patindex('%:%',a)-1)
from #tb a inner join (
select hostname,a=substring(a,patindex('Ping statistics for %:%',a)+20,20) from #ip
where a like 'Ping statistics for %:%') b on a.hostname=b.hostname

lb_show:
select id,数据库名=dbname,客户机名=hostname,用户名=loginname
,网卡物理地址=net_address,IP地址=net_ip,应用程序名称=prog_name from #tb

go

❽ wifi-direct 安卓作为go go端怎么知道客户端ip

好像不可以。 DHCP协议是为了提供IP地址的协议，所以协议通信不是基于IP通信的。 而且从始至终客户端给DHCP服务器发消息都是广播发送的，也就是说，客户端一直都不知道谁是DHCP服务器。 DHCP服务器可以告诉客户端DHCP服务器自己的IP地址，但这是可选的，不是所有服务器都会在消息中携带这个信息