技术标签: Golang 笔记 golang 后端 开发语言
目录
之前在 Go语言中array、slice、map的用法和细节分析_浮尘笔记的博客-程序员宅基地 里面说过Go语言内置的map类型的用法,而且当时说过 map 不是并发写安全的,不支持同时并发读写,如果对 map 实例进行并发读写,程序运行时就会抛出异常。比如下面的例子中两个 goroutine 分别操作读和写:
//basic/go03/sync2/map1.go
package main
import (
"fmt"
"time"
)
func test1() {
m := map[int]int{
1: 11,
2: 12,
3: 13,
}
go func() {
for i := 0; i < 1000; i++ {
m[i] = i * i
}
}()
go func() {
for i := 0; i < 1000; i++ {
fmt.Println(m[i])
}
}()
time.Sleep(time.Second)
//执行后报错:fatal error: concurrent map read and map write
}
func main() {
test1()
}
在同一时间段内,让不同的 goroutine 中的代码对同一个map进行读写操作是不安全的,因为map值本身可能会因这些操作而产生混乱,相关的程序也可能会因此发生不可预知的问题。
在sync.Map出现之前,如果要实现并发安全的map可以使用读写锁(sync.Mutex或sync.RWMutex)来实现原生map的并发读写,比如下面的例子:
//basic/go03/sync2/map2.go
package main
import "sync"
type RWMap struct { // 一个读写锁保护的线程安全的map
sync.RWMutex // 读写锁保护下面的map字段
m map[int]int
}
// 新建一个RWMap
func NewRWMap(n int) *RWMap {
return &RWMap{
m: make(map[int]int, n),
}
}
func (m *RWMap) Get(k int) (int, bool) { //从map中读取一个值
m.RLock()
defer m.RUnlock()
v, existed := m.m[k] // 在锁的保护下从map中读取
return v, existed
}
func (m *RWMap) Set(k int, v int) { // 设置一个键值对
m.Lock() // 锁保护
defer m.Unlock()
m.m[k] = v
}
func (m *RWMap) Delete(k int) { //删除一个键
m.Lock() // 锁保护
defer m.Unlock()
delete(m.m, k)
}
func (m *RWMap) Len() int { // map的长度
m.RLock() // 锁保护
defer m.RUnlock()
return len(m.m)
}
func (m *RWMap) Each(f func(k, v int) bool) { // 遍历map
m.RLock() //遍历期间一直持有读锁
defer m.RUnlock()
for k, v := range m.m {
if !f(k, v) {
return
}
}
}
func test1() {
var m = NewRWMap(10)
go func() {
for {
m.Set(1, 1) //设置key
}
}()
go func() {
for {
m.Get(2) //访问这个map
}
}()
select {}
}
func main() {
test1()
}
查询和遍历属于读操作,加读锁;增加、修改、删除属于写操作,加普通的锁。
虽然使用了读写锁可以实现线程安全的 map,但是在大量并发读写的情况下,锁的竞争会非常激烈,从而导致程序可用性下降。
Go 1.9 版本中引入了支持并发写安全的 sync.Map 类型,可以用来在并发读写的场景下替换掉 map。Go语言的官方文档中描述:在以下两个场景中使用 sync.Map,会比使用 map+RWMutex 的方式性能要好得多:(1)只会增长的缓存系统中,一个 key 只写入一次而被读很多次;(2)多个 goroutine 为不相交的键集读、写和重写键值对。
sync.Map 类型提供了一些常用的键值存取操作方法,并保证了这些操作的并发安全。同时它的存、取、删等操作都可以基本保证在常数时间内O(1) 执行完毕,和原生map一样。但是毕竟sync.Map本身也用到了锁,在某些情况下会降低程序的性能。sync.Map 对键的要求是 不能使用函数类型、map类型、切片类型作为键。
sync.Map的数据结构源码:
// $GOROOT/src/sync/map.go
type Map struct {
mu Mutex
// 基本上你可以把它看成一个安全的只读的map
// 它包含的元素其实也是通过原子操作更新的,但是已删除的entry就需要加锁操作了
read atomic.Value // readOnly
// 包含需要加锁才能访问的元素
// 包括所有在read字段中但未被expunged(删除)的元素以及新加的元素
dirty map[interface{}]*entry
// 记录从read中读取miss的次数,一旦miss数和dirty长度一样了,就会把dirty提升为read,并把dirty置空
misses int
}
type readOnly struct {
m map[interface{}]*entry
amended bool // 当dirty中包含read没有的数据时为true,比如新增一条数据
}
// expunged是用来标识此项已经删掉的指针
// 当map中的一个项目被删除了,只是把它的值标记为expunged,以后才有机会真正删除此项
var expunged = unsafe.Pointer(new(interface{}))
// entry代表一个值
type entry struct {
p unsafe.Pointer // *interface{}
}
sync.Map主要包含 Store、Load、Delete 这 3 个核心方法,它们都是先从 read 字段中处理的,因为读取 read 字段的时候不用加锁。
接下来,使用sync.Map 对上面 basic/go03/sync2/map1.go 改造一下:
//basic/go03/sync2/map1.go
package main
import (
"fmt"
"sync"
"time"
)
func test2() {
var m sync.Map
go func() {
for i := 0; i < 1000; i++ {
m.Store(i, i*i)
}
}()
go func() {
for i := 0; i < 1000; i++ {
data, _ := m.Load(i)
fmt.Println(i, data)
}
}()
time.Sleep(time.Second)
//执行后正确输出
}
func main() {
test2()
}
细节分析:
- 如果 dirty 字段非 nil 的话,map 的 read 字段和 dirty 字段会包含相同的非 expunged 的项,所以如果通过 read 字段更改了这个项的值,从 dirty 字段中也会读取到这个项的新值,因为本来它们指向的就是同一个地址。
- dirty 包含重复项目的好处就是:一旦 miss 数达到阈值需要将 dirty 提升为 read 的话,只需简单地把 dirty 设置为 read 对象即可。不好的一点就是,当创建新的 dirty 对象的时候,需要逐条遍历 read,把非 expunged 的项复制到 dirty 对象中。
- 空间换时间。通过冗余的两个数据结构(只读的 read 字段、可写的 dirty),来减少加锁对性能的影响。对只读字段(read)的操作不需要加锁,优先从 read 字段读取、更新、删除,因为对 read 字段的读取不需要锁。
- sync.Map 所有的方法涉及的键和值的类型都是interface{},也就是空接口,这意味着可以使用任意数据类型,因此在程序中必须要自行保证键类型和值类型的正确性, Go 语言编译器无法在编译期对它们进行检查,不正确的键值实际类型肯定会引发 panic。
Go 是一个自动垃圾回收的编程语言,一般创建对象的时候想创建就创建,用完之后它会自动回收。但是如果想使用 Go 开发一个高性能的应用程序就必须考虑垃圾回收给性能带来的影响。在对程序做性能优化的时候会采用对象池的方式,把不用的对象回收起来,避免被当成垃圾回收掉,这样使用的时候就不必再重新创建了。比如对于数据库连接、TCP 长连接、HTTP连接 这些比较耗时的操作,可以把这些连接保存下来,避免每次使用的时候都重新创建,可以提高应用程序的整体性能。
在了解 sync.Pool 之前先看看如何使用一个普通的带缓冲channel来实现对象池,关于带缓冲channel可以参考:Go语言的并发:goroutine和channel_浮尘笔记的博客-程序员宅基地
//basic/go03/sync2/pool.go
package main
import (
"errors"
"fmt"
"time"
)
// 可重复使用的对象结构体
type userStruct struct {
name string
age int
}
type ObjPool struct {
bufChan chan *userStruct //用于缓冲可重用对象
}
// 创建并初始化对象池
func NewObjPool(numOfObj int) *ObjPool {
objPool := ObjPool{}
objPool.bufChan = make(chan *userStruct, numOfObj)
for i := 0; i < numOfObj; i++ {
objPool.bufChan <- &userStruct{
//假设提前预置好指定数量的连接信息
//也可以在这里不预置,然后在 PutObj() 操作中再设置连接信息
name: fmt.Sprintf("%v_%d", "user", i),
age: 18,
}
}
return &objPool
}
// 获取对象池中的数据
func (p *ObjPool) GetObj(timeout time.Duration) (*userStruct, error) {
select {
case ret := <-p.bufChan:
return ret, nil
//超时控制,不会让获取对象的地方一直阻塞,达到设定的超时时间后会返回一个错误信息
case <-time.After(timeout):
return nil, errors.New("获取数据超时")
}
}
// 将数据放入到对象池中
func (p *ObjPool) PutObj(obj *userStruct) error {
select {
case p.bufChan <- obj:
return nil
//在某些情况下(比如size已经满了)会出现放不进去,为了防止阻塞,在default分支中抛出一个异常
default:
return errors.New("对象池容量已满")
}
}
func main() {
pool := NewObjPool(5)
//尝试给已满的对象池中继续放入对象
//if err := pool.PutObj(&userStruct{}); err != nil {
// fmt.Println("错误: ", err)
//}
for i := 0; i < 3; i++ {
//设置1秒超时
if v, err := pool.GetObj(time.Second * 1); err != nil {
fmt.Println("获取对象出错: ", err)
} else {
fmt.Printf("%T, %v,%v \n", v, v, pool.bufChan)
if err := pool.PutObj(v); err != nil {
fmt.Println("放入对象出错: ", err)
}
}
}
fmt.Println("完成")
}
上面的例子使用channel实现了一个简单的用户信息对象池,如果尝试给已满的对象池中继续放入对象(去掉main函数上面部分 pool.PutObj 的注释),就会报错:
如果获取完对象忘记了放回去,并且获取的次数超过了预置的对象池大小,则会进入到获取数据的超时控制部分:
func main() {
pool := NewObjPool(5)
for i := 0; i < 6; i++ {
//设置1秒超时
if v, err := pool.GetObj(time.Second * 1); err != nil {
fmt.Println("获取对象出错: ", err)
} else {
fmt.Printf("%T, %v,%v \n", v, v, pool.bufChan)
//if err := pool.PutObj(v); err != nil {
// fmt.Println("放入对象出错: ", err)
//}
}
}
fmt.Println("完成")
}
sync.Pool 用来保存一组可独立访问的临时对象,这里的“临时对象”是指不需要持久使用的某一类值,这个“临时对象”会在未来的某个时候被移除掉,而且如果没有别的对象引用这个被移除的对象的话,这个被移除的对象就会被垃圾回收掉。sync.Pool临时对象池是线程安全的,可以主要用作数据的缓存;会有锁的开销,因此使用的时候需要衡量是“锁带来的开销大?”还是“创建一个对象池带来的开销大?”。
sync.Pool定义如下:
//$GOROOT/src/sync/pool.go
type Pool struct {
noCopy noCopy
local unsafe.Pointer
localSize uintptr
victim unsafe.Pointer
victimSize uintptr
New func() any
}
func (p *Pool) Put(x any) {}
func (p *Pool) Get() any {}
sync.Pool类型有如下方法和字段:
看一个简单的例子:
//basic/go03/sync2/pool2.go
package main
import (
"fmt"
"sync"
)
func test1() {
pool := &sync.Pool{
//初始化并放入一个数据
New: func() interface{} {
fmt.Println("创建一个新对象")
return "你好呀"
},
}
fmt.Println(pool.Get()) //获取初始化对象池放入的数据,输出: 你好呀
pool.Put("我很好~") //放入一个新的数据
fmt.Println(pool.Get()) //再次获取池中的数据,输出: 我很好~
}
func main() {
test1()
}
上面的例子可以理解为就是一开始使用 New字段初始化一个池中的数据,然后用 Get方法获取刚才初始化的数据,再然后使用 Put方法给池中放入一个新的数据。如果在Put数据之后使用垃圾回收机制回收了池中的资源,那么刚才Put的数据就被清除了,会再次进入初始化的流程中。代码如下:
//basic/go03/sync2/pool2.go
package main
import (
"fmt"
"sync"
)
func test1() {
pool := &sync.Pool{
//初始化并放入一个数据
New: func() interface{} {
fmt.Println("创建一个新对象")
return "你好呀"
},
}
fmt.Println(pool.Get()) //获取初始化对象池放入的数据,输出: 你好呀
pool.Put("我很好~") //放入一个新的数据
runtime.GC() //人为的触发垃圾回收,清除sync.pool中缓存的对象
fmt.Println(pool.Get()) //再次获取池中的数据,输出: 我很好~
}
func main() {
test1()
}
刚才演示的是在顺序执行的流程中加入了 sync.Pool 的用法, 下面再看看goroutine中sync.Pool 的用法:
//basic/go03/sync2/pool2.go
package main
import (
"fmt"
"sync"
)
func test2() {
pool := &sync.Pool{
New: func() interface{} {
fmt.Println("创建一个新对象")
return "hello"
},
}
pool.Put("golang")
pool.Put("php")
pool.Put("java")
var wg sync.WaitGroup
for i := 0; i < 6; i++ {
wg.Add(1)
go func(id int) {
fmt.Println(pool.Get())
wg.Done()
}(i)
}
wg.Wait()
}
func main() {
test2()
}
上面代码初始化对象池之后放入了3个数据,然后在一个6次的循环中并发的获取池中的数据,已经放入的3个数据被取出来了,另外3次会进入到初始化的流程中。这也验证了上面总结的:如果当前池中没有任何值,那么Get 方法会使用New字段创建一个新值并直接将其返回。
标准库代码包 fmt 就使用到了sync.Pool类型,这个包会创建一个用于缓存某类临时对象的sync.Pool类型值,并将这个值赋给一个名为ppFree的变量。临时对象池ppFree的New字段在被调用的时候,总是会返回一个全新的pp类型值的指针(即临时对象),这就保证了ppFree的Get方法总能返回一个可以包含需要打印内容的值。
在使用 fmt.Println、fmt.Printf 同时执行很多的打印函数调用的时候,ppFree可以及时地把它缓存的临时对象提供给它们,以加快执行的速度。而当程序在一段时间内不再执行打印函数调用时,ppFree中的临时对象又能够被及时地清理掉,以节省内存空间。
//$GOROOT/src/fmt/print.go
var ppFree = sync.Pool{
New: func() any { return new(pp) },
}
【问】临时对象池中的值被回收的时机是怎样的?
【答】因为 Go 语言运行时系统中的垃圾回收器,检测到临时对象池以外的代码没有了对它们的引用,那么在稍后的垃圾回收过程中这些临时对象就会被当作垃圾销毁掉,它们占用的内存空间也会被回收。也就是说这个临时对象池的缓存有效期截止到下一次开始垃圾回收之前。
Go 标准库中的 Context 是在 Go 1.7 版本加入到标准库的,它可以理解为一种同步工具,在实现主要业务流程的时候,还能附带着实现一些通用的信息传递,也就是上下文信息,此类值是并发安全的,可以传播给多个 goroutine。Go 标准库中的 database/sql、os/exec、net、net/http、runtime/trace 等包中都使用到了 Context。
Context 还提供了超时(Timeout)和取消(Cancel)的机制。可以使用 Context的场景:上下文信息传递 (request-scoped),比如处理 http 请求、在请求处理链路上传递信息;控制子 goroutine 的运行(比较常用);超时控制的方法调用;可以取消的方法调用。
一个任务会有很多个协程协作完成,一次HTTP请求也会触发很多个协程的启动,如果因为某些原因导致任务终止了,HTTP请求取消了,那么它们启动的协程也应该取消。Context就是用来简化解决这些问题的,并且是并发安全的。Context是一个接口,它具备手动、定时超时发出取消信号、传值等功能,主要用于控制多个协程之间的协作,尤其是取消操作。
Context 包含四个方法:Deadline、Done、Err、Value,同时实现了 2 个常用的生成顶层 Context 的方法。Context的定义如下:
//$GOROOT/src/context/context.go
type Context interface {
// 获取 Context 被取消的截止时间,如果没有设置截止时间 则 ok 的值是 false;后续每次调用这个对象的 Deadline 方法时,都会返回和第一次调用相同的结果。
Deadline() (deadline time.Time, ok bool)
// 返回一个 Channel 对象,在 Context 被取消时,此 Channel 会被 close,如果没被取消,可能会返回 nil,后续的 Done 调用总是返回相同的结果。
// 当 Done 被 close 的时候,可以通过 ctx.Err 获取错误信息。
Done() <-chan struct{}
// 如果 Done 没有被 close,Err 方法返回 nil;如果 Done 被 close,Err 方法会返回 Done 被 close 的原因。
Err() error
// 返回此 ctx 中和指定的 key 相关联的 value
Value(key interface{}) interface{}
}
// Context 中实现了 2 个常用的生成顶层 Context 的方法。
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
// 返回一个非 nil 的、空的 Context,没有任何值,不会被 cancel,不会超时,没有截止日期。
// 一般用在主函数、初始化、测试以及创建根 Context 的时候。
func Background() Context {
return background
}
// 返回一个非 nil 的、空的 Context,没有任何值,不会被 cancel,不会超时,没有截止日期。
// 当你不清楚是否该用 Context,或者目前还不知道要传递一些什么上下文信息的时候,就可以使用这个方法。
func TODO() Context {
return todo
}
context 中的四个特殊方法:WithValue、WithCancel、WithTimeout、WithDeadline。
//$GOROOT/src/context/context.go
// 产生一个可撤销的parent的子值,返回 parent 的副本,只是副本中的 Done Channel 是新建的对象,它的类型是 cancelCtx。
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {}
// 基于 parent Context 生成一个新的 Context,保存了一个 key-value 键值对,常常用来传递上下文。
func WithValue(parent Context, key, val any) Context {}
// WithTimeout 是超时时间,用来产生一个会定时撤销的parent的子值。
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {}
// WithDeadline 是截止时间,超时时间 + 当前时间 = 截止时间
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {}
比如访问一个远程服务的时候出现了超时,那么可以在 Context 被 cancel 的时候断开服务器连接,这样能减少对服务调用的压力。比如下面的代码:
package main
import (
"context"
"fmt"
"time"
)
func test1() {
ctx, cancel := context.WithCancel(context.Background())
go func() {
defer func() {
fmt.Println("goroutine已退出,已断开远程服务连接")
}()
for {
select {
case <-ctx.Done():
return
default:
time.Sleep(time.Second)
}
}
}()
time.Sleep(time.Second)
cancel()
time.Sleep(2 * time.Second)
}
func main() {
test1()
}
还有一个场景,比如有一个监控进程一直在不停的监控后台数据是否有异常,可以使用context来发送停止监控的指令。代码如下:
// basic/go03/context/demo3.go
package main
import (
"context"
"log"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
wg.Add(1)
ctx, stop := context.WithCancel(context.Background())
go func() {
defer wg.Done()
watchData(ctx, "监控1")
}()
time.Sleep(time.Second * 3) //先监控3秒钟
stop() //发送停止的信号
wg.Wait()
}
func watchData(ctx context.Context, name string) {
//死循环中一直监控后台数据
for {
select {
case <-ctx.Done():
log.Println(name, "已收到停止监控的指令,不再监控")
return
default:
log.Println(name, "正在监控中...")
}
time.Sleep(time.Second)
}
}
上面例子演示了监控单个goroutine的示例,下面再扩展一下,如何监控多个goroutine。比如有这样一个场景:在启动了多个存在父子关联关系的任务(协程)之后,取消掉某一个节点的任务,需要对应的节点和它的所有子任务都被取消,如下图所示:
使用context可以很方便的实现这个功能,代码如下:
// basic/go03/context/demo2.go
package main
import (
"context"
"fmt"
"time"
)
func isCancelled(ctx context.Context) bool {
select {
// <-ctx.Done() 表示接收到了取消的通知信号,此时所有的子Context都会被取消
case <-ctx.Done():
return true
default:
return false
}
}
func main() {
// 通过 context.Background() 创建一个 根Context
// 通过 context.WithCancel(根Context) 创建子Context, 返回一个用于触发撤销信号的函数
ctx, cancel := context.WithCancel(context.Background())
for i := 0; i < 5; i++ {
go func(i int, ctx context.Context) {
for {
if isCancelled(ctx) {
break
}
time.Sleep(time.Millisecond * 5)
}
fmt.Println("任务", i, "已取消")
}(i, ctx)
}
//调用 触发撤销信号的函数
cancel()
time.Sleep(time.Second * 1)
}
一般使用Context的原则:
- Context不要放在结构体中,要以函数的方式传递;当函数使用 Context 的时候,会把这个参数放在第一个参数的位置。
- 使用 context.Background() 创建一个空的上下文对象(根节点),使用With系列函数生成Context树,把相关的Context关联起来。
- Context 只是用来临时做函数之间的上下文透传,不能持久化 Context 或者把 Context 长久保存,不要把 Context 持久化到数据库、本地文件或者全局变量中。
- key 的类型不应该是字符串类型或者其它内建类型,否则容易在包之间使用 Context 时候产生冲突。使用 WithValue 时,key 的类型应该是自己定义的类型。
- 常常使用 struct{} 作为底层类型定义 key 的类型,对可导出 key 的静态类型,常常是接口或者指针,这样可以尽量减少内存分配。
源代码:https://gitee.com/rxbook/go-demo-2023/tree/master/basic/go03/sync2
文章浏览阅读2k次。小白一只,由于毕设题目跟SDN有关,就开始踢软件定义网络的大门,当然第一步就是熟悉网络工具,从mininet开始。对于从没接触过mininet、Linux的人来说,安装过程还是挺艰难的,我在安装过程中参考了一些很好的博客,在此做一个总结。 本人是在虚拟机VirtualBox中安装ubuntu-16.04.6-desktop-amd64.iso,然后在ubantu系统中..._安装mininet有几种方法
文章浏览阅读1.6k次。Reactive Extensions for .Net 为开发人员提供了一组功能,用于为 .Net 开发人员实现反应式编程模型,使用声明性操作使事件处理更简单、更具表现力。虽然反应式扩展的关键基石是 IObserver 和 IObservable 接口,但作为开发人员,您通常不需要自己实现这些接口。该库支持内置类型Subject<T>,它实现了两个接口并支持许多功能。主题是库中不同可用主题的基础,还有其他主题 -ReplaySubject<T>、BehaviorSubje..._iobserver
文章浏览阅读1.9k次,点赞4次,收藏27次。Debug 是对程序运行时环境的跟踪和观测,Debug 调试是开发者需要掌握的核心技能,是解决疑难杂症的金钥匙。这是 SAP ABAP 断点调试的第三篇文章,讲解经典 Debug 场景,演示开发和运维中常用的 Debug 工具和技巧,分享我的一些经验。_abap 外部断点可以进入数
文章浏览阅读1k次。最近搞echarts搞的要起飞了。上边文章已经说了基本地图的功能实现,下边开始自定义图片,样式如下我们需要对已经存在的资源池进行地区的显示。百度了之后发现代码都没实现成功,应该是我的写法,或者我没抄对吧。还是看看文档自己思考吧。官网介绍传送门完整代码需要给myMap增加固定的高和宽<div id="myMap" ref="myMap" class="border"></div><script>import { defineComponent, r_vue3 echarts自定义地图背景
文章浏览阅读2.8w次。本文以UNITY3D接入91SDK的过程为例。我的开发环境: MAC系统, ECLIPSE, UNITY4.0开发过程:1.准备要UNITY为交互Android自备的CLASS.JAR文件。 我的操作过程是:应用程序->UNTITY文件夹->UNITY->右键:显示包内容->CONTENTS文件夹->PLAYBACKENGINES文件夹->Android_unity中介入sdk
文章浏览阅读49次。Eclipse中10个最有用的快捷键组合一个Eclipse骨灰级开发者总结了他认为最有用但又不太为人所知的快捷键组合。通过这些组合可以更加容易的浏览源代码,使得整体的开发效率和质量得到提升。 1. ctrl+shift+r:打开资源 这可能是所有快捷键组合中最省时间的了。这组快捷键可以让你打开你的工作区中任何一个文件,而你只需要按下文件名或mask名中的前几个字母,比如a...
文章浏览阅读360次,点赞10次,收藏8次。如果嫌麻烦,可以把短信验证码功能关掉(sms.enable=false),此时会开启密码登录模式(登录密码就是验证码),直接使用手机号作为验证码即可登录,因为在注册功能中,默认会把手机号作为登录密码保存到数据库中。访问路径:http://localhost:56085/sailing / verify? 由于统一账户服务(wanxinp2p-account-service)需要使用短信验证码功能,因此需要使用sailing服务,接入很方便,只需在Apollo上进行相关配置即可。_验证码通过服务
文章浏览阅读877次。解决问题的操作步骤设置git:设置git的user name和email:git config --global user.name "xxx"git config --global user.email "[email protected]"生成密钥:ssh-keygen -t rsa -C "[email protected]"按3个回车,密码为空这里一般不使用密钥。最后得到了两个文件:id_rsa和id_rsa.p..._系统重置后git和小乌龟怎么恢复、
文章浏览阅读4.8k次,点赞6次,收藏38次。12、CSM_mcal crypto
文章浏览阅读9.2k次,点赞10次,收藏8次。写在前面:鉴于评论、私信等方式很难有时间查看,因此提供我的邮箱:[email protected]。1. 关于我:教育经历:2018年本科毕业于某985,推免至中科院某所,目前研二在读(2018-2021)。专业:计算机科学与技术(计算机应用技术)研究兴趣:Computer Graphics、Machine Learning、Computer Vision主力编程语言:C,......_作者: ryu邮箱
文章浏览阅读2.6k次。大家好,我是粥粥。分子动力模拟再好,没有方便的数据分析,就画不出有用又漂亮的图。对于MD模拟数据后处理,LAMMPS内的compute command可以进行简单的RDF、配位数、ADF和MSD等的计算,更多的分析可以借助别人造好的轮子(开源程序)进行计算,对于个性化的分析就要自己去编程了。此系列收集整理后处理程序的用途,以备不时之需。ISAACS可对由LAMMPS模拟得出的分子构型(data文件或轨迹文件)进行后处理分析的程序,包括径向分布函数、原子配位数、模型自由体积和密度、键角分布、环统计量、球面谐波_lammps计算聚合物自由体积
文章浏览阅读4.9k次,点赞2次,收藏8次。题目求PI的近似值 (30 分)用正多边形逼近法求π的近似值。 用圆内接正多边形的边长和半径之间的关系,不断将边数翻倍并求出边长,重复这一过程,正多边形的边长就逐渐逼近圆的周长,只要圆内接正多边形的边数足够多,就可以求得所需精度的π值。 从正六边形开始。简单起见,设单位圆的半径是1,则单位圆的圆周长是2×π,设单位圆内接正i边形的边长为2b,边数加倍后正2i边形的边长为x,则:输入格式:输入1-10的数k(圆正接多边形边数n=6*2^(k-1))输出格式:圆内接正多边形的边数n和PI值,PI的_求pi的近似值