Building a Concurrent Command-Line Application in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup

  4. Building a Concurrent Command-Line Application - Step 1: Creating the CLI Application - Step 2: Implementing the Concurrent Execution - Step 3: Reading Input from the User - Step 4: Writing Output to Files

  5. Conclusion

Introduction

In this tutorial, we will learn how to build a concurrent command-line application in Go. We will create a simple application that takes user input, executes multiple tasks concurrently, and writes the output to files. By the end of this tutorial, you will have a clear understanding of how to leverage Go’s concurrency features to build efficient command-line applications.

Prerequisites

To follow along with this tutorial, you should have the following prerequisites:

  • Basic understanding of Go programming language
  • Go installed on your system

Setup

Before we begin building the application, let’s set up the project structure and initialize a new Go module.

  1. Create a new directory for your project.

     $ mkdir concurrent-cli-app
 $ cd concurrent-cli-app

  2. Initialize a new Go module.

     $ go mod init github.com/your-username/concurrent-cli-app

    With the project set up, we can now start building our concurrent command-line application.

Building a Concurrent Command-Line Application

Step 1: Creating the CLI Application

First, we need to create the basic structure of our command-line application. Open your favorite text editor and create a new file main.go.

package main

import (
	"fmt"
	"os"
)

func main() {
	// TODO: Implement the CLI application logic
}

Inside the main function, we will implement the logic for our command-line interface.

Step 2: Implementing the Concurrent Execution

Next, we will implement concurrent execution using Goroutines and channels. Let’s define a function that performs a task concurrently.

func performTask(task string, result chan<- string) {
	// TODO: Implement the task logic
	// ...
	// Once the task is completed, send the result through the channel
	result <- "Task done: " + task
}

In the above function, performTask takes a task as input and a channel result to send the completed task result back to the main function.

Now, let’s modify the main function to create multiple concurrent tasks.

func main() {
	tasks := []string{"Task 1", "Task 2", "Task 3"}

	resultChannel := make(chan string)

	// Start Goroutines for each task
	for _, task := range tasks {
		go performTask(task, resultChannel)
	}

	// Receive the results from all the tasks
	for range tasks {
		fmt.Println(<-resultChannel)
	}
}

In the above code, we create multiple Goroutines, each handling one task concurrently. The results of the tasks are received from the resultChannel and printed to the console.

Step 3: Reading Input from the User

Let’s enhance our application by allowing the user to input the tasks from the command line. We will use the os package to read input from the user.

func readTasksFromUser() []string {
	var tasks []string

	fmt.Println("Enter tasks (press enter twice to finish):")

	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		task := scanner.Text()
		if task == "" {
			break
		}
		tasks = append(tasks, task)
	}

	return tasks
}

Now, let’s update the main function to use the readTasksFromUser function.

func main() {
	tasks := readTasksFromUser()

	resultChannel := make(chan string)

	// Start Goroutines for each task
	for _, task := range tasks {
		go performTask(task, resultChannel)
	}

	// Receive the results from all the tasks
	for range tasks {
		fmt.Println(<-resultChannel)
	}
}

Step 4: Writing Output to Files

Lastly, let’s modify the performTask function to write the task results to separate files instead of printing them to the console.

func performTask(task string, result chan<- string) {
	// TODO: Implement the task logic, e.g., compute the result string

	// Create a new file for each task
	fileName := task + ".txt"
	file, err := os.Create(fileName)
	if err != nil {
		result <- "Error creating file for task: " + task
		return
	}
	defer file.Close()

	// Write the result to the file
	_, err = file.WriteString("Task done: " + task)
	if err != nil {
		result <- "Error writing to file for task: " + task
		return
	}

	result <- "Task done: " + task
}

The updated performTask function creates a new file for each task and writes the result string to the file.

Now, when you run the application, the task results will be written to separate files instead of being printed to the console.

Conclusion

In this tutorial, we learned how to build a concurrent command-line application in Go. We covered the basics of Goroutines, channels, and how to leverage concurrency to execute tasks in parallel. We also enhanced our application by allowing user input and writing the task results to separate files. With the knowledge gained from this tutorial, you can now build your own efficient and concurrent command-line applications in Go.

Remember to experiment and explore more Go features to further enhance your applications. Happy coding!

Published:

Related Articles