Issue title: Misunderstanding about syncing tasks
 Issue body: I feel misunderstanding about syncing tasks. Could you make it clear?
There in the documention is said that returning a stream makes task asynchronous. That’s quite common. I understand. Therefore, if I don’t return a stream, task should be synchronous. Correct?
Then why the snipped bellow shows that “Finished” and 'here is the end’ messages printed out before debug log of gulp.src...?

```
'use strict';

var
  gulp = require('gulp'),
  jshint = require('gulp-jshint'),
  debug = require('gulp-debug'),
  gutil = require('gulp-util');

gulp.task('jshint', function () {
    gulp.src(['Gulpfile.js', 'public/js/**/*.js', '!./public/js/templates.js'])
        .pipe(debug({title: 'jshint 1'}))
        .pipe(jshint({
          quotmark: true
        }))
        .pipe(jshint.reporter('jshint-stylish'))
        .pipe(jshint.reporter('fail'));
    gutil.log('here is the end');
});
```

Output:

```
$ gulp jshint
[14:48:04] Using gulpfile c:\WebProj\EngMe\web\gulpfile.js
[14:48:04] Starting 'jshint'...
[14:48:04] here is the end
[14:48:04] Finished 'jshint' after 170 ms
[14:48:04] jshint 1 Gulpfile.js
[14:48:04] jshint 1 public\js\app.js
[14:48:04] jshint 1 public\js\main.js
[14:48:04] jshint 1 public\js\plugins.js
[14:48:05] jshint 1 4 items
```

 Comments: 
 Comment 0: @zhekaus If you won't return stream or won't call callback task won't know about end. Task will be finished in time when it was called, even with long operation. You just need to say when operations in task end.

``` js
gulp.task(name, function (done) {
  del('dist', done);
});
```

``` js
gulp.task(name, function () {
  return new Promise(function (resolve) {
    del('dist', resolve);
  });
});
```

``` js
gulp.task(name, function () {
  return gulp.src('src')
    .pipe(gulp.dest('dist'));
});
```

 Comment 1: Thank you so much!
You described her how to run tasks synchronously, didn’t you?
I’m asking that because this technique described in documentation as “Async task support” that makes me think about simultaneous running but not consecutive.

 Comment 2: @zhekaus Knowing when the task ends let you control async flow. Synchronously task will be if you will  use sync code. For example

``` js
// Sync task
gulp.task(name, function () {
  fs.readFileSync(filename);
})

// Async
gulp.task(name, function (done) {
  fs.readFile(filename, function () {
    done();
  });
})

// Still async, but you won't know when file will be loaded. Task will finished before.
gulp.task(name, function () {
  fs.readFile(filename, function () {});
})
```

 Comment 3: Sync tasks will be removed in 4.0, I suggest you always use `done` for an easier transition.
 Comment 4: @phated But what about returning streams and promises?
 Comment 5: @TrySound those are still supported as alternatives to `done` but `done` should be used will callback-style async tasks or sync tasks
 Comment 6: @phated Will gulp modify pipeline for error bubbling? Now I use this decision
```js
gulp.task(name, function (done) {
  return gulp.src()
    .pipe(uglify())
    .on('error', done)
    .pipe(gulp.dest())
})
```
{'source': 'GithubIssues', 'repo_name_with_owner': 'gulpjs/gulp', 'issue_id': 98148623, 'repo_stars': 32636.0}