title: TLS handshake timeout on requesting data concurrently from api
body: <p>This is my first program in which I have used concurrency so I might be missing something fairly simple.</p>
  
  <pre><code>package main
  
  import(
      "net/http"
      "net/url"
      "log"
      "flag"
      "io/ioutil"
      "fmt"
      "golang.org/x/net/html"
      "strings"
      "encoding/json"
      "os"
      "html/template"
  )
  
  type fileInfo struct{
      Title string `json:"Title"`;
      Year string `json:"Year"`;
      Runtime string `json:"Runtime"`
      Genre string `json:"Genre"` 
      Rating string `json:"imdbRating"`;
      Description string `json:"Plot"`;
      Image string `json:"Poster"`;
      Awards string `json:"Awards"`;
  }
  
  var movie struct{
      Name string;
      Year string;
  }
  var Movies []fileInfo
  func main() {
      flag.Parse()
      files, _ := ioutil.ReadDir(flag.Args()[0])
      var queryNames []string
      for _, f := range files {
          go func(){
              queryNames= append(queryNames,url.QueryEscape(f.Name()))
          }()
      }
      //fmt.Println(os.Getenv("GOPATH") + "/src/github.com/krashcan/review/template/index.tpl")
      fmt.Println("Preparing data")
  
  
      for _, f := range queryNames {
          go GetTitleAndYear("https://opensubtitles.co/search?q=" + f)
      }
  
  
  
  
      fmt.Println("Done")
      http.HandleFunc("/",ShowRatings)
      http.Handle("/static/",http.StripPrefix("/static/",http.FileServer(http.Dir(os.Getenv("GOPATH") + "/src/github.com/krashcan/review/static"))))
  
      log.Fatal(http.ListenAndServe(":8080",nil))
  }
  
  func ShowRatings(w http.ResponseWriter,r *http.Request){
      t,err := template.ParseFiles(os.Getenv("GOPATH") + "/src/github.com/krashcan/review/template/index.tpl")
      if(err!=nil){
          log.Fatal(err)
      }
      t.Execute(w,Movies)
  }
  
  func GetTitleAndYear(url string){
      resp,err := http.Get(url)
      if err!=nil{
          log.Fatal(err)
      }
      var movieData string
      if resp.StatusCode != 200 {
          fmt.Println("statuscode",err)
      }
      z := html.NewTokenizer(resp.Body)
      for{
          tt := z.Next()
  
          if tt == html.ErrorToken{
              return
          }else if tt==html.StartTagToken{
              t:= z.Token()
              if t.Data=="h4"{
                  tt = z.Next()
                  tt = z.Next()
                  tt = z.Next()
                  t = z.Token()
                  movieData = strings.TrimSpace(t.Data)               
                  break
              }
          }
      }
  
      movie.Name = movieData[:len(movieData)-6]
      movie.Year = movieData[len(movieData)-5:len(movieData)-1]
      movie.Name = strings.Replace(movie.Name, " ", "+", -1)
      url = "http://www.omdbapi.com/?t=" + movie.Name + "&amp;y=" + movie.Year + "&amp;plot=short&amp;r=json"  
      req,err := http.Get(url)
  
      if err!=nil{
          log.Fatal(err)
      }
      var x fileInfo
      jsonParser := json.NewDecoder(req.Body)
      if err := jsonParser.Decode(&amp;x); err != nil {
          log.Fatal("parsing config file", err)
      }
      Movies = append(Movies,x)
      fmt.Println(x.Title,x.Year)     
  }
  </code></pre>
  
  <p>This program ran perfectly for the first time. But after that it keeps on giving <code>net/http:TLS Handshake timeout</code> on random filenames. I am not sure what is causing this. What might be a possible solution? Also what exactly is this error? </p>
  
  <p>EDIT 2: To solve the racing problem in concurrency, I used channels but now my program is very very slow compared to before. My updated main function :</p>
  
  <pre><code>func main() {
      flag.Parse()
      files, _ := ioutil.ReadDir(flag.Args()[0])
      var queryNames []string
      for _, f := range files {
          queryNames= append(queryNames,url.QueryEscape(f.Name()))
      }
      //fmt.Println(os.Getenv("GOPATH") + "/src/github.com/krashcan/review/template/index.tpl")
      fmt.Println("Preparing data")
      ch := make(chan string)
      done := make(chan bool)
      go func(){
          for{
              name,more := &lt;-ch
              if more{
                  GetTitleAndYear("https://opensubtitles.co/search?q=" + name)
              }else{
                  done &lt;-true
              }
          }
      }()
  
      for i:=0;i&lt;len(queryNames);i++{
          ch &lt;- queryNames[i] 
      }
      &lt;- done
      fmt.Println("Preparation DONE")
      http.HandleFunc("/",ShowRatings)
      http.Handle("/static/",http.StripPrefix("/static/",http.FileServer(http.Dir(os.Getenv("GOPATH") + "/src/github.com/krashcan/review/static"))))
  
      log.Fatal(http.ListenAndServe(":8080",nil))
  }
  </code></pre>
  
  <p>Please suggest me a way to have the same speed as before but also avoid racing around problems.</p>
  
  <p>EDIT 1: I have added my complete program. There is no way to depict line no.s on stack overflow , I have used concurrency only in the main function. If you feel the need to advice me on my way of writing go programs, please do so, I am a beginner and I would love to do things right.</p>