How to create a producer and consumer in Go

package main

import (
    "runtime/pprof"
    "flag"
    "log"
    "fmt"
    "runtime"
    "os"
    
    
  
)

// Producer definition
type Producer struct {
    text *chan int
    done *chan bool
}

// produce start creating message and send it through channel 
func (p *Producer) produce(max int) {
    fmt.Println("Producer start message sending")
    for i := 0; i < max; i++ {
        fmt.Println("Message send by Producer ", i)
        *p.text <- i
    }
    *p.done <- true // updates when message produced
    fmt.Println("Producer message ends")
}


type Consumer struct {
    text *chan int
}

// consume reads the text channel
func (c *Consumer) consume() {
    fmt.Println("consumer start recieving message")
    for {
        message := <-*c.text
        fmt.Println("Message recieved by consumer", message)
    }
}

func main() {
    // profile flags
    cpuflag := flag.String("cpuflag", "", "update cpu profile to `file`")
    memflag := flag.String("memflag", "", "update memory profile to the `file`")

    // Get the max number from flag
    max := flag.Int("n", 4, "Show message count")

    flag.Parse()

    // To create the maximum number of cores in the processor
    runtime.GOMAXPROCS(runtime.NumCPU())

    // CPU Profile creation
    if *cpuflag != "" {
        f, err := os.Create(*cpuflag)
        if err != nil {
            log.Fatal("Enable to create CPU profile: ", err)
        }
        if err := pprof.StartCPUProfile(f); err != nil {
            log.Fatal("Enable to start CPU profile: ", err)
        }
        defer pprof.StopCPUProfile()
    }

    var text = make(chan int)  // channel send its messages
    var done = make(chan bool) // channel to intimate when production is done 

	//creating a Producer
    //Start a goroutine for Produce.produce
	producer := &Producer{text: &text, done: &done}
    go producer.produce(*max)

	//creating a Consumer
    //Start a goroutine for Consumer.consume
	consumer := &Consumer{text: &text}
	go consumer.consume()

    // End the program when the production is complete 
    <-done

    // Memory profile creation
    if *memflag != "" {
        f, err := os.Create(*memflag)
        if err != nil {
            log.Fatal("Enable to create memory id: ", err)
        }
        runtime.GC() // get update on status
        if err := pprof.WriteHeapProfile(f); err != nil {
            log.Fatal("Enable to write memory id: ", err)
        }
        f.Close()
    }
}