并行(parallel)：
　　　　如下图所示,指在同一时刻，有多条指令在多个处理器上同时执行。

　　并发(concurrency)：
　　　　如下图所示,指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，通过cpu时间片轮转使多个进程快速交替的执行。

　　如下图所示:
　　　　并行是两个队列同时使用两台咖啡机(真正的多任务)
　　　　并发是两个队列交替使用一台咖啡机(假的多任务)

　　程序:
　　　　是指编译好的二进制文件，在磁盘上，不占用系统资源

　　进程:
　　　　是一个抽象的概念，与操作系统原理联系紧密。进程是活跃的程序，占用系统资源,在内存中执行。换句话说，程序运行起来，产生一个进程。

　　进程状态:
　　　　进程基本的状态有5种。分别为初始态，就绪态(等待CPU分配时间片)，运行态(占用CPU)，挂起态(等待除CPU以外的其它资源主动放弃CPU)与终止态。其中初始态为进程准备阶段，常与就绪态结合来看。

　　在使用进程 实现并发时会出现什么问题呢？
　　　　1>.系统开销比较大，占用资源比较多，开启进程数量比较少;
　　　　2>.在unix/linux系统下，还会产生"孤儿进程"和"僵尸进程”
　　　　　　孤儿进程:
　　　　　　　　父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。
　　　　　　僵尸进程:
　　　　　　　　进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。  

　　温馨提示:
　　　　在操作系统运行过程中，可以产生很多的进程。在unix/linux系统中，正常情况下，子进程是通过父进程fork创建的，子进程再创建新的进程。并且父进程永远无法预测子进程到底什么时候结束。 当一个进程完成它的工作终止之后，它的父进程需要调用系统调用取得子进程的终止状态。　　
　　　　Windows下的进程和Linux下的进程是不一样的，它比较懒惰，从来不执行任何东西，只是为线程提供执行环境。然后由线程负责执行包含在进程的地址空间中的代码。当创建一个进程的时候，操作系统会自动创建这个进程的第一个线程，成为主线程。

　　线程概念:
　　　　线程是轻量级的进程(light weight process),本质仍是进程(Linux下)

　　进程：
　　　　独立地址空间，拥有PCB(进程控制块) 

　　线程：
　　　　有独立的PCB(进程控制块)，但没有独立的地址空间(即和其所在的进程共享用户空间)

　　线程同步:
　　　　指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。
　　　　"同步"的目的，是为了避免数据混乱，解决与时间有关的错误。实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。因此，所有"多个控制流，共同操作一个共享资源"的情况，都需要同步。

　　常见锁的应用如下所示:
　　　　互斥量(mutex):
　　　　　　Linux中提供一把互斥锁mutex（也称之为互斥量）。每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。
　　　　　　资源还是共享的，线程间也还是竞争的，但通过"锁"就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。但应注意"同一时刻，只能有一个线程持有该锁"。
　　　　　　举个例子:
　　　　　　　　当A线程对某个全局变量加锁访问，B在访问前尝试加锁，拿不到锁，B阻塞。C线程不去加锁，而直接访问该全局变量，依然能够访问，但会出现数据混乱。
　　　　　　　　综上所述,互斥锁实质上是操作系统提供的一把"建议锁"(又称"协同锁")，建议程序中有多线程访问共享资源的时候使用该机制。但并没有强制限定。因此，即使有了mutex，如果有线程不按规则来访问数据，依然会造成数据混乱。

　　　　读写锁
　　　　　　与互斥量类似，但读写锁允许更高的并行性。其特性为：写独占，读共享。
　　　　　　读写锁状态：
　　　　　　　　特别强调：读写锁只有一把，但其具备两种状态,即读模式下加锁状态(读锁),写模式下加锁状态(写锁)。
　　　　　　读写锁特性：
　　　　　　　　读写锁是"写模式加锁"时,解锁前,所有对该锁加锁的线程都会被阻塞。
　　　　　　　　读写锁是"读模式加锁"时,如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
　　　　　　　　读写锁是"读模式加锁"时,既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高
　　　　　　温馨提示:
　　　　　　　　读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。
　　　　　　　　读写锁非常适合于对数据结构读的次数远大于写的情况。

