使用golang设计一个key是playerid，value是channel的map。当写入数据的时候，如果playerid对应的channel不存在，那么创建一个channel，并将数据写入channel ; 定时检查当channel为空的时候，10s后删除该值，并且该map可以并发使用。

好的，这是一个关于使用golang设计一个key是playerid，value是channel的map的问题。可以使用sync包中的Mutex来实现并发使用，使用time包中的Ticker来定时检查channel是否为空并删除。具体实现可以参考以下代码：

package main

import (
    "sync"
    "time"
)

type Player struct {
    channel chan interface{}
    mutex   sync.Mutex
}

type PlayerMap struct {
    players map[string]*Player
    mutex   sync.Mutex
}

func NewPlayerMap() *PlayerMap {
    return &PlayerMap{
        players: make(map[string]*Player),
    }
}

func (pm *PlayerMap) Write(playerID string, data interface{}) {
    pm.mutex.Lock()
    defer pm.mutex.Unlock()

    player, ok := pm.players[playerID]
    if !ok {
        player = &Player{
            channel: make(chan interface{}),
        }
        pm.players[playerID] = player
    }

    player.mutex.Lock()
    defer player.mutex.Unlock()

    player.channel <- data
}

func (pm *PlayerMap) StartCleaner() {
    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop()

    for range ticker.C {
        pm.mutex.Lock()

        for playerID, player := range pm.players {
            player.mutex.Lock()

            select {
            case <-player.channel:
                // Channel not empty, do nothing
            default:
                // Channel empty, delete player
                delete(pm.players, playerID)
            }

            player.mutex.Unlock()
        }

        pm.mutex.Unlock()
    }
}

使用示例：

func main() {
    pm := NewPlayerMap()

    // Start cleaner
    go pm.StartCleaner()

    // Write data
    pm.Write("player1", "data1")
    pm.Write("player2", "data2")

    // Wait for data to be processed
    time.Sleep(1 * time.Second)
}