idioma ir WebSocket establecer conexiones y enviar regularmente los latidos del corazón

En se necesita mucho trabajo para establecer la WebSocket conexión a los usuarios concurrentes Simulación, el principio es el uso de un paquete de WebSocket jmeter de terceros para lograr, pero se encontró demasiado multiproceso jmeter consumen recursos del sistema, construido alrededor de 8000 cuando la carga es máquina conectada en el proceso de medición de la presión los recursos se habían ocupado casi, en lugar de ir a conseguir.

Es parte del código de aplicación:

paquete principal 

de importación ( 
   " codificación / json " 
   " bandera " 
   " FMT " 
   " github.com/gorilla/websocket " 
   " github.com/satori/go.uuid " 
   " registro " 
   " / url neta " 
   " expresión regular " 
   " sincronización " 
   " tiempo " 
) 

tipo de Connetion struct { 
   con * websocket.Conn 
   mutex sync.Mutex 
}

　//定义命令行参数
 var dir = bandera.String ( " un ", " Ip: puerto " , " http dirección de servicio " )
 var clientUuid = flag.String ( " u " , "" , " uuid " )
 var c = flag.Int ( " c " , 5 , " número de conexiones " ) 


func webSocketConn (WG sync.WaitGroup, msg [] bytes ) { 
   u: = {url.URL Esquema: " ws " , Host:* Dir}
    era marcador * websocket.Dialer

   Conn, _, ERR: = dialer.Dial (u.String (), nil) 

   SI ! ERR = {nula 
     fmt.Println (ERR) 

     de retorno 
   } 


   WERR: = conn.WriteMessage (websocket.TextMessage, MSG) 

   // FMT. printf ( "Enviar:% S \ n-", String (MSG))
    // 2. Crear un objeto de expresión regular 
   REGx, _: = regexp.Compile ( " .. \\ {W} 8 (- 4 \\ {W }) {} de 3 - 12 es {W} \\. " )
    // 3. expresiones regulares objeto coincide con la cadena especificada 
   RES: regx.FindString = ( string (MSG))
    // fmt.Printf (" partido clientId:% S \ n-", RES) 
   MSG1: = la marca (mapa [ cadena ] interfaz {})
   msg2: nil {= Marca (mapa [ cadena ] interfaz {}) 
   msg2 [ " éxito " ] = verdadero 

   msg1 [ " clientId " ] = res 
   msg1 [ " messageType " ] = " ACK " 
   msg1 [ " messageId " ] = " 5e7d6e31e4b079c2b22876d8 " 
   msg1 [ " datos " ] = msg2 
   amsg, _: = json.Marshal (msg1) 

   si Werr =! 
      FMT.Println (Werr) 
   }
    // 10s temporizador declarar, establecer el tiempo de los latidos del corazón 10s 
   ticker: = time.NewTicker (time.Second * 10 ) 

   Conectar: = & Connetion { 
      CON: Conn, 
   } 
   // Abrir multiproceso 
   Go Connect .timeWriter (ticker, Connecticut) 


   para { 
      _, Mensaje, ERR: = conn.ReadMessage ()
       SI ERR =! nil { 
         fmt.Println ( " Leer: " , ERR)
          de retorno 
      }   // mutex 
      connect.mutex.Lock () 
      werr2:

 =connect.con.WriteMessage (websocket.TextMessage, amsg) 
      connect.mutex.Unlock ()

      Si werr2 =! nil { 
         fmt.Println (werr2) 
      } 

      fmt.Printf ( " recibido:% s \ n " , mensaje) 
   } 
   wg.Done ()               // 每次把计数器-1 

} 

func (con * Connetion) Timewriter (ticker * time.Ticker, c * websocket.Conn) { 


   para {
       <- ticker.C 
      err: = c.SetWriteDeadline (. time.Now () Añadir ( 10 * time.Second))
       // fmt.Println (tiempo .now Format (). (time.UnixDate)) 
      si se equivocan! = nil { 
         log.Printf ( " error de ping:% s \ n " , err.Error ()) 
      } 

      con.mutex.Lock () 
      si se equivocan: = c.WriteMessage (websocket.PingMessage, nil); ! err = nil { 
         log.Printf ( " ping-error:% s \ n " , err.Error ()) 
      } 
      con.mutex.Unlock () 

   } 
} 


func NewConnMsg () [] bytes { 

   msg: = marca (mapa [ string ] interfaz {}) 

   uuid1, _: = uuid.NewV4 ()
    // fmt.Printf ( "uuid值:% s \ n", uuid1)
   id: = uuid1.String ()
    si  * clientUuid =="" { 
      msg [ " clientId " ] = ID 
   } demás { 
      msg [ " clientId " ] = * clientUuid 
   } 


   msg [ " messageId " ] = " 5e7d6e31e4b079c2b22876d8 " 
   msg [ " messageType " ] = " LOGIN " 
   msg [ " targetType " ] = " PASAJERO "

   BMSG, _: = JSON.
   Marshal (msg) //log.Printf ( "% S \ n-", BMSG) 

   volver BMSG 
} 

FUNC RUN () { 

   flag.Parse ()          // comando argumentos de línea de 
   var WG sync.WaitGroup          // contador declare 
   para I: = 0 ; I <C * ; I ++ { 
      wg.Add ( 1. )          // conjunto de contadores valor inicial 
      Go webSocketConn (WG, NewConnMsg ())
       SI (% C * 200 es ) == 0 { 
         time.sleep (time.Millisecond * 50 )
          // fmt.Println (Time.now (). Formato (time.UnixDate)) 
       }
   } 
   log.Printf ( " Conexiones creaate WebSocket: V% \ n- " , * C) 
   wg.Wait ()             // bloqueo de código hasta que el contador se decrementa a 0 run 
} 


FUNC main () { 
   // NewConnMsg () 
   RUN () 
}

Desde WebSocket no admite la escritura simultánea, es necesario agregar son necesarios para escribir un mensaje en lugar de la exclusión mutua, no será error: escritura concurrente para ir WebSocket conexión