　　进程:
　　　　是并发执行的程序在执行过程中分配和管理资源的基本单位。

　　线程:
　　　　是进程的一个执行单元，是比进程还要小的独立运行的基本单位。一个程序至少有一个进程，一个进程至少有一个线程。

　　进程和线程的主要区别如下:
　　　　根本区别：
　　　　　　进程是资源分配最小单位，线程是程序执行的最小单位。 计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配。每个进程都有相应的线程，在执行程序时，实际上是执行相应的一系列线程。
 
　　　　地址空间：
　　　　　　进程有自己独立的地址空间，每启动一个进程，系统都会为其分配地址空间，建立数据表来维护代码段、堆栈段和数据段；线程没有独立的地址空间，同一进程的线程共享本进程的地址空间。

　　　　资源拥有：
　　　　　　进程之间的资源是独立的；同一进程内的线程共享本进程的资源。

　　　　执行过程：
　　　　　　每个独立的进程程有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

　　　　调度单位:　　
　　　　　　线程是处理器调度的基本单位，但是进程不是。由于程序执行的过程其实是执行具体的线程，那么处理器处理的也是程序相应的线程，所以处理器调度的基本单位是线程。　　
　　　　　　Windows系统下，可以直接忽略进程的概念，只谈线程。因为线程是最小的执行单位，是被系统独立调度和分派的基本单位。而进程只是给线程提供执行环境。

　　　　系统开销： 　　　　　
　　　　　　进程执行开销大，线程执行开销小。

　　协程：
　　　　coroutine。也叫轻量级线程。
　　　　与传统的系统级线程和进程相比，协程最大的优势在于"轻量级"。可以轻松创建上万个而不会导致系统资源衰竭。而线程和进程通常很难超过1万个。这也是协程别称"轻量级线程"的原因。
　　　　一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。
  　　协程不是被操作系统内核所管理，而完全是由程序所控制(也就是在用户态执行),这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。
　　　　综上所述,我们可以总结说协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

  子程序调用:
　　　　或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。
　　　　协程在子程序内部是可中断的，然后转而执行别的子程序，在适当的时候再返回来接着执行。 
 
　　多数语言在语法层面并不直接支持协程，而是通过库的方式支持，但用库的方式支持的功能也并不完整，比如仅仅提供协程的创建、销毁与切换等能力。关于协程调度的实现理论上分为以下三类模型:
　　　　一对多:
　　　　　　即用户态中的多个协程对应内核态的一个线程。
　　　　　　如果在这样的轻量级线程中调用一个同步IO操作，比如网络通信、本地文件读写，都会阻塞其他的并发执行轻量级线程，从而无法真正达到轻量级线程本身期望达到的目标。
　　　　一对一:
　　　　　　即用户态中的一个协程对应内核态的一个线程。
　　　　　　虽然解决一对多的阻塞问题，但是本质上还是线程之间的切换。
　　　　多对多:
　　　　　　即用户态中的多个协程对应内核态的多个线程。
　　　　　　相比一对多方案解决了阻塞问题，现在的协程调度器都是使用类似的模型。

　　在协程中，调用一个任务就像调用一个函数一样，消耗的系统资源最少！但能达到进程、线程并发相同的效果。

　　在一次并发任务中，进程、线程、协程均可以实现。从系统资源消耗的角度出发来看，进程相当多，线程次之，协程最少。

　　Go在语言级别支持协程，叫goroutine。Go语言标准库提供的所有系统调用操作(包括所有同步IO操作)，都会出让CPU给其他goroutine。这让轻量级线程的切换管理不依赖于系统的线程和进程，也不需要依赖于CPU的核心数量。

　　有人把Go比作21世纪的C语言。第一是因为Go语言设计简单，第二，21世纪最重要的就是并行程序设计，而Go从语言层面就支持并发。同时，并发程序的内存管理有时候是非常复杂的，而Go语言提供了自动垃圾回收机制。

