Design of golang lottery system

Business difficulties

Design a lottery system , This system is not materialized , It's abstraction , It has the following difficulties ：
1、 Lottery business needs Complicated and changeable
2、 Prize type and probability setting
3、 Fair draw and safe Award
4、 Concurrent security issues One cannot shoot many times
5、 Efficient draw and Award , Provide high concurrency and performance
6、 How to use redies To optimize

Technology options

1. High concurrency Go Collaboration takes precedence over PHP Multi process ,Java Of Multithreading model
2. High performance compiled binary takes precedence over PHP Explanatory and Java virtual machine
3. Efficient network model epoll The model takes precedence over PHPBIO Models and Java NIO Model

sweepstakes

1. The annual meeting draw , Lottery scratch , Wechat shakes , Lottery turntable , Activities such as lucky card , This project Lottery turntable Design as an activity .
2. Actual content of the project ： frame / Core code background function , Set and send prizes reasonably , mysql+ Optimize - Use redies Award plan and prize pool , Stress testing and more operational strategies （ Have a better understanding of the performance of the system , There are more strategies for operating products ）, introduce thirft frame (RPC frame ), Design interface generation code , Server interface and client program

Demand analysis

1. go mod  To configure 
2.  Configure domestic agents ： go env -w GOPROXY=https://goproxy.cn,https://goproxy.io,direct
3. go get -u -v github.com/kataras/iris  The download package is in  GOPATH Of PKG Under the table of contents 
4. iris: function ：  Safety certification , cache  cookies  file  MVC,  Templates   Rich sample code 
5. https://iris-go.com/v10/recipe

* The drawing process of the annual meeting
It uses iris This web frame To deal with

/** * curl http://localhost:8080/ * curl --data "users=123,567" http://localhost:8080/import * curl http://localhost:8080/lucky */

package main

import (
	"fmt"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/mvc"
	"math/rand"
	"strings"
	"sync"
	"time"
)

var userList []string //  Before and after reading and writing shared variables   Need to increase the   Lock setting   Add mutexes in a simple way 
var mu sync.Mutex

type lotteryController struct {
    
	Ctx iris.Context
}

//  Start a  iris  application 
func newApp() *iris.Application {
    
	app := iris.New()
	mvc.New(app.Party("/")).Handle(&lotteryController{
    })
	return app
}
func main() {
    
	app := newApp()
	userList = []string{
    }
	mu = sync.Mutex{
    }
	err := app.Listen(":8080")
	if err != nil {
    
		panic(fmt.Sprintf("web server start error: %s\n", err))
		return
	}
}

func (c *lotteryController) Get() string {
    
	count := len(userList)
	return fmt.Sprintf(" The current total number of users participating in the lottery ：%d\n", count)
}

// PostImport POST http://localhost:8090/import
// params : users
func (c *lotteryController) PostImport() string {
    
	strUsers := c.Ctx.FormValue("users")
	users := strings.Split(strUsers, ",")
	//  When batch threads are imported   Found a problem with multithreading   The statistics are incorrect 
	mu.Lock()
	defer mu.Unlock()
	count1 := len(userList)
	for _, u := range users {
    
		u = strings.TrimSpace(u)
		if len(u) > 0 {
    
			userList = append(userList, u)
		}
	}
	count2 := len(userList)
	return fmt.Sprintf(" The current total number of users participating in the lottery ：%d,  Number of users successfully imported ：%d\n", count2, count2-count1)
}

// GetLucky GET http://localhost:8090/lucky
func (c *lotteryController) GetLucky() string {
    
	//  The lottery place carries on the lock judgment 
	mu.Lock()
	defer mu.Unlock()

	count := len(userList)
	if count > 1 {
    
		index := rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(int32(count))
		user := userList[index]
		//  need   Delete the selected person   You can delete   At present index  The data under the   Better 
		userList = append(userList[0:index], userList[index+1:]...)
		return fmt.Sprintf(" Current winning users ：%s,  Number of remaining users ：%d\n", user, count-1)
	} else if count == 1 {
    
		user := userList[0]
		return fmt.Sprintf(" Current winning users ：%s,  Number of remaining users ：%d\n", user, count-1)
	} else {
    
		return fmt.Sprintf(" The current winning is over , No user participated in winning \n")
	}
}

Unit test problems , about userList Of Data contention occurs in multithreading ：

package main

import (
	"fmt"
	"github.com/kataras/iris/v12/httptest"
	"sync"
	"testing"
)

func TestMVC(t *testing.T) {
    
	app := newApp()
	e := httptest.New(t, app)

	//  Use synchronous wait lock 
	var wg sync.WaitGroup
	e.GET("/").Expect().Status(httptest.StatusOK).Body().Equal(" The current total number of users participating in the lottery ：0\n")

	for i := 0; i < 100; i++ {
    
		wg.Add(1)
		//  There will be no concurrency problem 
		go func(i int) {
    
			defer wg.Done()
			e.POST("/import").WithFormField("users", fmt.Sprintf("test_u%d", i)).Expect().Status(httptest.StatusOK)
		}(i)
	}

	wg.Wait()
	e.GET("/").Expect().Status(httptest.StatusOK).Body().Equal(" The current total number of users participating in the lottery ：100\n")
	e.GET("/lucky").Expect().Status(httptest.StatusOK)
	e.GET("/").Expect().Status(httptest.StatusOK).Body().Equal(" The current total number of users participating in the lottery ：99\n")
}