Golang order output of go routines

I have 16 go routines which return output , which is typically a struct.

struct output{
index int,
description string,
}

Now all these 16 go routines run in parallel, and the total expected output structs from all the go routines is expected to be a million. I have used the basic sorting of go lang it is very expensive to do that, could some one help me with the approach to take to sort the output based on the index and I need to write the "description" field on to a file based on the order of index.

For instance ,
if a go routine gives output as {2, "Hello"},{9,"Hey"},{4,"Hola"}, my output file should contain
Hello
Hola
Hey

All these go routines run in parallel and I have no control on the order of execution , hence I am passing the index to finally order the output.

One thing to consider before getting into the answer is your example code will not compile. To define a type of struct in Go, you would need to change your syntax to

type output struct {
	index       int
	description string
}

In terms of a potential solution to your problem - if you already reliably have unique index's as well as the expected count of the result set - you should not have to do any sorting at all. Instead synchronize the go routines over a channel and insert the output in an allocated slice at the respective index. You can then iterate over that slice to write the contents to a file. For example:

ch := make(chan output) //each go routine will write to this channel
wg := new(sync.WaitGroup) //wait group to sync all go routines

//execute 16 goroutines 
for i := 0; i < 16; i++ {
	wg.Add(1)
	go worker(ch, wg) //this is expecting each worker func to call wg.Done() when completing its portion of work
}

//create a "quit" channel that will be used to signal to the select statement below that your go routines are all done
quit := make(chan bool)
go func() {
    wg.Wait()
	quit <- true
}()

//initialize a slice with length and capacity to 1mil, the expected result size mentioned in your question
sorted := make([]string, 1000000, 1000000)

//use the for loop, select pattern to sync the results from your 16 go routines and insert them into the sorted slice
for {
	select {
		case output := <-ch:
            //this is not robust - check notes below example
			sorted[output.index] = output.description
		case <-quit:
            //implement a function you could pass the sorted slice to that will write the results
            // Ex:  writeToFile(sorted)
			return
	}
}

A couple notes on this solution: it is dependent upon you knowing the size of the expected result set. If you do not know what the size of the result set is - in the select statement you will need to check if the index is read from ch exceeds the length of the sorted slice and allocate additional space before inserting our you program will crash as a result of an out of bounds error

You could use the module Ordered-concurrently to merge your inputs and then print them in order.

https://github.com/tejzpr/ordered-concurrently

Example - https://play.golang.org/p/hkcIuRHj63h

package main

import (
	concurrently "github.com/tejzpr/ordered-concurrently/v2"
	"log"
	"math/rand"
	"time"
)

type loadWorker int

// The work that needs to be performed
// The input type should implement the WorkFunction interface
func (w loadWorker) Run() interface{} {
	time.Sleep(time.Millisecond * time.Duration(rand.Intn(10)))
	return w
}

func main() {
	max := 10
	inputChan := make(chan concurrently.WorkFunction)
	output := concurrently.Process(inputChan, &concurrently.Options{PoolSize: 10, OutChannelBuffer: 10})
	go func() {
		for work := 0; work < max; work++ {
			inputChan <- loadWorker(work)
		}
		close(inputChan)
	}()
	for out := range output {
		log.Println(out.Value)
	}
}

Disclaimer: I'm the module creator