　　Go语言为并发编程而内置的上层API基于顺序通信进程模型CSP(communicating sequential processes)。这就意味着显式锁都是可以避免的，因为Go通过相对安全的通道发送和接受数据以实现同步，这大大地简化了并发程序的编写。

　　Go语言中的并发程序主要使用两种手段来实现。goroutine和channel。

　　温馨提示:
　　　　Goroutine早期调度算法:
　　　　　　早期Goroutine调度存在会频繁的加锁解锁，最好的情况就是那个线程创建的协程就由哪个线程执行;
　　　　　　早期的协程调度存在资源拷贝的弊端，频繁的在线程间切换会增加系统开销。
　　　　Goroutine新版调度器算法(MPG):
　　　　　　M：
　　　　　　　　os线程（即操作系统内核提供的线程）
　　　　　　G：
　　　　　　　　goroutine，其包含了调度一个协程所需要的堆栈以及instruction pointer（IP指令指针），以及其他一些重要的调度信息。
　　　　　　P：
　　　　　　　　M与P的中介，实现m:n 调度模型的关键，M必须拿到P才能对G进行调度，P其实限定了golang调度其的最大并发度。
　　　　　　　　P默认和CPU核数相等，可按需设置。
　　　　　　M要去抢占P,如果抢到了P然后去领取G，如果没有任务会从其它的P或者全局的任务队列获取G。　

　　Goroutine是Go语言并行设计的核心，有人称之为go程。 Goroutine从量级上看很像协程，它比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB)，当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。

　　一般情况下，一个普通计算机跑几十个线程就有点负载过大了，但是同样的机器却可以轻松地让成百上千个goroutine进行资源竞争。

package main

import (
    "fmt"
    "time"
)

func Task(start int, end int, desc string) {
    for index := start; index <= end; index += 2 {
        fmt.Printf("%s %d\n", desc, index)
        time.Sleep(1 * time.Second)
    }
}

func main() {
    /**
    创建Goroutine:
        只需在函数调⽤语句前添加Go关键字，就可创建并发执⾏单元。开发⼈员无需了解任何执⾏细节，调度器会自动将其安排到合适的系统线程上执行。
        在并发编程中，我们通常想将一个过程切分成几块，然后让每个goroutine各自负责一块工作，当一个程序启动时，主函数在一个单独的goroutine中运行，我们叫它main goroutine。新的goroutine会用go语句来创建。而go语言的并发设计，让我们很轻松就可以达成这一目的。
    
    Goroutine特性:
        为了避免类似孤儿进程的存在，如果main协程挂掉，所有协程都挂掉。
        换句话说,主goroutine退出后，其它的工作goroutine也会自动退出。
    */
    go Task(10, 30, "Task Func Say: index =")

    Task(11, 30, "Main Say: index =")
}

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    go func() {
        defer fmt.Println("Goroutine 666666")

        func() {
            defer fmt.Println("Goroutine 88888888")

            /**
            return、Goexit() 和 os.Exit()的区别:
                return:
                    一般用于函数的返回,只能结束当前所在的函数.
                Goexit():
                    一般用于协程的退出
                    具有击穿特性,能结束掉当前所在的Goroutine，无论存在几层函数调用
                os.Exit():
                    主动退出主Goroutine,换句话说，直接终止整个程序的运行。
            */
            runtime.Goexit() //终止当前Goroutine
            //return
            //os.Exit(100)
            fmt.Println("AAAA")
        }()

        fmt.Println("CCCCC")
    }()

    //我们的主Goroutine会运行15s,有充足时间使得上面的子Go程代码执行完毕哟~
    for index := 1; index <= 30; index += 2 {
        fmt.Printf("Main Say: index = %d\n", index)
        time.Sleep(1 * time.Second)
    }
}

　　博主推荐阅读:
　　　　https://www.cnblogs.com/yinzhengjie2020/p/12657206.html