Petua untuk menggunakan caching untuk memproses data pemanduan autonomi di Golang.

Pembangunan teknologi pemanduan autonomi menjadikan sejumlah besar pemprosesan data diperlukan. Terutamanya dalam peralatan yang dipasang pada kenderaan, penghantaran dan pemprosesan data mestilah tepat pada masanya dan cekap untuk memastikan pemanduan yang selamat. Golang ialah bahasa pengaturcaraan sumber terbuka yang ringan yang dicirikan oleh pelaksanaan serentak dan pemprosesan data berskala besar yang cekap. Artikel ini akan memperkenalkan cara menggunakan caching untuk memproses data pemanduan autonomi di Golang, dengan itu meningkatkan kecekapan pemprosesan data.

1. Peranan caching

Dalam proses pemprosesan data kenderaan autonomi, sejumlah besar data perlu dikumpul, diproses, disimpan dan dihantar. Bagi sesetengah data dengan prestasi masa nyata yang tinggi, jika setiap permintaan mengakses pangkalan data atau peranti storan, kecekapannya akan terjejas dengan ketara. Pada masa ini, menggunakan cache boleh meningkatkan kecekapan pemprosesan data dengan berkesan. Caching merujuk kepada menyimpan sebahagian data dalam ingatan supaya ia boleh diakses dengan cepat kemudian.

Di Golang, caching boleh dilaksanakan menggunakan RWMutex yang disediakan dalam peta dan pakej penyegerakan. Dengan mentakrifkan objek peta global, data yang perlu dicache disimpan dalam peta, supaya data boleh dibaca terus dari memori dalam permintaan seterusnya dan bukannya mengakses pangkalan data atau membaca cakera setiap kali.

2. Pelaksanaan cache

Di Golang, tentukan objek peta global untuk menyimpan data yang perlu dicache. Pelaksanaan cache biasa adalah seperti berikut:

var cacheMap = make(map[string]interface{})
var mutex = sync.RWMutex{}

Dengan cara ini, kita boleh menggunakan objek peta dalam skop global untuk menyimpan data yang perlu dicache. Seterusnya, kita perlu menggunakan kunci baca-tulis untuk memastikan keselamatan akses serentak kepada data cache.

// 获取缓存值
func GetCache(key string) (interface{}, bool) {
    mutex.RLock()
    defer mutex.RUnlock()

    value, ok := cacheMap[key]
    return value, ok
}

// 设置缓存值
func SetCache(key string, value interface{}) {
    mutex.Lock()
    defer mutex.Unlock()

    cacheMap[key] = value
}

Apabila mendapatkan nilai cache, kami menggunakan kunci baca (RLock) untuk memastikan berbilang coroutine boleh membaca data dalam cache pada masa yang sama. Apabila menetapkan nilai cache, kami menggunakan kunci tulis (Kunci) untuk memastikan data tidak ditulis oleh berbilang coroutine pada masa yang sama.

Untuk memastikan cache tidak menempati memori sepanjang masa, kita perlu menetapkan tempoh sah cache. Apabila tempoh sah cache tamat, data cache akan dikosongkan.

// 设置带有过期时间的缓存值
func SetExpireCache(key string, value interface{}, ttl time.Duration) {
    mutex.Lock()
    defer mutex.Unlock()
    cacheMap[key] = expireCache{value, time.Now().Add(ttl)}
}

type expireCache struct {
    Value interface{}
    ExpireTime time.Time
}

// 获取缓存值和剩余过期时间
func GetExpireCache(key string) (interface{}, time.Duration, bool) {
    mutex.RLock()
    defer mutex.RUnlock()

    value, ok := cacheMap[key].(expireCache)
    if !ok {
        return nil, 0, false
    }

    now := time.Now()
    if now.After(value.ExpireTime) {
        delete(cacheMap, key)
        return nil, 0, false
    }

    return value.Value, value.ExpireTime.Sub(now), true
}

Melalui pelaksanaan kod di atas, kami boleh melaksanakan fungsi tetapan tempoh sah cache dengan mudah. Ini memastikan bahawa cache tidak menduduki memori sepanjang masa, dan juga memastikan bahawa data dalam cache dikemas kini pada setiap masa untuk memastikan ketepatan data.

3. Penggunaan cache

Dalam proses pemprosesan data sebenar, kami boleh mempercepatkan akses data melalui caching. Berikut ialah contoh mudah yang menggunakan cache untuk memproses data kenderaan autonomi yang diperoleh daripada perkhidmatan Mock:

func (s *AutoCarServer) GetCarData(ctx context.Context, req *api.CarDataRequest) (*api.CarDataResponse, error) {
    key := fmt.Sprintf("%s_%d", req.GetVin(), req.GetTimestamp())

    // 从缓存中获取数据
    if value, ok := cache.GetCache(key); ok {
        if data, ok := value.(*api.CarData); ok {
            return &api.CarDataResponse{
                Data: data,
            }, nil
        }
    }

    // 从 Mock 服务中获取数据
    data, err := s.autoCarServiceClient.GetCarData(ctx, req)
    if err != nil {
        log.Errorf("failed to get car data from mock server, error: %v", err)
        return nil, status.Errorf(codes.Internal, "failed to get car data from mock server")
    }

    // 将数据存入缓存
    cache.SetExpireCache(key, data.GetData(), 10*time.Second)

    return &api.CarDataResponse{
        Data: data.GetData(),
    }, nil
}

Dalam contoh ini, kami mula-mula mendapatkan data daripada cache. Jika data yang sepadan tidak ditemui dalam cache, data diperoleh daripada perkhidmatan Mock. Selepas mendapatkan data, kami juga perlu menyimpan data dalam cache supaya data boleh dibaca terus dari cache kemudian, dengan itu mengurangkan bilangan permintaan untuk perkhidmatan Mock.

4. Ringkasan

Caching ialah cara yang berkesan untuk meningkatkan kecekapan pemprosesan data dan juga sangat penting dalam teknologi pemanduan autonomi. Sebagai bahasa pengaturcaraan yang sangat serentak dan cekap, Golang menyediakan pakej peta dan penyegerakan yang fleksibel serta alatan lain untuk melaksanakan fungsi caching dengan mudah. Dalam proses pemprosesan data sebenar, penggunaan cache secara berkesan dapat mengurangkan bilangan permintaan dan meningkatkan kecekapan pemprosesan data dan prestasi sistem. Dengan petua di atas, kami boleh menggunakan caching dengan mudah untuk memproses data pemanduan autonomi di Golang.

Atas ialah kandungan terperinci Petua untuk menggunakan caching untuk memproses data pemanduan autonomi di Golang.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!