与传统语言不同，Go是为并发而设计的语言，它在语言层次上提供了对并发编程的大量支持。

修改多个Goroutine同时访问的数据时，必须串行化访问，方法有两种：

1. 通过通道操作
2. 使用sync、sync/atomic包提供的同步原语

在不改变语义的前提下，编译期和处理器可能对读写操作进行重新排序。由于重新排序的存在，不同Goroutine看到的执行顺序可能不同。

在多Goroutine访问共享变量的情况下，必须使用同步机制，确保读操作能看到期望的（happens before的）写。

Go应用初始化时只有一个Goroutine，它能够创建更多的Goroutine，这些Goroutine会并发的运行。

如果包p导入了包q，则q的init函数的执行完毕，发生在任何p的init函数之前。

go语句的执行，发送在Goroutine主体逻辑执行之前。

Goroutine的销毁不保证发生在任何事件之前。

向一个通道发送数据，发生在接收数据之前：

var c = make(chan int, 10)
var a string

func f() {
	a = "hello, world"
	c <- 0
}

func main() {
	go f()
	<-c
	print(a)
}

上面的例子会确保一定能打印hello, world。 

Goroutine是由Go运行时管理的轻量级线程，不依赖于操作系统级别的线程机制。

下面是Goroutine简单的例子：

func worker(name string) {
    for i := 0; i < 2; {
        time.Sleep(time.Second)
        fmt.Println("%v-%v", name, i)
        i++
    }
}
func main() {
    // 使用go关键字，后面跟着一个函数调用，即可发动一个Goroutine
    go worker("W")
    worker("M")
}

Goroutine和程序主体部分在同一地址空间运行，因此它们共享变量时必须进行同步。sync包提供了相关的同步原语。

Go运行时为Goroutine实现线程的多路复用 —— 如果某个Goroutine阻塞（例如调用了某个阻塞性的系统调用），则运行时自动将阻塞Goroutine所在的OS线程上分配的其余Goroutine转移到其它Runnable的OS线程上。

每个Goroutine都需要栈资源，Go运行时支持动态栈大小，新创建的Goroutine的栈大小为几个KB，并根据需要进行扩展/收缩。这种动态栈大小让Goroutine平均资源消耗很小，在单台机器上创建10万级别的Goroutine很常见，但是创建相同数量的OS线程，负担要大得多。

Goroutine的调度模型由Go运行时实现。调度模型发生过一次较大的重构。

G-M-P调度模型从Go 1.2版本引入，并沿用至今。在此模型中，有三个重要的角色：

1. G：对应Go语言中的Goroutine，运行时需要维护每个Goroutine的执行栈、执行状态等信息
2. P：逻辑处理器，每个逻辑处理器对应一个局部运行队列，G可以在其上排队等候执行。P决定了Go程序中可以并行执行的Goroutine的数量（当然不能超过物理CPU的核心数）。对于G来说，P就是运行它的CPU
3. M：对应操作系统线程。M不保存任何G的信息，这让G跨M调度成为可能

P必须绑定到M（逻辑处理器必须绑定到OS线程）才能让本地运行队列中的G有机会运行。当P绑定到M后会执行调度循环，调度循环会：

1. 从P的本地运行队列中获取可运行的G
2. 切换到G的执行栈
3. 执行G的函数

如果G中执行了死循环，那么G将永远占据对应的P和M。这样会导致相同P中的其它G没有机会执行，更严重的是，如果只有一个P的情况下，程序中所有其它G都会被饿死。

为了解决上面的问题，Go 1.2引入抢占式调度。Go会在每个函数的入口都添加一段额外的代码，以保证Go运行时有机会检查，并执行抢占式调度。这种抢占式调度只能解决部分问题，对于没有任何函数调用的单纯死循环仍然无能为力。

Go程序启动时，运行时会创建一个名为sysmon的M（监控线程），此M不需要绑定P即可运行。sysmon每隔20us~10ms就会运行并执行对长时间运行的G发起抢占调度：

1. 设置G的抢占标识位为true
2. 当G下一次调用任何函数时，Go运行时即执行抢占
3. G被放入P的本地运行队列，等待下一次调度

Go的理念是，基于阻塞性的接口编程，并使用Goroutine和Channel处理并发，而不是使用回调或者Future。对于Goroutine而言，所有IO操作都是阻塞性的。但是，大部分IO操作都不会导致M阻塞，这避免了大量创建操作系统线程。

Go运行时实现了netpoller，它将操作系统提供的异步网络IO转换为Go中的阻塞性IO，这一方面防止M被阻塞，另一方面保持了Go语言内部的阻塞性接口风格。

当G在通道操作或者网络IO上阻塞时，运行时调度器将其放入某个等待队列，M会尝试执行下一个可运行的G。如果没有可运行的G则M和P解绑并进入休眠状态。

当通道操作完成或者网络IO可用时，等待队列中的G被唤醒，标记为可运行并放入到某个P的本地运行队列中，绑定M并执行。

对于普通文件（Non-Pollable）的IO操作会导致M阻塞，等待IO操作完成后被操作系统唤醒。这种情况下，P会和M分离，寻求其它的M进行绑定，如果没有空闲的M则会创建新的M。这意味着大量的IO可能导致很多操作系统线程被创建。

发生任何其它阻塞性系统调用时，Go运行时的调度逻辑类似。

Go运行时会在逻辑处理器P上调度Goroutine，每个P会绑定一个操作系统线程M。每个P上可能有多个Goroutine等待被执行，这些Goroutine形成的队列被叫做本地运行队列。

新创建的Goroutine会被放置到一个全局运行队列中，Go运行时的调度器会进行调度，把Goroutine分配给某个P。

调用

runtime.GOMAXPROCS(1)

runtime.GOMAXPROCS(runtime.NumCPU())

GOMAXPROCS最大可以设置到256。

设置环境变量GODEBUG可以查看运行时调度器的状态，例如设置

GODEBUG=schedtrace=1000

SCHED 10ms: gomaxprocs=8 idleprocs=6 threads=4 spinningthreads=1 idlethreads=1 runqueue=0 [1 0 0 0 0 0 0 0]

# SCHED，固定前缀，表示这一行调试信息由运行时调度器打印
# 10ms，从程序启动到打印信息经过的时间
# gomaxprocs 最大P数量
# idleprocs 空闲的P数量
# threads 操作系统线程数量
# spinningthreads 正在自旋的操作系统线程数量
# idlethread 空闲的操作系统线程数量
# runqueue 全局运行队列中G的数量
# [1 0 0 0 0 0 0 0] 各P的本地队列中G的数量

设置环境变量

GODEBUG=schedtrace=1000,scheddetail=1

应用程序退出时，不会等待Goroutine执行完毕，而是会立即退出。解决办法包括：

1. 使用WaitGroup，让主Goroutine等待Worker Goroutine完成
2. 如果Worker是长期运行的消息处理循环，应当从主Goroutine向其发送信号，导致其退出。最常见的用法是stop chan

基于通信来共享内存，而不是基于共享内存进行通信 —— Share memory by communicating; don't communicate by sharing memory。

Goroutine和Channel受到CSP并发模型（Communicating Sequential Processes）的启发。在CSP中，多个Process使用Channel进行通信，并且这种通信通常是同步式的。

Go语言中的通道是一种强类型的管道，你可以使用通道操作符

<-

// 类似于切片，你需要先创建才能使用通道
ch := make(chan int)

ch <- v      // 将值v发送到通道ch
v := <-ch    // 从ch接收数据并赋值给v

下面是两个Goroutine通过Channel进行通信的例子：

func receiver(ch chan int8) {
    for val := range ch {
        fmt.Printf("Received value: %v\n", val)
    }
}
func sender(ch chan int8) {
    for i := 0; i < 3; i++ {
        ch <- int8(i)
        time.Sleep(time.Second)
    }
    close(ch)
}
func main() {
    ch := make(chan int8)
    go sender(ch)
    go receiver(ch)
    time.Sleep(time.Second * 5)
}

Goroutine可能会永久的阻塞在通道上，对于发送者来说，只要接收方没有响应，就会发生这种情况。

考虑下面的例子：

func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

此函数从一系列replicas中返回第一个replica(query)调用的结果。除了第一个执行完毕的Goroutine之外，其它的都会阻塞，原因是主Goroutine仅仅从通道获取一个数据后就退出了。

解决此问题的方法有多种：

1. 使用具有足够大缓冲的通道：

   c := make(chan Result,len(replicas))

2. 使用带有default的select：
   

   searchReplica := func(i int) {
       select {
       case c <- replicas[i](query):
       // 如果通道c不可写，则执行下面的分支
       default:
       }
   } 

3. 使用一个“取消”通道：
   

   done := make(chan struct{})
   // 外层函数退出时，通道被关闭
   defer close(done)
   
   searchReplica := func(i int) {
       select {
       case c <- replicas[i](query):
       // 那时任何协程都可以读取通道并退出
       case <- done:
       }
   } 

默认情况下，通过通道发送、接收数据都会阻塞，直到通道的另外一端响应。 这样，Goroutine不需要明确的锁定或者条件变量即可同步。

你可以创建具有缓冲区的通道 —— 发送操作仅仅在缓冲区满的情况下阻塞，接收操作仅仅在缓冲区为空的情况下阻塞：

// 第二个参数为缓冲区大小
ch := make(chan int, 100)

你可以调用

close(chan)

// 如果通道没有更多的值可以接收，并且已经针对通道调用过close，则ok = false
v, ok := <-ch

注意：

1. 仅仅应当由发送者关闭通道，而不是消费者。如果尝试向已经关闭的通道发送数据，会导致Panic
2. 通道不同于文件，通常你不需要显式关闭通道。除非你需要显式的告知接收者（例如提示其结束for...range循环）
3. 从已经关闭的通道接收是安全的，第二返回值将为false

for i := range c

func fibonacci(n int, c chan uint64) {
    x, y := uint64(0), uint64(1)
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan uint64, 50)
    go fibonacci(cap(c), c)
    for i := range c {
        fmt.Printf("%v ", i)
    }
}

多个Goroutine同时遍历单个通道是允许的，不会出现竞态条件。但是要注意：

1. 尽量使用参数在Goroutine之间传递chan，而不是使用全局变量
2. 对于单个Goroutine来说，不要又读又写，容易死锁
3. 如果使用不带缓冲的Chan不会出现死锁，那么使用带缓冲的Chan也不会出现死锁。反之不成立。可以先使用不带缓冲的Chan，当需要性能提升时，增加缓冲

Go中的通道是一等公民，可以像其它值一样被传来传去。甚至，你可以通过通道来传递另外一个通道。下面是一个远程计算服务的例子：

// 远程计算请求
type Request struct {
    // 计算参数
    args []int
    // 计算逻辑
    f func([]int) int
    // 处理结果返回的通道
    resultChan chan int
}

// 客户端
func Client(queue chan *Request) {

    request := &Request{[]int{1, 2, 3, 4, 5}, func(a []int) (s int) {
        for _, v := range a {
            s += v
        }
        return
    }, make(chan int)}
    queue <- request
    fmt.Printf("Result from server: %v", <-request.resultChan)
}

// 远程计算服务
func Server(queue chan *Request) {
    for req := range queue {
        req.resultChan <- req.f(req.args)
    }
}
func main() {
    queue := make(chan *Request)
    go Server(queue)
    go Client(queue)
    time.Sleep(time.Second)
}

 可以看到，客户端通过通道发送请求，请求对象中包含了一个通道，服务器向此通道发送计算结果。

在零值通道上发送、接收都会永久阻塞。

var send chan<- int      // 在chan关键字后侧加<-表示仅仅能发送
var receive <-chan int   // 在chan关键字左侧加<-表示仅仅能接收

// 单向通道常常用于函数或方法的参数中
func counter(out chan<- int) {
}

select...case语句允许Goroutine在多个通信操作符上等待，当至少有一个操作符（可以在default分支中立即退出）准备好（可读或可写），Select才从阻塞中恢复。如果同时有多个操作符准备好，Select会随机执行其中一个分支： 

func fibonacci(c chan uint64, quit chan bool) {
    x, y := uint64(0), uint64(1)
    for {
        select {
        // 发送端
        case c <- x:
            x, y = y, x+y
            // 这里的break用于终止case执行，如果要跳出for，可以使用标签或者goto
            break
        // 接收端，注意接收数据后可不赋值给任何变量
        case <-quit:
            fmt.Println("Quit signaled")
            return
        // 如果没有任何case满足条件，则执行default
        default:
            // 可以在此休眠，执行阻塞性收发，等等
        }
    }
}

func main() {
    c := make(chan uint64)
    q := make(chan bool)
    go fibonacci(c, q)
    // 从匿名函数启动Groutine
    go func() {
        for i := 0; i < 50; i++ {
            fmt.Println(<-c)
        }
        q <- true
    }()
    time.Sleep(time.Second)
}

下面是Istio代码中的一个示例：

select {
case client.pushChannel <- &XdsEvent{}:
    // 意味着推送通道可用，事件推送成功
case <-client.doneChannel:
    // 意味着客户端已经关闭连接
case <-time.After(PushTimeout):
    // 意味着在超时之前，推送通道不可用，客户端也没关闭。可能是网络慢卡住了
}

感受一下，用非常简洁的代码就把正常、异常情况处理好了。 

// Ticker会定期向通道写入数据
tickChan := time.NewTicker(c.flaggerWindow).C
for {
	select {
        // 定期触发这个case
	case <-tickChan:
		c.scheduleCanaries()
	case <-stopCh:
		return nil
	}
}

c := make(chan int)  // 分配一个通道
// 在Go程中启动排序。当它完成后，在通道上发送信号
go func() {
	list.Sort()
	c <- 1  // 发送信号，什么值无所谓
}()
doSomethingForAWhile()
<-c   // 等待排序结束，丢弃发来的值

还有缓冲的通道可以作为信号量使用：

var sem = make(chan int, MaxOutstanding)

func handle(r *Request) {
	sem <- 1 // 等待活动队列清空。
	process(r)  // 可能需要很长时间
	<-sem    // 完成；使下一个请求可以运行
}

func Serve(queue chan *Request) {
	for {
		req := <-queue
		go handle(req)
	}
} 

通道是跨Goroutine通信的利器，但是某些时候Goroutine之间不需要传递数据，我们只需要保证在任何时刻，仅仅它们其中的一个能够访问（同步）某项资源以避免冲突，这时你可以使用互斥量。

发生Goroutine之间的竞态条件和传统的基于线程的语言类似：

var count uint32 = 0
var wg sync.WaitGroup

func inc() {
    defer wg.Done()
    count++     // 非原子操作
}
func main() {
    const N = 500
    wg.Add(N)
    for i := 0; i < N; i++ {
        go inc()
    }
    wg.Wait()
    fmt.Printf("Expected: %v, Actual: %v", N, count) // Expected: 500, Actual: 488
}

运行上段程序，可以看到计数器的结果不符合预期，每次都会不一样。这是由于对共享变量count的++操作不是原子操作，不受保护的访问会导致写覆盖。

现实中的例子要复杂的多，可能很难察觉到问题。你可以为go build 传入 --race参数，这样，在运行代码时，Go会自动检测竞态条件：

==================
WARNING: DATA RACE
Read at 0x0000005bddb0 by goroutine 7:
  main.inc()
      /home/alex/Go/projects/go-study/application.go:13 +0x69

Previous write at 0x0000005bddb0 by goroutine 6:
  main.inc()
      /home/alex/Go/projects/go-study/application.go:13 +0x83

Goroutine 7 (running) created at:
  main.main()
      /home/alex/Go/projects/go-study/application.go:19 +0x6e

Goroutine 6 (finished) created at:
  main.main()
      /home/alex/Go/projects/go-study/application.go:19 +0x6e
==================
Found 1 data race(s)

 Go标准库中定义的

sync.Mutex

type Locker interface {
    // 调用此方法可以锁定共享资源
    Lock()
    // 调用此方法可以解除对共享资源的锁定
    Unlock()
}

使用互斥锁来改造上面的计数器代码：

var lock sync.Mutex

func inc() {
    defer wg.Done()
    defer lock.Unlock()
    lock.Lock()
    count++
}

即可同步化对共享变量count的访问。下面是另外一个使用互斥锁的例子：

import (
    "fmt"
    "sync"
    "time"
)

// 并发安全的计数器
type SafeCounter struct {
    v map[string]int
    // 锁
    mux sync.Mutex
}

//  为某个键进行计数
func (c *SafeCounter) Inc(key string) {
    // 在进行不安全操作前后进行加锁、解锁
    c.mux.Lock()
    c.v[key]++
    c.mux.Unlock()
}

func (c *SafeCounter) Value(key string) int {
    c.mux.Lock()
    // 可以使用defer，确保此方法退出时会执行解锁
    defer c.mux.Unlock()
    return c.v[key]
}

func main() {
    c := SafeCounter{v: make(map[string]int)}
    const key = "default-counter"
    for i := 0; i < 10000000; i++ {
        go c.Inc(key)
    }

    time.Sleep(time.Second)
    fmt.Println(c.Value(key))
} 

互斥锁要求所有访问共享资源的Goroutine串行化执行，因此性能较差。在读多写少的情况下，使用读写锁可以提升性能，读写锁的特点是：

1. 读锁不排斥其它的读锁，但是排除任何写锁
2. 写锁排除任何锁

var rw sync.RWMutex

// 加读锁
rw.RLock()
// 解读锁
rw.RUnlock()

// 加写锁
rw.Lock()
// 解写锁
rw.Unlock()

在Go语言中，唯一被保证是原子性的，就是sync.atomic中定义的那些操作。也就是说，哪怕是简单的赋值，也需要保护：

clearCacheMutex.Lock()
clearCacheTimerSet = false
clearCacheMutex.Unlock()

使用互斥量是最常见的保证原子性的方法，sync.atomic包相对不常用。

此包提供了很多低级的原子性内存访问原语，可以用于实现同步算法。 使用此包时要想当小心，推荐优先基于通道或者锁实现同步。

func AddInt32(addr *int32, delta int32) (new int32)

CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

lock := int32(0)
// 如果旧值和新值不同，则原子的设置为新值
if atomic.CompareAndSwapInt32(&lock, 0, 1) {
    fmt.Printf("Locked: %v", lock) // Locked: 1
}

等待组类似于Java的CountdownLatch：

var wg sync.WaitGroup
const N = 100
wg.Add(N) // 需要N次Done调用才能解除Wait()
for i := 0; i < N; i++ {
    go func() {
        wg.Done()
        wg.Wait()  // 等待所有协作者完成
    }()
}
wg.Done()
wg.Wait()  // 等待所有协作者完成

注意：传递WaitGroup时应当传递其指针。

使用Context可以方便的控制多个相互协作的Goroutine，下面是一个简单的例子：

import (
    "context"
    "log"
    "math/rand"
    "time"
)

func main() {
    // 使用空白上下文为根，产生一个子上下文
    // 当返回的cancel函数被调用后，子上下文的Done通道自动关闭
    ctx, cancel := context.WithCancel(context.Background())

    for i := 0; i < 5; i++ {
        go genRandNum(ctx)
    }
    // 让Goroutine工作一会儿
    time.Sleep(time.Second * 3)
    cancel() // 发出取消上下文的信号
    time.Sleep(time.Second * 3)
}
func genRandNum(ctx context.Context) {
    for {
        select {
        // 检测上下文是否取消
        case <-ctx.Done():
            // 如果上下文已经取消，则退出Goroutine
            log.Println("Stop random number generation.")
            return
        default:
            // 如果上下文尚未取消，则产生随机数
            log.Printf("Generated number: %v", rand.Int())
            time.Sleep(time.Second)
        }
    }
}

context.WithCancel()、context.WithTimeout()调用返回的第二个值，即cancel()函数，其作用是触发ctx.Done()通道可读（关闭）。

Context接口定义了四个方法：

type Context interface {
    // 返回设置的最后期限，如果没有设置最后期限，第二个返回参数为false
    Deadline() (deadline time.Time, ok bool)
    // 返回一个只读的通道，如果此通道可读取，则意味着父Context已经发起了取消请求
    // 从该通道读取到东西后，当前Goroutine应该进行资源清理并退出
    Done() <-chan struct{}
    // 返回上下文被取消的原因
    Err() error
    // 返回上下文上绑定的属性
    Value(key interface{}) interface{}
}

内置的实现包括：

var (
    background = new(emptyCtx)
    todo       = new(emptyCtx)
)
func Background() Context {
    return background
}
func TODO() Context {
    return todo
}

background、todo都是emptyCtx类型，这是一个不可取消、没有设置最后期限、没有绑定任何属性的Context。

context.Background()通常在main函数中用于根Context。 

emptyCtx不能做任何事情，我们通常将其作为根Context，并利用下面的函数来构建上下文树：

// 产生一个子上下文和取消函数，调用函数可以取消上下文
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
// 产生一个子上下文，在到达最后期限时，会自动取消，也可以手工取消
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
// 类似上面
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
// 通过上下文共享数据
func WithValue(parent Context, key, val interface{}) Context

注意：调用取消函数会导致当前上下文以及任何后代上下文被取消，也就是Done()关闭

1. 以参数的方式传递Context，并且不会将其包装在结构中
2. Context作为第一个参数
3. 不要传递nil Context
4. 避免通过Context传递不必要的数据
5. Context可以跨Goroutine安全访问

调度器会在GC、go语句、阻塞channel操作、阻塞系统调用和lock操作后运行。它也会在非内联函数调用后执行。

你也可以显式的唤起调度器：

for !done {
    runtime.Gosched()
}

但是一个空循环，就可以阻止调度器运作。 

使用Go语言实现一个线程池是很简单的。下面分析Istio源码中包含的线程池的例子。

package pool

import (
	"sync"
)

// 代表工作协程需要执行的函数
type WorkFunc func(param interface{})

// 协程池结构，持有一组可重用的协程，工作函数可以调度到协程上
type GoroutinePool struct {
	queue          chan work      // 工作队列，缓冲通道
	wg             sync.WaitGroup // 用于在所有工作完成之前阻止shutdown操作
	singleThreaded bool           // 提示是否运行在单线程模式
}

// 放入队列的工作，即工作函数+参数
type work struct {
	fn    WorkFunc
	param interface{}
}

// 创建新的协程池
func NewGoroutinePool(queueDepth int, singleThreaded bool) *GoroutinePool {
	gp := &GoroutinePool{
		queue:          make(chan work, queueDepth), // 队列深度即通道缓冲大小
		singleThreaded: singleThreaded,
	}
// 至少添加一个工作协程
	gp.AddWorkers(1)
	return gp
}

// 协程池实现io.Closer接口。在关闭时，必须在等待组上等待 —— 等待所有工作协程退出
func (gp *GoroutinePool) Close() error {
	if !gp.singleThreaded {
// 关闭通道
		close(gp.queue)
// 等待
		gp.wg.Wait()
	}
	return nil
}

// 调度一份工作，在未来执行
// 调用者必须确保，工作函数仅仅依赖于通过params传递的“外部数据” —— 要保证这一点，你可以
// 传递一个普通命名函数给此方法，而不是一个内联的匿名函数（容易形成闭包）
func (gp *GoroutinePool) ScheduleWork(fn WorkFunc, param interface{}) {
	if gp.singleThreaded {
// 单线程模式下，执行运行
		fn(param)
	} else {
// 否则，写入到通道。如果通道满了，可能会导致调用者阻塞
		gp.queue <- work{fn: fn, param: param}
	}
}

// 添加工作协程到池中，增加并行度
func (gp *GoroutinePool) AddWorkers(numWorkers int) {
	if !gp.singleThreaded {
// 增加需要等待的数量
		gp.wg.Add(numWorkers)
		for i := 0; i < numWorkers; i++ {
// 工作协程的工作循环
			go func() {
// 取出一个工作并执行
				for work := range gp.queue {
					work.fn(work.param)
				}
// 如果通道关闭，则减少等待组计数。所有协程都执行到这一步后，Close()调用才能从阻塞中返回
				gp.wg.Done()
			}()
		}
	}
}

package pool

import (
	"sync"
	"testing"
)

func TestWorkerPool(t *testing.T) {
	const numWorkers = 123
	const numWorkItems = 456

	parameterMismatch := false

	for i := 0; i < 2; i++ {
		gp := NewGoroutinePool(128, i == 0)
		gp.AddWorkers(numWorkers)

		wg := &sync.WaitGroup{}
		wg.Add(numWorkItems)

		for i := 0; i < numWorkItems; i++ {
			passedParam := i // 在栈上捕获变量，避免创建闭包
			gp.ScheduleWork(func(param interface{}) { // 调度
				paramI := param.(int)
				if paramI != passedParam {
					parameterMismatch = true
				}
				wg.Done()
			}, passedParam)
		}

		// 等待所有工作执行完毕
		wg.Wait()

		if parameterMismatch {
			t.Fatal("Passed parameter was not as expected")
		}

		// 关闭池
		_ = gp.Close()
	}
}

The post Go语言并发编程 appeared first on 绿色记忆.

一个运行的程序称作进程。每个进程都有自己的系统状态，包括内存、已打开文件列表、用于跟踪正在执行的指令的程序计数器以及用于保存函数的局部变量的调用栈。通常在一个控制流序列中， 进程逐条执行语句，这一般称为进程的主线程。在任何一个给定的时刻，程序都只做一件事情。 程序可以使用库函数创建新的进程，比如os或subprocess模块中的函数（例如os.fork()、 subprocess.Popen等)。这些叫做子进程的进程是作为完全独立的实体运行的。 每个子进程都有自己的私有系统状态和执行主线程。因为子进程是独立的，所以它可以与原始进程并发执行。也就是说，创建子进程的进程可以继续处理别的事情，同时子进程在后台执行它自己的任务。

尽管进程是孤立的，但它们可以彼此通信，这称为进程间通信（Interprocess Communication, IPC)。 进程间通信的最常见形式是基于消息传递。一条消息就是一块原始字节的缓存。然后，就可以使用像 send()和recv()这样的简单操作，通过一个I/O通道（如管道或网络套接字）来传输或接收消息。另一种不太常见的IPC机制依赖于内存映射区域（参见nmap模块)。借助内存映射，进程可以创建共享的内存区域。如果对这些内存区域进行修改，那么査看这些区域的所有进程都能看到这些修改。 如果需要同时处理多个任务，可以在一个应用程序内使用多个进程，每个进程负责处理一部分工 作。

另一种将工作细分为多个任务的方法是使用线程。线程类似于进程，也具有自己的控制流和执行栈。但线程运行在创建它的进程内部，它们共享所有的数据和系统资源。当应用程序需要并发执行多个任务时，可以使用线程，但可能存在大量需要在各个任务之间共享的系统状态。

使用多个进程或线程时，主机操作系统负责安排它们的工作。安排的具体做法是：给每个进程（线程）分配一个小的时间片，并在所有活动任务之间快速循环——给每个任务分配一部分可用的CPU周期。例如，如果系统同时运行10个活动的进程，操作系统将给每个进程分配大约1/10的CPU时间，同时在进程之间快速循环。在具有多个CPU核心的系统上，操作系统在安排进程时可以尽可能使用每个 CPU，从而并行执行进程。 编写使用并发执行的程序原本就很复杂，其复杂性的一个主要原因就是同步和访问共享数据。也就是说，多个任务同时更新一个数据结构可能导致数据损坏和程序状态不一致（这个问题的正式说法是竞争条件）。要解决这些问题，并发程序必须找出关键的代码段，并使用互斥锁和其他类似的同步手段保护它们。例如，如果不同的线程尝试同时向一个文件写入数据，可以使用互斥锁来同步它们的

在大多数系统上，Python同时支持消息传递和基于线程的并发编程。Python线程受到的限制有很多，Python解释器使用了内部的GIL (Global Interpreter Lock，全局解释器锁定），在任意指定的时刻只允许单个 Python线程执行。无论系统上存在多少个可用的CPU核心，这限制了 Python程序只能在一个处理器上 运行。如果一个应用程序的大部分是I/O受限（bounded）的，那么使用线程一般没有问题，因为额外的处理器对于花费大多数时间等待事件的程序帮助不大。对于涉及大量CPU处理的应用程序而言，使用线程来细分工作没有任何好处，反而还会降低程序的运行速度。

避免大量使用线程的较为常见的做法是把这类应用程序重新构造为异步事件处理系统。例如，中心的事件循环可以监控使用select模块的所有I/O,并将异步事件分离给大量I/O 处理器。这是诸如asyncore这样的库模块和诸如Twisted等流行的第三方模块的基础。

如果要在Python中进行各种类型的并发编程，消息传递很可能是必须熟练掌握的概念。 即便使用线程，常推荐的方法也是将应用程序的结构设计为大量独立的线程集合，这些线程通过消息队列交换数据。这种特别的方法往往很少出错，因为它极大地减少了对使用锁定和其他同步手段的需求。消息传递还会自然扩展到网络和分布式系统中。消息传递的抽象也与髙级Python功能（如协程）有关。例如，协程是可以接收并处 理发送给它的消息的函数。因此，掌握了消息传递之后，写出的程序会较之前更灵活。

该模块为在子进程中运行任务、通信和共享数据，以及执行各种形式的同步提供支持。接口风格与threading模块类似，但要注意进程之间没有任何共享状态。

1. 确保进程之间传递的所有数据都能够序列化
2. 避免使用共享数据，尽可能使用消息传递和队列。使用消息传递时，不必过于担心同步、锁定和其他问题。当进程的数量增长时，它往往还能提供更好的扩展
3. 在必须行在单独进程中的函数内部，不要使用全局变量而应当显式地传递参数
4. 尽量不要在同一个程序中混合使用线程和多线程处理
5. 特別要注意关闭进程的方式。一般而言，需要显式地关闭进程，并使用一种定义良好的终止模式，而不要仅仅依赖于垃圾收集或者被迫使用terminate ()操作强制终止子进程
6. 管理器和代理的使用与分布式计算中的多个概念密切相关（例如，分布式对象)
7. 尽管此模块可以工作在Windows上，但还是应该仔细阅读官方文档中的各种微妙细节
8. 最重要的一点是：尽量让事情变得简单

进程是multiprocessing模块的核心，其构造函数如下：

Process([group [, target [, name [, args [, kwargs ]]]]])
# group 预留参数
# target 进程启动时需要执行的可调用对象
# name  进程名称的描述性字符串
# args 传递给target的位置参数的元组
# kwargs 传递个target的关键字参数的字典

Process具有以下实例方法、属性：

简单的例子：

import multiprocessing
import time
def clock(interval):
    while True:
        print "Current time is %s" % time.ctime()
        time.sleep(interval)
if __name__ == '__main__':
    p = multiprocessing.Process(
        target=clock,
        args=(15,)
    )
    p.start()

#使用扩展子类的方式
class ClockProcess(multiprocessing.Process):
    def __init__(self,interval):
        multiprocessing.Process.__init__(self)
        self.interval = interval
    def run(self):
        while True:
            print "Current time is %s" % time.ctime()
            time.sleep(self.interval)

multiprocessing模块支持进程间通信的两种主要形式：管道和队列，这两种方法都是使用消息传递实现的。

使用Queue([maxsize])可以创建队列，maxsize是队列中允许的最大项数，省略表示无穷大，具有以下实例方法：

使用JoinableQueue([maxsize])可以创建可连接的共享队列，允许消费者通知生产者消息项已经被成功处理，具有额外的方法：

使用队列通信的例子：

import multiprocessing
def consumer(inputq):
    while True:
        item = inputq.get()
        if item == -1: break    #特殊标记时终止
        print item
        inputq.task_done()
def produce(seq, outputq):
    for item in seq:
        outputq.put(item)
if __name__ == '__main__':
    q = multiprocessing.JoinableQueue()
    cons_p = multiprocessing.Process(target=consumer, args=(q,))
    cons_p.daemon = True
    cons_p.start()
    #这里可以继续创建多个消费者进程，但是每个消息只能被一个进程消费
    seq = [0, 1, 2, 3, 4 , -1]  #特殊标记，提示消费者流程结束
    produce(seq, q)
    q.join()  # 当前进程等待队列被消耗完毕

可以在进程之间创建一根管道：

#创建管道的函数：duplex表示是否双向通信，默认True
#如果duplex=False，那么conn1只能接收，conn2只能发送
(conn1,conn2) = Pipe([duplex])

Pipe函数的返回值为Connection对象的元组，Connection对象具有以下属性和方法：

如果生产者或消费者中都没有使用管道的某个端点，就应将其关闭。如果忘记执行这越步骤，程序可能在消费者中的recv()操作上挂起。管道是由操作系统进行引用计数的， 必须在所有进程中关闭管道后才能生成EOFError异常。因此，在生产者中关闭管道不会有任何效果， 除非消费者也关闭了相同的管道端点。

使用管道的生产者——消费者的例子：

import multiprocessing
def consumer(pipe):
    outputp, inputp = pipe
    inputp.close()  # 关闭消费者的输入通道
    while True:
        try:
            item = outputp.recv()
        except EOFError:
            break
        print item
    print "Consumer done"
def produce(seq, inputp):
    for item in seq:
        inputp.send(item)

if __name__ == '__main__':
    (outputp, inputp) = multiprocessing.Pipe(True)
    cons_p = multiprocessing.Process(target=consumer, args=((outputp, inputp),))
    cons_p.start()
    outputp.close()  # 关闭生产者的输出通道
    seq = [0, 1, 2, 3, 4]
    produce(seq, inputp)
    # 关闭输入通道
    inputp.close()
    # 等待消费者进程关闭
    cons_p.join()

双向通信的例子：

import multiprocessing
def server(pipe):
    serverp, clientp = pipe
    clientp.close()                #服务器不会使用管道的另一端
    while True:
        try:
            x, y = serverp.recv()  #接收请求消息
        except EOFError:           #如果客户端关闭了管道另一端
            print "Pipe endpoint closed by peer"
            break
        result = x + y
        serverp.send(result)       # 返回处理结果
    print "Server done"
if __name__ == '__main__':
    (serverp, clientp) = multiprocessing.Pipe(True)
    s = multiprocessing.Process(target=server, args=((serverp, clientp),))
    s.start()
    
    #客户端逻辑部分
    serverp.close()                #客户端不会使用管道的另一端
    clientp.send((1, 1))           #发送请求消息
    print clientp.recv()           #打印处理结果
    
    clientp.send(('Hello',' World'))
    print clientp.recv() 
    clientp.close()
    s.join()                       #等待子进程结束

Pool类可用于创建进程池，可以把各种数据处理任务提交给进程池处理：

#构造函数
Pool( [numprocess [, initializer [, initargs]]])
# numprocess   池中的进程数，省略则使用cpu_count()的值
# initializer  进程启动时执行的可调用对象，默认None
# initargs     传递给initializer的参数

Pool的实例支持以下方法： 

AsyncResult的实例支持以下方法：

通常，进程之间彼此是完全孤立的，唯一的通信方式是队列或管道。可以使用两个对象来表示共享数据。这些对象使用了共享内存（通过mmap模块）使访问多个进程成为可能。可以创建以下类型的共享数据：

可以使用以下功能与threading模块类似的同步原语：

结合信号量来把数组发送给另外一个进程的例子：

import multiprocessing
class FloatChannel(object):
    def __init__(self, maxsize):
        self.buffer = multiprocessing.RawArray('d', maxsize)
        self.buffer_len = multiprocessing.Value('i')
        self.empty = multiprocessing.Semaphore(1)
        self.full = multiprocessing.Semaphore(0)
    def send(self, values):
        # 等待缓冲区为空的信号
        self.empty.acquire()
        n = len(values)
        self.buffer_len = n
        self.buffer[:n] = values
        # 设置缓冲区已满的标记
        self.full.release()
    def recv(self):
        self.full.acquire()
        # 复制缓冲区中的值，注意可以使用切片语法
        values = self.buffer[:self.buffer_len.value]
        # 设置缓冲区已空的标记
        self.empty.release()
        return values
    
def consumer(count , fc):
    for i in xrange(count):
        fc.recv()
        
if __name__ == '__main__':
    fc = FloatChannel(100000)
    p = multiprocessing.Process(target=consumer, args=(1000, fc))
    p.start()
    
    values = [float(x) for x in xrange(100000)]
    for i in xrange(1000):
        fc.send(values)
    print "Produce done"
    p.join()

上一节的数据同步，只能使用共享值、数组等基本类型，如果需要使用Python对象则无能为力。Python提供了“管理器”这种独立的子进程，可以用于管理多个进程之间的共享对象。“管理器”作为服务器进程来运行，其他进程则通过代理访问共享对象，相当于客户端。

使用Manager()函数可以创建一个管理器，其返回位于multiprocessing.managers模块中的SyncManager对象

使用multiprocessing模块的程序可以与运行在同一台计算机上的其他进程或者位于远程系统 上的进程进行消息传递。可以使用Client来连接到其它进程：

#位于multiprocessing.connections子模块
connections.Client (address [, family [, authenticate [, authkey]]])
#address       代表网络地址的元组(hostname, port)
#family        表示地址格式的字符串，省略则从address自动推断
#authenticate  是否使用摘要身份验证
#authkey       包含身份验证密钥的字符串，省略则使用current_process().authkey

对方进程必须作为服务器，处于监听状态：

connections.Listener([address, [,family [, backlog[, authenticate [,authkey]]]]])

Listener的实例具有以下方法或属性： 

下面是一个简单的例子：

def server():
    from multiprocessing.connection import Listener
    serv = Listener(('127.0.0.1', 15000), authkey="12345")
    while True:
        conn = serv.accept()
        while True:
            try :
                x, y = conn.recv()
            except EOFError:  # 如果客户端断开连接
                print "Connection closed by peer"
                break
            result = x + y
            conn.send(result)
        conn.close()

if __name__ == '__main__':
    import multiprocessing
    s = multiprocessing.Process(target=server)
    s.start()
    from multiprocessing.connection import Client
    conn = Client(('127.0.0.1', 15000), authkey="12345")
    conn.send((1, 1))
    print conn.recv()
    conn.close()

该模块提供Thread类和各种同步原语，用于编写多线程的程序。

Thread类用于表本单独的控制线程。使用下面的函数可以创建一个新线程:

Thread (group=None, target=None, name=None, args=(), kwarga={})
# group 预留字段
# target 可调用对象，线程启动时，其run方法将调用该对象
# name 线程的名称
# args、kwargs 传递给target的参数

线程支持以下实例方法和属性：

下面是一个使用线程的例子：

import threading
import time
class ClockThread(threading.Thread):
    #除了__init__、run以外，改写别的方法
    def __init__(self, interval):
        threading.Thread.__init__(self)   #子类如果扩展__init__，必须调用Thread的构造函数
        self.daemon = True
        self.interval = interval
    def run(self):
        while True:
            print "Current time is %s" % time.ctime()
            time.sleep(self.interval)
if __name__ == '__main__':
    t = ClockThread(15)
    t.start()   
    time.sleep(150)

用于延迟执行某一函数：

Timer(interval, func [, args [, kwargs]])
#interval 延迟执行的秒数
#func 需要执行的函数
#args、kwargs 函数参数

Timer具有以下实例方法：

锁定是一个同步原语，状态是“已锁定”或“未锁定”之一。两个方法acquire() 和release()用于修改锁定的状态。如果状态为已锁定，尝试获取锁定将被阻塞，直到锁定被释放为 止。如果有多个线程等待获取锁定，当锁定被释放时，只有一个线程能获得它。等待线程获得锁定的顺序没有定义

使用构造函数Lock()可以创建锁的实例，初始状态为未锁定。具有以下实例方法：

使用诸如Lock、RLock或Semphore之类的锁定原语时，必须多加小心。锁定的错误管理经常导致死锁或者竞态条件。可以使用下面代码中提到的两种方式保证锁的正确释放：

import threading
lock = threading.Lock()
#方法一：使用try-finally语句
try:
    lock.acquire()
    #执行同步操作
finally:
    lock.release()
#方法二：使用上下文管理协议
#进入时自动获取锁定，离开时自动释放锁定
with lock:
    #执行同步操作
    pass

此外，应当尽量避免同时获取多个锁定，容易导致死锁。

可重入锁定是一个类似于Lock同步原语，但同一个线程可以多次获取它。这允许拥有锁定的线程执行嵌套的acquire()和release()操作。在这种情况下，只有最外面的release()操作才能将锁定重置为未锁定状态。进行若干次lock()后，必须在进行对应次数的release()才能彻底释放锁。

信号量是一个基于计数器的同步原语，每次调用acquire()方法时此计数器减1，每次调用 release()方法时此计数器加1。如果计数器为0, acquire ()方法将会阻塞，直到其他线程调用release ()方法为止。

可以使用Semaphore([value])来创建信号量，其中value为计数器的初始值，默认为1。信号量包含以下实例方法：

BoundedSemaphore的行为与Semaphore相同，但是限制但release()操作的次数不能超过acquire()的次数。

事件用于在线程之间通信。一个线程发出“事件”信号，一个或多个其他线程等待它，具有以下实例方法：

条件变量是构建在另一个锁定上的同步原语，当需要线程关注特定的状态变化或事件的发生时将使用这个锁定。典型的用法是生产者-消费者场景，其中一个线程生产的数据供另一个线程使用。使用构造函数Condition([lock])可以创建条件变量，其中lock是Lock或者RLock的实例，如果不提供则创建新的锁供食用。Condition具有以下实例方法：

条件变量的简单例子：

import threading
c = threading.Condition()
def producer():
    while True:
        c.acquire()
        produce_item()
        c.notify()
        c.release()
#使用条件变量时需要注意的是，如果存在多个线程等待同一个条件，notify()操作可能唤醒它们
#中的一个或多个（这种行为通常取决于底层的操作系统)。因此，始终有这样的可能：某个线程被
#唤醒后，其等待的条件已经不满足，因此可能需要循环继续等待下一个信号
def consumer():
    while True:
        c.acquire()
        while not item_is_available():
            #释放锁定，生产者可以获取并生产物品
            c.wait()
        c.release()
        consume_item()

线程没有任何方法可用于强制终止或挂起。这是设计上的原因，因为如果某个线程已经获取了锁定，在它能够释放锁定之前强制终止或挂起它，将导致整个应用程序出现死锁。此外，终止时一般不能简单地“释放锁定”，因为复杂的线程同步经常涉及锁定和解除锁定操作，而这些操作在执行时的次序要十分精确。 如果要为终止或挂起提供支持，需要自己构建这些功能。一般的做法是在循环中运行线程，这个循环的作用是定期检査线程状态以决定它是否应该终止

Python解释器被一个锁定保护，该锁定只允许一次执行一个线程，即便存在多个可用的处理器。 在计算密集型程序中，这严重限制了线程的作用。事实上，在计算密集型程序中使用线程，经常比仅仅按照顺序执行同样的工作慢得多。因此，实际上应该只在主要关注I/O的程序，如网络服务器中使用线程。对于计算密集程度更高的任务，最好使用C扩展模块或multiprocessing模块来代替。C扩展具有释放解释器锁定和并行运行的选项，可以做到当释放锁定时不与解释器进行交互。 multiprocessing模块将工作分派给不受锁定限制的单独子进程

queue模块（在Python 2中叫Queue)实现了各种多生产者——多消费者队列，可用于在执行的多个线程之间安全地交换信息。 该模块定义了3种不同的队列类：

队列具有以下实例方法：

使用队列一般可以简化多线程的程序。例如，可以使用共享队列将线程连接在一起，而不必依赖于必须由锁定保护的共享状态。在这种模型中，工作者线程一般充当数据的消费者。下面是一个简单的例子：

import threading 
from queue import Queue
class WorkerThread(threading.Thread):	
   def __init__(self,*args,**kwargs)： 
       threading.Thread.__init__(self, *args, **kwargs) 
       self.input_queue = Queue()
   def send(self,item):
       self.input_queue.put(item)
   def close(self):
       self.input_queue.put(None) 
       self.input_queue.join()
   def run(self):
       while True:
           item = self.input_queue.get()
           if item is None:
               break
           print item #处理条目
           self.input_queue.task_done()
       self.input_queue.task_done()
       return
#使用示例
w = WorkerThread()
w.start()
w.send('Hello')   #把条目发送给工作线程处理
w.close()

上面的例子几乎完全等同于协程。如果要执行的工作不涉及任何阻塞操作，可以将run()方法重新实现为协程，这就省却了使用线程的麻烦。后一种方法的运行速度可能更快，因为节省了线程上下文切换带来的开销

在某些类型的应用程序中，可以使用一个任务调度器和一些生成器或协程实现协作式用户空间多线程，这有时称为微线程。这种技术的一种常见用法是在需要管理大量的已打开文件或套接字的程序中，例如一台需要同时管理 1000个客户端连接的网络服务器。此时的解决方案是联合使用异步I/O或轮询（使用select模块）与处理I/O事件的任务调度器，而不是创建1000个线程，因为过多的线程会导致大量系统资源浪费在上下文切换上。 这种编程技术的基础概念是这样产生的：生成器或协程函数中的yield语句挂起函数的执行，直到稍后使用next () 或者send()操作进行恢复为止。这样就可以使用一个调度器循环在一组生成器函数之间协作多个任务。

基于协程的并发编程的例子：基于协程技术实现的异步Echo服务

The post Python并发编程 appeared first on 绿色记忆.

进程和信号是Linux操作环境的基础部分，控制着Linux和其它类UNIX系统的几乎所有活动。

UNIX标准对进程的定义：其中运行着一个或者多个线程的地址空间，以及这些线程需要的系统资源。Linux系统的进程是非常轻量级的。

每个Linux进程包含以下部分：

1. PID：进程的唯一表示，是范围从2~32768的正整数，数字回绕一圈后，重新从2开始计数（数字1被系统第一个进程init占用）
2. 程序代码：以自动方式加载到内存，正常情况下Linux进程不能对用来存放程序代码的内存区域进行写操作，因而可以被多个进程安全的共享
3. 函数库：系统函数库也可以被共享，不管多少进程调用printf，内存中只需要它的一份副本即可，这种做法类似于微软的DLL机制但更为复杂
4. 进程数据：存放进程的全局变量
5. 栈空间：进程有属于自己的栈空间，用于保存函数中的局部变量、控制函数的调用和返回
6. 环境空间：包含专为该进程建立的环境变量
7. 程序计数器：记录进程执行到的位置，即在执行线程中的位置。进程可以包含多个执行线程

Linux系统使用一个被称为进程表的结构来存放当前加载到内存的所有进程的信息。这些信息包括：进程ID、进程状态、进程命令字符串以及其它一些ps命令输出的信息。操作系统通过PID对进程进行管理，早起的UNIX系统只能同时运行256个进程。

注意：这些状态也适用于线程。进程中的线程通常处于不同的状态。

通过ps的STAT列，可以查看进程的状态，其代码如下表：

一般而言，每个Linux进程都是由另外一个被称为父进程的进程所启动的，前者相对的被称为子进程。在Linux系统启动时，它运行一个PID为1的init进程，可以把该进程看做操作系统的进程管理器，它是所有进程的祖先进程。

启动进程并等待其结束，是Linux中最基本的进程管理任务。应用程序可以通过fork、exec、wait等系统调用完成这些任务。

每个进程被分配以非常短暂的时间片，在时间片范围内进程代码被CPU执行，由于CPU非常快、时间片又非常短，你会感觉到多个程序同时运行的假象。Linux内核使用进程调度器来决定下一个时间片应该分配给哪个进程，其判断的依据是进程的优先级，优先级高的进程获得的时间片更多。在Linux中进程的运行时间不可能超过分配给它的时间片，Linux使用的是抢占式处理，因此进程的挂起、继续运行不需要彼此之间的协作。

进程调用

exit()

父进程可能先于子进程死亡，这种情况下，init进程可以成为子进程的养父。

子进程在死亡后，将处于僵尸状态。这种状态的进程不能被调度，并占据少量的系统资源，以保证其父进程可以访问其退出码等信息。父进程负责完全的释放子进程。

进程包含：虚拟地址空间、打开的系统对象的描述符、安全上下文、进程标识符、环境变量、最小-最大工作集大小，以及最少一个线程 —— 主线程。

线程是进程内部的一个可调度的实体（执行路径），进程内的所有线程共享地址空间、打开的描述符。每个线程维护自己的exception handlers、调度优先级、线程本地存储、线程标识符、线程上下文结构。线程可以具有自己的安全上下文。

线程上下文中包括的数据项：寄存器数据、内核栈、线程环境块、位于进程地址空间的用户栈。

可以在程序内部启动另外一个程序，从而创建新的进程，可以通过库函数system()完成：

#include <stdlib.h>
/**
 * 运行指定的命令并等待其完成
 * @param cmd 需要执行的命令
 * @return 如果无法启动Shell返回127，其它错误返回-1，否则返回所执行命令的退出码
 */
int system( const char *cmd );

上述函数的重大缺点是必须等待子进程的完成，并且依赖于Shell，因此使用的不多。

exec系列函数用于把当前进程替换为一个新的进程（新进程执行结束后不会返回原进程）。 新的程序启动后，原有的程序就不再运行了：

#include <unistd.h>
char **environ; // 该全局变量可用来设置传递到新程序的环境变量

// ***p函数通过搜索PATH环境变量来查找新的可执行文件的路径，如果目标程序不在PATH中，则path参数应当使用绝对路径
// ***e函数支持通过envp数组指定环境变量

// 下面三个函数支持变长参数列表，此列表以一个空指针结束
int execl(const char *path, const char *arg0, ..., (char *)0);
int execlp(const char *file, const char *arg0, ..., (char *)0);
int execle(const char *path, const char *arg0, ..., (char *)0, char *const envp[]);

// 下面三个函数使用数组来表示参数列表
int execv( const char *path, char * const argv[] );
int execvp( const char *file, char * const argv[] );
int execve( const char *path, char * const argv[], char * const envp[] );

//举例：
char * const ps_argv[] = { "ps", "ax", 0 };
char * const ps_envp[] = { "PATH=/bin:/usr/bin", "TERM=console", 0 };
execl("/bin/ps", "ps", "ax", 0);
execlp("ps", "ps", "ax", 0);
execle("/bin/ps", "ps", "ax", 0, ps_envp);
execv("/bin/ps", ps_argv);
execvp("ps", ps_argv);
execve("/bin/ps", ps_argv, ps_envp);

一般情况下，exec函数是不会返回的，除非发生错误，此时返回-1并设置errno。

exec启动的新进程保留了原进程的许多特性，特别是，原进程打开的文件描述符仍然有效，除非这些描述符的close on exec flag标记位被设置。任何在原进程中打开的目录流都会在新进程中被关闭。

系统调用fork允许创建以当前进程为模板，复制出一个新的进程。fork调用会在进程表中创建一个新的表项，其中很多属性都和原进程相同，包括所执行的代码。但新进程具有自己的数据空间、环境、文件描述符。fork函数的原型如下：

#include <sys/types.h>
#include <unistd.h>
pid_t fork( void );

fork()函数很巧妙，其具有“两次返回”的效果，实质上对应了父子进程的不同执行路径。对于父进程，fork()返回子进程的ID；而对于子进程，fork()总是返回0。通过这一特点，可以判断当前执行的代码是父进程还是子进程：

pid_t new_pid;
new_pid = fork();
switch ( new_pid )
{
    case -1 :   /* 错误 */
        break;
    case 0 :    /* 子进程 */
        break;
    default :   /* 父进程 */
        break;
}

结合fork、exec函数，创建新进程的条件就完备了。

当fork启动一个子进程后，子进程就有了自己的生命周期，并将独立运行，有时候，需要知道子进程何时结束，可以在父进程中用wait系统调用：

#include <sys/types.h>
#include <sys/wait.h>
/**
 * 暂停父进程的执行，直到其子进程结束
 * @param stat_loc 存放状态信息，用于了解子进程的退出状态（即子进程main函数的返回值或者exit函数的退出码）
 *     WIFEXITED(stat_val)     如果子进程正常结束，则取值非0
 *     WEXITSTATUS(stat_val)   如果WIFEXITED非0，取值子进程的退出码
 *     WIFSIGNALED(stat_val)   如果子进程死于未捕获的信号，则取值非0
 *     WTERMSIG(stat_val)      如果WIFSIGNALED非0，取值目标信号的代码
 *     WIFSTOPPED(stat_val)    如果子进程意外终止，取值非0
 *     WSTOPSIG(stat_val)      如果WIFSTOPPED非0，返回信号代码
 *
 * @return 子进程的PID
 */
pid_t wait( int *stat_loc );

/**
 * 等到某个特定的子进程结束
 * @param pid 子进程的PID，如果指定为-1将返回任一子进程的信息
 * @param stat_loc 如果不是空指针，则用来存放状态信息
 * @param option 用于定制waitpid的行为
 */
pid_t waitpid( pid_t pid, int *stat_loc, int options );

/**
 * 检查某个子进程是否结束，立即返回
 * 
 * @return 如果目标子进程没有结束或者意外终止，返回0；否则返回子进程PID
 *         如果函数调用失败，返回-1并设置errno
 */
waitpid(child_pid, (int *) 0, WNOHANG);

使用fork创建的子进程终止时，其与父进程的关联还会保持，直到父进程也正常终止或者父进程调用wait才会结束。在此之前，虽然子进程已经无事可做，但是其在进程表中的项不会被删除，其退出码需要被保存，以备后续父进程的wait调用，这种进程被称为僵尸进程（Zombie，也称为死defunct进程）。

如果父进程异常终止，子进程自动把PID=1的进程（init）作为自己的父进程，这类僵尸进程会一直保存在进程表中直到init发现并释放它。

在Linux中，会话（Session）通常是指Shell会话，即会话的概念和Shell是分不开的。所谓Shell是用户访问Linux系统的接口，是用户与内核之间的桥梁。

在大部分的Linux发行版中，BASH是默认的Shell实现。每当你：

1. 本地打开Terminal窗口
2. 通过SSH远程登录

时，一个关联的新会话会被自动创建。不管本地还是远程登录，用户都会得到一个与终端（Terminal）相关联的（Shell）进程，该进程作为Session Leader，会话的ID就是该进程的PID。

你也可以编程式的创建新的会话，调用

pid_t setsid(void) 

当终端被挂断（Hangup），即：

1. 对于本地Terminal，窗口被关闭
2. 对于SSH终端，网络连接被断开

时，Session Leader会接收到SIGHUP信号而退出。在Session Leader退出前，它会向所有子进程也发送SIGHUP信号，通常会导致会话中所有进程都结束掉。要想让某个子进程超越Session的生命周期而存活，你可以：

1. 让Session Leader主动退出，一般来说就是在Shell里调用exit/logout等命令。默认情况（Shell选项huponexit=off）下，主动退出不会发送SIGHUP给子进程
2. 守护进程化：即所谓Double fork技巧，让Shell的子进程fork出孙子进程，在孙子进程中执行程序逻辑，而子进程立即退出（孙子进程变成孤儿进程）。由于Shell只会将SIGHUP发送给直接子进程，孙子进程就不会受到影响了
3. 使用

   setsid()

    系统调用，让某个子进程变成新的Session的Leader，自立门户

顾名思义，进程组（Process group）就是包含了1~N个进程的分组。进程组的主要作用是利于信号的分发——当信号发送给进程组时，其内部的所有进程都会接收到信号。

一个会话中可以包含1~N个进程组，进程组不允许跨会话迁移，进程没有资格创建属于其它会话的进程组，进程也不能加入属于其它会话的进程组。

一个Session有且只有一个终端，该终端称为控制终端（controlling terminal），改变Session关联的终端这一操作，只能由Session Leader完成。

终端的生命周期可能：

1. 与Session相同，这类终端是随着会话而创建的伪终端
2. 与系统相同，这类终端是随着系统启动的，init进程在会话结束后重启getty来监听该终端

软中断信号（简称信号，signal）用来通知进程发生了异步事件（通常是某种错误）。信号是进程之间（包括用户进程之间、用户进程与内核进程之间）进行通信的一种简单方式，信号不会给目标进程发送任何数据。

使用信号并挂起程序（例如pause调用）是Linux程序设计的一个重要部分，这意味着程序不需要总是在执行，在一个无限循环中检查某个事件是否发生，相反，它可以等待事件的发生。这种机制对于只有一个CPU的多任务环境非常重要，进程共享一个处理器，繁忙的循环会对系统性能造成极大的影响。

尽管用户可以通过命令手工发出信号，但是内核是主要的信号发出者。以下场景下会目标进程会收到信号：

1. 检测到一个可能出现的硬件故障，如电源故障
2. 程序出现异常行为，比如尝试访问进程外部内存空间、尝试写入只读内存区域
3. 用户从终端向目标程序发出某些指令（ctrl + z、ctrl + c等），终端进程会接收到对应信号
4. 进程的一个子进程终止时

在进程的进程表项（内核通过进程表对进程进行管理，每个进程在进程表中占有一项）中，有一个信号域，信号域的每一个slot对应一种信号，对于同一种信号，进程无法知道在处理前来过多少个。

内核通过设置进程的信号域对应slot，来给进程发送信号。

当内核将信号发送给正在睡眠的进程时：

1. 如果进程处于可中断的睡眠状态，则唤醒之
2. 如果进程处于不可中断的睡眠状态：则仅仅设置slot

进程在以下场景下检查自己是否收到信号：

1. 进程即将从内核态返回到用户态时：进程在内核态运行时，信号不起作用，直到其将要返回用户态时才进行处理，信号处理函数在进程上下文中进行
2. 进程即将进入或离开一个适当的低调度优先级睡眠状态时

进程接收到信号后，可以：

1. 忽略该信号
2. 捕获该信号：当前进程继续执行前，调用一个用户定义的函数。这种处理机制类似于中断处理程序
3. 让内核执行与该信号相关的默认动作，大部分信号的默认动作导致进程终止

根据POSIX标准，信号为进程而产生，但是仅仅其中一个线程可以接收信号并处理。至于哪个线程负责处理信号，取决于实现。

对于Linux：

1. 信号可以针对进程的整体而产生，例如kill命令产生的信号
2. 信号可以针对特定线程，例如SIGSEGV、SIGFPE信号，或者pthread_kill命令产生的信号
3. 对于针对进程整体的信号，任何没有被信号阻塞的线程都可以处理之。如果有多个这样的线程（has the signal unblocked），内核会随机的选择一个

对于pthreads：每个线程具有独立的信号栈设置（signal stack settings），但是新线程总是从父线程拷贝此设置

shopt | grep huponexit

通过signal可以设置信号的处理函数：

#include <signal.h>
/**
 * 设置信号的处理函数
 * @param sig 信号
 * @param func 处理回调函数
 * @return 返回先前的信号处理函数的指针，如果未定义信号处理函数返回SIG_ERR并设置errno为正数
 *         如果给出一个无效的信号，或者尝试处理不可捕获、不可忽略的信号（例如SIGKILL），则将errno设置为EINVAL
 */
typedef void (*signal_handler_t )( int );
signal_handler_t signal( int sig, signal_handler_t );

//两个特殊的信号处理函数：
// SIG_IGN 忽略信号
// SIG_DFL 恢复此信号的默认处理行为

#include <unistd.h>
/**
 * 导致当前进程暂停执行，直到接收到一个信号
 * 当暂停被一个信号中断时，返回-1并且设置errno为EINTR
 */
int pause( void );

信号处理函数中调用某些函数是不安全的，例如printf，最好是在信号处理函数中设置一个标记，然后在主程序中检查标记再调用某些函数。下面是信号处理函数的例子：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void ouch( int sig )
{
    printf( "OUCH! - I got signal %d\n", sig );
    //该信号处理函数恢复默认行为:停止程序
    signal( SIGINT, SIG_DFL );
}

int main()
{
    //进程启动后，设置信号的处理函数
    signal( SIGINT, ouch );
    while ( 1 )
    {
        //此循环会不停执行，除非接收到信号
        printf( "Hello World!\n" );
        sleep( 1 );
    }
}

X/Open和UNIX规范推荐了更加健壮的信号编程接口：

#include <signal.h>
/**
 * 指定接收到sig信号后采取的动作
 * @param sig 处理的信号
 * @param act 需要指向的动作
 * @param oact 如果不为空，此函数调用前sig信号的处理动作被转储到该指针
 * @return 如果成功，返回0，失败返回-1，如果给出的信号无效或者对不允许忽略或者
 *         捕获的信号进行忽略或者捕获，则设置errno=EINVAL
 */
int sigaction( int sig, const struct sigaction *act, struct sigaction *oact );
typedef  void (*sa_handler_t)( int );
struct sigaction
{
    sa_handler_t sa_handler; //信号处理函数，包括SIG_DFL、SIG_IGN
    //一个信号集，在sa_handler被调用之前，此信号集中的信号不会传递给进程，
    //可以防止信号处理函数尚未执行完毕就接收到新信号并重入信号处理函数的情况
    //信号处理函数在指向过程中，可能被新的信号中断而再次调用，这不仅仅是递归调用
    //的问题，更牵涉到可重入（安全的进入和再次指向）的问题
    sigset_t sa_mask;
    //标记位：
    //SA_RESETHAND 表示处理函数调用后（入口第一句后），即重置默认处理函数（SIG_DFL）
    //SA_NOCLDSTOP 子进程停止后不产生SIGCHLD信号
    //SA_RESTART   重启可中断函数而不是给出EINTR错误。许多系统调用是可中断的，也就是
    //             说接收到信号后系统调用会返回一个错误并设置errno=EINTR
    //             以表示该调用因为信号而返回。设置该标记后，调用将重启而不是被信号中断
    //SA_NODEFER   捕获到信号时不将其加入到信号屏蔽掩码中。通常的做法：为防止同一信号不
    //             断到达，新接收到的信号会被加入到掩码中，直到处理函数指向完毕
    int sa_flags;
};

//向信号集中增加一个信号
int sigaddset( sigset_t *set, int signo );
//创建空白信号集
int sigemptyset( sigset_t *set );
//创建包含所有已定义信号的信号集
int sigfillset( sigset_t *set );
//从信号集中删除指定的信号
int sigdelset( sigset_t *set, int signo );
//判断信号是否为信号集的成员，如果是返回1否则返回0，如果给定的信号无效返回-1并设置EINVAL
int sigismember( sigset_t *set, int signo );
/**
 * 根据how指定的方式修改进程的信号屏蔽掩码
 * @param how
 *        SIG_BLOCK    将set加入到进程的掩码
 *        SIG_SETMASK  将进程的掩码设置为set
 *        SIG_UNBLOCK  从进程的掩码中删除set
 * @param set 新的信号屏蔽掩码，如果设置为空，仅仅是把当前信号屏蔽掩码保存到oset
 * @param oset 原先的信号屏蔽掩码
 * @return 如果成功返回0；如果how无效返回-1并设置errno=EINVAL
 *
 */
int sigprocmask( int how, const sigset_t *set, sigset_t *oset );

/**
 * 如果一个信号被进程阻塞，就不会传递给进程而停留在待处理状态。
 * 该函数可以查看阻塞的信号中那些处于待处理状态
 */
int sigpending( sigset_t *set );

/**
 * 挂起进程自己，等待信号集中某个信号到达
 * 如果接收到的信号终止了程序，该调用不会返回；否则返回-1并设置errno=EINTR
 */
int sigsuspend( const sigset_t *sigmask );

下面是对前一个信号处理例子的改写：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void ouch( int sig )
{
    printf( "OUCH! - I got signal %d\n", sig );
}
int main()
{
    struct sigaction act;
    act.sa_handler = ouch; //设置信号处理函数
    sigemptyset( &act.sa_mask ); //创建空的信号屏蔽掩码
    act.sa_flags = SA_RESETHAND;
    sigaction( SIGINT, &act, 0 );
    while ( 1 )
    {
        printf( "Hello World!\n" );
        sleep( 1 );
    }
}

信号处理函数中会遇到可重入问题，下表列出可以被信号处理函数安全调用的函数，他们本身是可重入、或者本身不会再生成信号：

进程可以调用kill函数来向包括其自身在内的进程发送一个信号。如果进程没有发送目标信号的权限，对kill的调用就会失败，失败的常见原因是目标进程是由另外一个用户所拥有。下面的函数可以用来发送信号：

#include <sys/types.h>
#include <signal.h>
/**
 * 将信号发送给指定进程，如果成功返回0，失败返回-1并设置errno，errno可以为以下值：
 * EINVAL  给定的信号无效
 * EPERM   发送进程的权限不够，一般只能发送给同一用户的进程，超级用户可以发送信号给所有进程
 * ESRCH   目标进程不存在
 *
 */
int kill( pid_t pid, int sig );

#include <unistd.h>
/**
 * 在延迟seconds秒以后，发送一个SIGALRM信号
 * 每个进程只能有一个闹钟，因此后续的调用将导致重新计时并返回上一次闹钟设置的剩余秒数
 * 如果seconds设置为0则取消闹钟请求
 */
unsigned int alarm( unsigned int seconds );

The post Linux信号、进程和会话 appeared first on 绿色记忆.

一个程序中可以有多个代码指向序列，这每个序列就是一个线程（Thread），线程是进程内部的一个控制序列。一个进程至少具有一个执行线程。

Linux中通过fork创建的新进程，与Phtead API创建的线程是具有很大不同的：

1. fork出的进程，拥有自己的变量、PID，其时间调度是独立的，其执行几乎完全独立于父进程
2. 进程中创建的新线程，具有自己的栈（因而具有独立的局部变量），但是它与创建者共享全局变量、文件描述符、信号处理函数、当前目录状态

尽管线程已经出现很长时间，但是在IEEE POSIX委员会发布相关标准前，并没有在UNIX系统中得到广泛的支持。POSIX 1003.1c规范改变了这一状况，线程的实现被标准化，绝大部分的Linux发行版都支持它。

Linux在1996年开始支持线程，当时的函数库称为LinuxThread，该线程实现和POSIX标准存在细微的差别，特别是信号处理的相关部分。许多项目致力于改善Linux对线程的支持，以清除与POSIX标准的差异、增加性能，其中大部分工作集中在如何将用户级线程映射到内核级线程。这些项目中，以下一代POSIX线程（NGPT）和本地POSIX线程库（NPTL）为代表，而NPTL成为了Linux线程库的新标准。

尽管相比起某些其它OS，Linux创建进程的效率很高，但是创建新线程比创建新进程的代价要小得多。

线程具有以下优势场景：

1. 有时，一个程序需要“同时”做几件事情。例如：编辑文档的时候同时进行单词个数的统计；数据库软件需要同时服务多个连接，这些连接可以对应不同的线程，线程之间需要紧密协作才能完成加锁、数据一致性要求，这些需求通过线程很容易实现
2. 混杂着输入、计算、输出的应用程序。分离为多个线程来处理，可以有效改善程序的性能。需要服务多个客户端的网络服务器也是天生适合多线程的例子
3. 一般而言，线程之间的切换需要操作系统做的工作比进程切换少得多。多个线程对资源的需求要远远小于多个进程

线程的主要缺点是：

1. 多线程程序需要非常仔细的设计。在多线程程序中，因为时序上的细微差别、无意间的变量共享引发错误的可能性很大
2. 多线程程序的调试比单线程困难的多，因为线程之间的交互非常难于控制
3. 对于计算密集型程序，将计算拆分到多个线程运行，对于单处理器来说没有价值

Linux下线程具有一套完整的库函数，这些函数大部分以pthread_开头，声明在头文件：

pthread.h

在最初设计UNIX/POSIX例程时，人们往往假设每个进程只有一个执行线程，典型的例子就是errno全局变量。在多线程环境下，需要“可重入例程”：即多次调用仍然能正常工作，这些调用可能来自不同的线程，也可能是某种形式的递归调用。

编写多线程程序时，通常需要在任何include语句之前定义宏

_REENTRANT

1. 对部分函数进行重新定义，定义为其可重入版本，这些函数的名字一般不会发生改变，只是在原函数的名字后面加上

   _r

    
2. stdio.h中原来以宏实现的一些函数，变成可重入函数
3. errno.h中定义的变量errno变成一个函数调用，能够以多线程的形式来获取真正的errno值

下面是基本的线程API：

#include <pthread.h>
/**
 * 创建一个新的线程
 * @param thread 指向pthread_t的指针，线程被创建时，指针指向的变量被写入一个标识符，该标识符用来引用新的线程
 * @param attr 设置线程的属性，不需要时设置为NULL
 * @param start_routine 线程启动时执行的函数
 * @param arg 线程启动时指向的函数的参数
 *
 * @return 成功时返回0，错误时返回错误代码，pthread_函数的大部分都没有遵循UNIX函数惯例——失败时返回-1
 */
int pthread_create( pthread_t *thread, pthread_attr_t *attr,
        void *(*start_routine)( void * ), void *arg );

/**
 * 终止一个线程的执行（谁调用，谁被终止），类似于exit()终止一个进程的执行
 * @param retval 存放返回值的指针，注意不能使用局部变量，因为线程退出后已经销毁
 */
void pthread_exit( void *retval );

/**
 * 类似于进程中用来收集子进程信息的wait函数
 * @param th 将要等待的线程
 * @param thread_return 指向一个指针，该指针指向线程的返回值
 */
int pthread_join( pthread_t th, void **thread_return );

/**
 * 可以让一个线程要求另外一个线程终止，就好像进程之间发送信号一样。
 * @param thread 需要终止的线程的标识符
 */
int pthread_cancel( pthread_t thread );
/**
 * 可以设置自己的取消状态
 * @param state  PTHREAD_CANCEL_ENABLE 允许取消请求（默认）；PTHREAD_CANCEL_DISABLE 忽视取消请求
 */
int pthread_setcancelstate( int state, int *oldstate );
/**
 * 可以设置自己的取消方式
 * @param type
 *    PTHREAD_CANCEL_ASYNCHRONOUS 接收到请求后立即采取行动；
 *    PTHREAD_CANCEL_DEFERRED 延迟取消行为（默认），直到线程执行了以下函数之一：
 *      pthread_join, pthread_cond_wait,pthread_cond_timedwait, pthread_testcancel, sem_wait, sigwait
 */
int pthread_setcanceltype( int type, int *oldtype );

下面是一个例子：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
void *thread_function( void *arg );
//一个共享变量
char message[] = "Hello";
int main()
{
    setbuf( stdout, _IOFBF );
    int res;
    pthread_t a_thread;
    void *thread_result; //存放线程返回值的指针
    //创建一个线程
    res = pthread_create( &a_thread, NULL, thread_function, ( void * ) message );
    if ( res != 0 )
    {
        perror( "Thread creation failed" );
        exit( EXIT_FAILURE );
    }
    printf( "Waiting for thread to finish...\n" );
    //等待线程运行结束，将返回值指针的地址传递给函数，线程指向完毕后，会填写此地址
    res = pthread_join( a_thread, &thread_result );
    if ( res != 0 )
    {
        perror( "Thread join failed" );
        exit( EXIT_FAILURE );
    }
    //打印线程的返回值
    printf( "Thread joined, it returned message: %s\n", ( char * ) thread_result );
    //打印共享变量
    printf( "Message changed: %s\n", message );
    exit( EXIT_SUCCESS );
}
//线程入口函数定义
void *thread_function( void *arg )
{
    printf( "Thread is running. Argument: %s\n", ( char * ) arg );
    sleep( 3 );
    //修改共享变量
    strcpy( message, "Bye" );
    //线程退出，返回一段文本
    pthread_exit( "Thread exit" );
}

在创建线程的时候，允许指定一个属性参数，下面的API用于控制属性：

#include <pthread.h>
/**
 * 初始化一个线程属性
 */
int pthread_attr_init( pthread_attr_t *attr );
/**
 * 销毁一个线程属性，一旦被销毁，除非再次初始化，否则不能继续使用
 */
int pthread_attr_destroy( pthread_attr_t * );

//线程属性控制函数
//detachstate：允许无需对线程进行rejoin
//detachstate可以为：PTHREAD_CREATE_JOINABLE（默认）、PTHREAD_CREATE_DETACHED，后者不允许针对其pthread_join调用
int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate );
int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate );
//schedpolicy：控制线程如何被调度。可选值：SCHED_OTHER（默认）、SCHED_RP、SCHED_FIFO
//后两个值要求超级用户权限，分别使用循环调度、先进先出调度策略
int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy );
int pthread_attr_getschedpolicy( const pthread_attr_t *attr, int *policy );
//scheparam：与schedpolicy配合使用，可以控制SCHED_OTHER的行为
int pthread_attr_setschedparam( pthread_attr_t *attr, const struct sched_param *param );
int pthread_attr_getschedparam( const pthread_attr_t *attr, struct sched_param *param );
//inheritsched：是否从创建者继承调度属性。可选值：PTHREAD_EXPLICIT_SCHED、PTHREAD_INHERIT_SCHED
//分别表示需要明确设定，以及从创建者继承
int pthread_attr_setinheritsched( pthread_attr_t *attr, int inherit );
int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inherit );
//scope：控制线程调度的计算方式，Linux目前仅仅支持PTHREAD_SCOPE_SYSTEM
int pthread_attr_setscope( pthread_attr_t *attr, int scope );
int pthread_attr_getscope( const pthread_attr_t *attr, int *scope );
//stacksize：控制线程栈大小，单位字节
int pthread_attr_setstacksize( pthread_attr_t *attr, int scope );
int pthread_attr_getstacksize( const pthread_attr_t *attr, int *scope );

下面是一个控制线程优先级的例子：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sched.h>

int main( int argc, char **argv )
{
    pthread_attr_t thread_attr;
    int max_priority;
    int min_priority;
    struct sched_param scheduling_value;

    int res = pthread_attr_setschedpolicy( &thread_attr, SCHED_OTHER );
    if ( res != 0 )
    {
        perror( "Setting scheduling policy failed" );
        exit( EXIT_FAILURE );
    }
    max_priority = sched_get_priority_max( SCHED_OTHER );
    min_priority = sched_get_priority_min( SCHED_OTHER );
    scheduling_value.sched_priority = min_priority; //设置为最低优先级
    res = pthread_attr_setschedparam( &thread_attr, &scheduling_value );
    if ( res != 0 )
    {
        perror( "Setting scheduling priority failed" );
        exit( EXIT_FAILURE );
    }
}

Linux包含一组控制线程执行和代码临界区域访问的方法。 

信号量这个概念最初由Dijkstra提出，他是一种特殊的变量，可以被增加或减少，即使在多线程环境下，对其进行增加、减少等关键操作也能保证原子性。这意味着多个线程对信号量的操作将被顺序执行，而对于普通变量，来自程序中多个线程的冲突操作造成的结果是不能确定的。

信号量用于控制对一组相同对象的访问。Linux下有两组函数可以用于信号量：

1. 一组取自POSIX的扩展，用于线程
2. 一组被称为System V信号量，用于进程的同步

Linux可用的信号量包括两种：二进制信号量、计数信号量，前者只有0/1两个值，可以用来保护代码同时只能被一个线程访问。线程中使用的基本信号量函数有以下四个：

#include <semaphore.h>
/**
 * 创建一个信号量
 * @param sem 被初始化的信号量
 * @param pshared 信号量的类型，如果为0表示是进程内部信号量，如果为1表示可以在多个进程之间共享
 * @param value 信号量初始值
 */
int sem_init( sem_t *sem, int pshared, unsigned int value );
/**
 * 以原子的方式将信号量的值加1
 * 所谓原子操作是指：如果两个线程同时企图调用该函数，他们不会互相干扰，结果总是一致的加2
 */
int sem_post( sem_t * sem );
/**
 * 以原子的方式将信号量的值减1，但它会等到直到信号量有个非零值时才会指向减法操作
 * 如果对值为0的信号量调用该操作，调用者将一直等待直到信号量不为0为止
 */
int sem_wait( sem_t * sem );
//尝试获取一个信号量，立即返回
int sem_trywait( sem_t *sem );
//等待一个信号量，在指定时间后超时退出
int sem_timedwait( sem_t *sem, const struct timespec *abstime );
/**
 * 在用完信号量后对其进行清理
 */
int sem_destroy( sem_t * sem );

用于控制同一时刻只能有一个线程可以访问共享内存，互斥量允许锁住某个对象，直到操作完成后再释放它。

#include <pthread.h>
//这些函数成功返回0，失败返回错误代码，不设置errno
/**
 * 初始化一个互斥量
 * @param mutex 互斥量
 * @param mutexattr 互斥量的属性，可以定制其行为
 */
int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr );
/**
 * 锁定一个互斥量，如果互斥量已经被加锁，该调用会一直阻塞直到其解锁
 */
int pthread_mutex_lock( pthread_mutex_t *mutex );
/**
 * 解锁一个互斥量
 */
int pthread_mutex_unlock( pthread_mutex_t *mutex );
/**
 * 销毁一个互斥量
 */
int pthread_mutex_destroy( pthread_mutex_t *mutex );

The post POSIX线程编程 appeared first on 绿色记忆.

线程的本质是机器指令的执行路径，它完全是多任务操作系统之上的虚拟概念。从硬件角度来看，每一个CPU只有一条执行路径，成百上千的线程同时运行，只是操作系统调度形成的假象。

每一个计算机程序，或者说进程，至少有一个线程，称为主线程。Java程序的主线程叫做main thread，它以某个Class的main()方法为执行路径的起始点。任何计算机程序都是以单一线程开始运行的。

Java允许两种创建新线程的风格：

1. 继承java.lang.Thread，并覆盖run()方法
2. 实现java.lang.Runnable接口，并将其传递给Thread类的构造器

Thread对象本质上并不代表线程本身，而是一组与线程有关的方法和数据封装。

Thread的构造函数包括以下参数：

Thread t = new Thread() {
    public void run()
    {
        while ( !isInterrupted() )
            ;
        System.out.println( "interrupted" );
    }
};
t.start();
TimeUnit.SECONDS.sleep( 1 );
t.interrupt();

Thread t = new Thread() {

    public void run()
    {
        try
        {
            TimeUnit.SECONDS.sleep( 3600 );
        }
        catch ( InterruptedException e )
        {
            System.out.println( "interrupted" );
        }
    }
};
t.start();
TimeUnit.SECONDS.sleep( 1 );
t.interrupt();

竞态条件（Race Condition），是指计算的输出依赖于不受控制的事件的出现顺序或者出现时机，具体来理解此定义中的关键词：

1. 计算的输出：比如方法调用的结果
2. 不受控制：比如线程的调度是不受控制的，具有随机性
3. 顺序或时机：比如哪个线程先执行，执行到哪一行代码并OS切换出去，哪个线程被切换进来获得CPU并执行

下面举个浅显的例子，假设有这样一个计算器：

public class Calculator
{
    private final int[] input;
    private int         start;
    private int         end;
    public Calculator( int start, int end )
    {
        super();
        this.input = new int[] { start, end };
        reset();
    }
    private void reset()
    {
        start = input[0];
        end = input[1];
    }
    public int add()
    {
        int res = 0;
        for ( ; start <= end; start++ )
            res += start;
        reset();
        return res;
    }
}

我们期望它每次计算都能输出正确的结果，下面有两个线程连续调用计算器100次：

private static class CalculateThread extends Thread
{
    private Calculator calculator;

    public CalculateThread( Calculator calculator )
    {
        super();
        this.calculator = calculator;
    }

    public void run()
    {
        for ( int i = 0; i < 1000; i++ )
            System.out.println( calculator.add() );
    }
}

public static void main( String[] args )
{
    Calculator calculator = new Calculator( 0, 100 );
    new CalculateThread( calculator ).start(); //线程1
    new CalculateThread( calculator ).start(); //线程2
}

观察计算结果，可以看到，大部分的调用能够得到正确的和5050，但是会有一些随机的值夹杂其中，例如0、4189、1766…… 而且每次运行的输出结果都不一样。这就是典型的竞态条件场景了，线程1在调用add()方法时，随时可能因为OS的线程调度而暂停运行，这个时候calculator处于一种不一致的中间状态，此时线程2来发起/继续它的add()调用，calculator的两个状态字段的值是不确定的、随机的，因而计算结果必然不可靠。

之所以大部分结果是正确的，是因为CPU分配给线程的时间片相对于add()中的循环来说，是非常漫长的，因此大部分情况下线程能够不受干扰的一次执行完这个方法。

即使是一些非常简单的代码，也可能引入竞态条件：

public class IntCounterTest {
	private static int counter = 0;
	private static class CounterThread extends Thread {
		public void run() {
			for (int i = 0; i < 10000000; i++)
				synchronized (IntCounterTest.class) {
					counter++;
				}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		CounterThread t1 = new CounterThread();
		t1.start();
		CounterThread t2 = new CounterThread();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(counter);
	}
}

上面的例子中，我们让t1、t2两个线程分别把计数器的值增加1000万，期望结果应该是2000万，但是几乎每次运行结果都不正确。 什么原因呢？因为++操作符至少包含三条指令：

1. 读取变量的当前值到寄存器
2. 将此值加一
3. 将新值写回到变量

如果线程t1在执行这三条指令期间受到干扰，例如：

1. 执行完第二条指令后，OS调度导致t1让出CPU，由t2执行
2. 多核CPU场景下，t1执行完第二指令后，t2连续执行三条指令

就必然导致数据状态的不一致。

出现竞态条件的根本原因是一项操作（例如一个方法调用、或者一个操作符）不是原子的（atomic），物理学曾经认为原子是不可再分的，我们借用这一概念，用来描述一个不可中断的操作——要么不做、要么完成。

要让一个Java的方法变为原子的，那么就需要线程执行这个方法所有指令的整个过程不被干扰，即不会有其他线程来修改共享资源的状态。达到这一目标最直接的方法就是使用互斥锁（Mutex Lock）机制，该机制可以保证同一时刻只有一个线程对关键的、修改共享资源状态的代码段具有访问权。Java在语言级别上支持互斥锁机制——synchronized关键字，我们可以这样对上例的代码进行改写：

private static class CounterThread extends Thread
{
    public void run()
    {
        for ( int i = 0; i < 10000000; i++ )
            //限制同一时刻只有一个人能访问对象IntCounterTest.class
            //由于这个类对象是全局唯一的，因此同一时刻只有一个线程能对counter进行递增
            synchronized ( IntCounterTest.class )
            {
                counter++;
            } //在同步块的边界，所有寄存器变量的值被视为无效
    }
}

这样再执行，结果就总是2000万了。不过使用synchronized的代价是高昂的，在我机器上测试，修改前后代码运行耗时相差超过100倍。Java5提供的AtomicInteger性能相对较好（仍然有10倍性能差距），可以用来代替上例的int。

等待（阻塞）在synchronized块入口的线程，和sleep的线程、wait的线程，从Linux系统的角度来说，都处于S（可中断睡眠）状态。

在Java中，除了long、double以外的变量（包括引用）的基本加载、存储是原子操作，因此这些变量的读、写操作不会存在中间状态。即便如此，没有任何保护错误的共享变量仍然是不安全的，因为Java的内存模型允许线程持有共享变量的本地内存（Local Memory，往往是寄存器）拷贝，这就意味着， 一个线程修改了某个共享变量后，其它线程可能不会立刻发现。解决这一问题的方法有两种：

1. 禁止直接访问变量，使用synchronized保护的getter/setter
2. 声明变量为volatile

第二种方法更加优雅，volatile可以理解为对单个变量的读写操作进行了同步（JSR-133），volatile关键字的作用包括：

1. 确保线程每次读取变量时，都去主存读取
2. 确保线程每次写入变量时，都写出到主存
3. Happens-Before原则：对volatile字段的写操作，必然发生在后续读操作之前

volatile关键字可以用在各种基本类型的变量上，甚至是数组或者对象，但是对于后两者，其volatile语义是作用在引用（指针）上。合理使用volatile可以避免不必要的同步操作，从而提高应用程序性能。

Java5的concurrent包引入接口：

java.util.concurrent.locks.Lock

public class MainClass
{
    private Lock   lock;

    private Object shared;

    public void operation()
    {
        lock.lock(); //获得锁，如果无法得到，线程将进入不可中断的等待状态
        try
        {
            operate( shared ); //操作共享资源
        }
        finally
        {
            lock.unlock(); //释放锁
        }
    }
}

Lock接口提供了比synchronized更加细致的控制方式，它提供以下方法： 

Lock最常用的实现是：

ReentrantLock

所谓公平锁是指相对公平的响应锁请求的线程，避免发生线程饥饿现象（一直等待而无法得到锁）。

new ReentrantLock(true)

JVM可以在不影响语义的情况下，对执行指令的顺序进行重新排列。这种重排是不考虑并发效应的：

private int i;
private int j;
public void set()
{
    //下面两个语句的顺序JVM可以重排
    i = 0;
    j = 1; //该语句可以重排到该方法的任何地方
    if ( i == 0 ) //i = 0的指令必须在这一句前面
        i = 1;
}

这种指令重排机制可能导致多线程程序的运行结果和预期不符，因此不要尝试依靠代码顺序来避免同步，典型的反例是双重检查惯例。synchronized机制可以有效的避免指令重排效应。

在JSR-133中， volatile的语义被增强，禁止了volatile变量与普通变量之间重排序。因此Java5之后，volatile与synchronized具有类似的语义——针对单个变量读写的锁。

Java5的concurrent包引入了若干Atomic类，这些类支持以原子的方式进行操作，可以避免同步、提高性能。

Atomic家族在内部实现上使用了一种乐观同步机制：当前线程假设没有其它线程修改共享变量，并计算变量的新值，在尝试更新变量时检查是否有其它线程对变量进行了修改，如果被修改，则使用最新的值重新执行前面的步骤。

不管是Java还是数据库，死锁的发生都有一个前提，那就是消费者在独占（不释放）某些资源的同时，又请求其它资源的独占，消费者在Java中就是线程，资源就是对象监视器或者锁。

一个经典的死锁例子是“哲学家进餐问题”，该问题的描述如下：

1. N位哲学家坐在圆桌上，它们只做两件事情，思考和吃饭
2. 圆桌中间放着一大盘米饭，每位哲学家左右两边各放一只筷子，共计N只筷子
3. 哲学家必须先拿起左边的筷子，然后再拿起右边的筷子，才能把米饭盛到自己的碗里

由于哲学家们从不交流，就可能导致吃不上饭的问题：每位哲学家都拿着左手的筷子，并等着右手的筷子。

在这个场景中，筷子就是共享资源，每位哲学家都会尝试在得到一个资源的同同时，请求另外一个资源。致命的是，这些资源请求形成了一个环路，导致任何一个资源都永远无法释放。

下面是哲学家问题的Java代码：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.commons.lang3.RandomUtils;

public class PhilosopherProblem
{
    private static void printf( String fmt, Object... args )
    {
        System.out.println( Thread.currentThread().getName() + " " + String.format( fmt, args ) );
    }

    private static class Chopstick extends ReentrantLock
    {
        private static final long serialVersionUID = 1L;

        private int               id;

        public Chopstick( int id )
        {
            super();
            this.id = id;
        }

        @Override
        public void lock()
        {
            super.lock();
            printf( "got chopstick %s", id );
        }

        @Override
        public void unlock()
        {
            super.unlock();
            printf( "released chopstick %s", id );
        }
    }

    private static class Philosopher extends Thread
    {
        private Chopstick left;

        private Chopstick right;

        public Philosopher( String name, Chopstick left, Chopstick right )
        {
            super();
            this.left = left;
            this.right = right;
            setName( name );
        }

        @Override
        public void run()
        {
            for ( ;; )
            {
                try
                {
                    meditate();
                    eat();
                }
                catch ( InterruptedException e )
                {
                    e.printStackTrace();
                }
            }
        }

        public void meditate() throws InterruptedException
        {
            int ms = RandomUtils.nextInt( 1000, 10000 );
            TimeUnit.MILLISECONDS.sleep( ms );
            printf( "meditated for %d ms", ms );
        }

        public void eat() throws InterruptedException
        {
            try
            {
                left.lock();
                try
                {
                    right.lock();
                    int ms = RandomUtils.nextInt( 1000, 10000 );
                    TimeUnit.MILLISECONDS.sleep( ms );
                    printf( "ate for %d ms", ms );
                }
                finally
                {
                    right.unlock();
                }
            }
            finally
            {
                left.lock();
            }
        }
    }

    public static void main( String[] args )
    {
        Chopstick cs0 = new Chopstick( 0 );
        Chopstick cs1 = new Chopstick( 1 );
        Chopstick cs2 = new Chopstick( 2 );
        Chopstick cs3 = new Chopstick( 3 );
        Chopstick cs4 = new Chopstick( 4 );
        new Philosopher( "Socrates", cs0, cs1 ).start();
        new Philosopher( "Plato", cs1, cs2 ).start();
        new Philosopher( "Aristotle", cs2, cs3 ).start();
        new Philosopher( "Thales", cs3, cs4 ).start();
        new Philosopher( "Pythagoras", cs4, cs0 ).start();
    }
}

程序运行起来后，很快即陷入死锁，不再有任何输出。 很多工具（TPTP、JProfiler、JMC）可以协助识别死锁，帮助改进程序。例如JMC检测上述程序死锁的输出如下：

1. 当持有一个锁的时候，线程应当避免再去获得其它锁
2. 确保相关的锁总是以一致的顺序被获得
3. 总是在

   finally

    块中调用

   unlock()

    
4. 使用时限锁：

   tryLock()

    ，在指定时间内没有获得锁则退出，而不是一直等待

每个Java对象都有一个伴随的监视器（Monitor）对象，使用监视器可以实现锁定。同样的每个对象也有一种机制让它称为等待区，这种机制的想法其实很单纯：

1. 某个线程等待一个特定条件的出现
2. 其它线程可以为它创建这个条件
3. 当其它线程创建条件时，会通知正在等待该条件的线程

该等待-通知机制是通过定义在

java.lang.Object

synchronized(object){}

表格里面已经提到，等待通知机制中的方法都需要持有目标对象的监视器，这是因为该机制本身存在竞态条件问题，因而必须结合锁一起使用。等待-通知机制的竞态条件场景举例如下：

1. Thread1测试条件（通常是一个共享的变量），确认它需要等待
2. Thread2设置条件
3. Thread2调用notify()，试图唤醒Thread1，但是这不会成功，因为Thread1尚未等待
4. Thread1调用wait()方法进入等待

等待通知机制不会在调用wait()与释放锁之间、返回wait()与重新获得锁之间发生竞态条件。

对于wait()的调用一般都位于循环结构中，另外需要注意：

1. 线程应该总是在持有锁时、在wait()之前测试条件不满足，然后调用wait()等待
2. 线程应该总是从wait()返回后，判断条件是否满足，还是需要继续等待。因为可能有其它线程也被唤醒，并且它改变了条件（即使被唤醒，也不代表条件满足）

下面是一个简单的例子：

public class WaitAndNotifyMechanism
{
    private static boolean condition;
    private static Object lock = new Object();
    private static class Consumer extends Thread
    {
        @Override
        public void run()
        {
            for ( ;; )
            {
                try
                {
                    //这里是一个全局锁，因此锁定哪个对象不重要，只要对象是全局唯一的
                    //甚至可以把WaitAndNotifyMechanism.lock作为锁
                    synchronized ( WaitAndNotifyMechanism.class )
                    {
                        //检测条件时必须锁定
                        if ( condition )
                        {
                            condition = false; //消费
                            System.out.println( currentThread().getName() );
                        }
                        WaitAndNotifyMechanism.class.wait(); //但是必须调用作为锁的对象的wait()方法
                    }
                }
                catch ( InterruptedException e )
                {
                }
            }
        }
    }

    public static void main( String[] args ) throws InterruptedException
    {
        //两个消费者
        new Consumer().start();
        new Consumer().start();
        //主线程扮演的生产者
        for ( ;; )
        {
            TimeUnit.SECONDS.sleep( RandomUtils.nextInt( 1, 6 ) );
            //修改条件时必须锁定
            synchronized ( WaitAndNotifyMechanism.class )
            {
                if ( !condition )
                {
                    condition = true; //生产
                    WaitAndNotifyMechanism.class.notify(); //唤醒一个等待的线程
                }
            }
        }
    }
}

条件变量是有某个锁关联的变量，它是很多线程系统使用的同步模型，它与Java的等待-唤醒机制很类似。POSIX条件变量的四个基本函数——wait()、timed_wait()、signal()、broadcast()与Java中Object的方法一一对应，它们在逻辑上处理上也是一致的。条件变量的wait()、signal()操作需要当前线程持有互斥锁， 从wait()调用返回时需要重新得到互斥锁。

但是Java的等待-唤醒机制更加易用，它相当于把条件变量与互斥锁整合在了一起，因而在synchronized代码块中调用被同步对象的wait()、notify()方法是很自然的操作方式。

Java5引入的Lock接口，支持创建条件变量，Lock与Condition是绑定的，就像既有的等待-唤醒机制一样。这两个接口提供的灵活性就像其它线程系统的条件变量一样。下面是一个来自JDK的例子，我们可以看一下条件变量的用法：

/**
 * 一个有界的缓冲区
 * @param <T> 缓冲区元素类型
 */
class BoundedBuffer<T>
{
    //互斥锁对象
    private final Lock      lock     = new ReentrantLock();

    //从互斥锁创建两个条件变量，条件变量和锁是绑定的
    private final Condition notFull  = lock.newCondition(); //消费者通知生产者用

    private final Condition notEmpty = lock.newCondition(); //生产者通知消费者用

    private int             putptr, takeptr, count;

    private T[]             items;

    @SuppressWarnings ( "unchecked" )
    public BoundedBuffer( int capacity )
    {
        items = (T[]) new Object[capacity];
    }

    //由消费者线程调用
    public void put( T x ) throws InterruptedException
    {
        //修改共享数据，因此首先需要互斥锁定
        lock.lock();
        try
        {
            while ( count == items.length )
                //如果缓冲区目前是满的，放弃锁定并等待
                //与既有的等待-唤醒机制一样，在唤醒后，需要重新获得锁
                notFull.await();
            items[putptr] = x;
            if ( ++putptr == items.length ) putptr = 0;
            ++count;
            //唤醒正在等待缓冲非空信号的消费者线程
            notEmpty.signal();
        }
        finally
        {
            lock.unlock(); //总是解除锁定
        }
    }

    //由生产者线程调用
    public Object take() throws InterruptedException
    {
        lock.lock();
        try
        {
            while ( count == 0 )
                notEmpty.await(); //如果当前缓冲区为空，等待
            T x = items[takeptr];
            if ( ++takeptr == items.length ) takeptr = 0;
            --count;
            notFull.signal(); //唤醒等待缓冲区非满的生产者线程
            return x;
        }
        finally
        {
            lock.unlock();
        }
    }
}

条件变量比起既有的等待-唤醒机制，其优势在于：

1. 使用Lock时，Condition是必要的，因为Lock的wait/notify方法已经被覆盖，用来实现Lock对象的功能
2.  每个Lock可以创建多个对应的Condition，通过给Condition变量进行合理命名，可以使代码的语义更加直白

从JDK1.2开始，ThreadLocal类被引入。该类用于存放线程本地（Local，局部）变量。这种变量与普通的共享变量不同，它为每个线程设置不同的副本，不同线程之间互不干扰。

ThreadLocal往往添加

private static

static getter()

class SharedObject{
    //普通变量，会被多个线程共享，存在并发问题
    private static Map<String,String> normalVariables; 
    //线程本地变量，每个线程都有自己的副本，不存在并发问题
    private static ThreadLocal<Map<String,String>> variables = new ThreadLocal<Map<String,String>>(){
        //可以覆盖此方法，为每个线程的副本提供初值
        protected Map<String,String> initialValue() {
            return new HashMap<String,String>();
        };
    };

    public static ThreadLocal<Map<String,String>> getVariables()
    {
        return variables;
    }
}

调用ThreadLocal的set/get方法，可以设置、读取本地变量的值，在JDK1.5之后，ThreadLocal类提供了泛型支持。

线程本地变量常被用来避免方法调用的参数传递，理论上将，可以使用线程本地变量完全取代方法参数，而保持等同的应用逻辑。

除非存在外部引用，否则线程本地变量将在线程终结时自动回收。

在Java中，信号量基本上可以认为是带有计数器的Lock。计数器许可只有1的信号量和Lock是一回事，除了某些Lock的实现支持重入。下面的代码是一个通用的固定大小对象池，演示了信号量的用法：

package cc.gmem.study.j5ia.concurrent.adv;

import java.util.List;
import java.util.concurrent.Semaphore;

public class CommonPool<T>
{
    private int         maxPoolSize;

    private Semaphore   available;

    protected T[]       items;

    protected boolean[] used;

    @SuppressWarnings ( "unchecked" )
    public CommonPool( List<? extends T> objects )
    {
        //对象池的最大尺寸
        this.maxPoolSize = objects.size();
        //对象池内存存储结构数组
        this.items = (T[]) objects.toArray();
        //构建一个许可数目与对象池大小相同的公平信号量
        this.available = new Semaphore( maxPoolSize, true );
        this.used = new boolean[maxPoolSize];
    }

    /**
     * 从池中借出一个对象
     */
    public T borrowItem() throws InterruptedException
    {
        //首先，当前线程需要获取一个许可，如果没有需求，则陷入等待
        available.acquire();
        return getNextAvailableItem();
    }

    /**
     * 归还一个对象到池中
     */
    public void returnItem( T item )
    {
        if ( markAsUnused( item ) ) //只有是池里既有的对象才能放回去
            //如果返回成功，则释放一个许可
            available.release();
    }

    /**
     * 获取下一个可用对象
     */
    protected synchronized T getNextAvailableItem()
    {
        for ( int i = 0; i < maxPoolSize; ++i )
        {
            if ( !used[i] )
            {
                used[i] = true;
                return items[i];
            }
        }
        return null;
    }

    /**
     * 标记某个对象为可用
     */
    protected synchronized boolean markAsUnused( T item )
    {
        for ( int i = 0; i < maxPoolSize; ++i )
        {
            if ( item == items[i] )
            {
                if ( used[i] )
                {
                    used[i] = false;
                    return true;
                }
                else return false;
            }
        }
        return false;
    }
}

对象池的测试代码：

List<Object> objects = new ArrayList<Object>();
objects.add( new Object() );
objects.add( new Object() );
objects.add( new Object() );
final CommonPool<Object> pool = new CommonPool<Object>( objects );
//把三个对象都借走
Object[] borrowed = new Object[] { pool.borrowItem(), pool.borrowItem(), pool.borrowItem() };
new Thread() {
    public void run()
    {
        try
        {
            //阻塞，直到3秒后
            pool.borrowItem();
            System.out.println( "Borrowed an object." );
            //阻塞，直到3秒后
            pool.borrowItem();
            System.out.println( "Borrowed another object." );
        }
        catch ( InterruptedException e )
        {
        }
    }
}.start();

for ( Object item : borrowed )
{
    TimeUnit.SECONDS.sleep( 3 );
    pool.returnItem( item );
}

屏障类很简单，允许多个线程在一个屏障点集中，汇总结果、并继续下一步工作。下面我们以公司组织去水长城旅游的例子来说明该类的用法：

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.time.DateFormatUtils;

public class GreatWaterWallTourism
{
    /**
     * 小院屏障：所有车到小院集合，换乘旅游大巴
     */
    private static CyclicBarrier farmyardBarrier;

    /**
     * 去往水长城的旅游大巴
     */
    private static TouristBus    touristBus;

    private static class TouristBus extends Thread
    {
        private List<String> persons = new ArrayList<String>();

        public void getOn( List<String> persons )
        {
            this.persons.addAll( persons );
        }

        @Override
        public void run()
        {
            System.out.println( persons + " are leaving for the great water wall" );
        }
    }

    /**
     * 去往小院的交通工具
     */
    private abstract static class Vehicle extends Thread
    {

        protected List<String> persons = new ArrayList<String>();

        @Override
        public void run()
        {

            try
            {
                doRun();
                farmyardBarrier.await(); //等待其它车辆抵达
                touristBus.getOn( persons ); //把人装进旅游大巴
            }
            catch ( Exception e )
            {
            }

        }

        protected String now()
        {
            return DateFormatUtils.format( Calendar.getInstance(), "HH:mm:ss" );
        }

        protected abstract void doRun() throws InterruptedException;
    }

    /**
     * 小汽车
     */
    private static class Car extends Vehicle
    {
        protected void doRun() throws InterruptedException
        {
            persons.add( "Fu Chang" );
            persons.add( "Bing Lee" );
            System.out.println( persons + " are going to the farmyard by car" );
            TimeUnit.SECONDS.sleep( 1 );
            System.out.println( "Car arrived at " + now() );
        }
    }

    /**
     * 十一路
     */
    private tatic class BusNo11 extends Vehicle
    {

        @Override
        protected void doRun() throws InterruptedException
        {
            persons.add( "Zhen Wong" );
            System.out.println( persons + " are taking bus number 11 to the farmyard" );
            TimeUnit.SECONDS.sleep( 10 );
            System.out.println( "Bus number 11 arrived at " + now() );
        }

    }

    public static void main( String[] args ) throws Exception
    {
        touristBus = new TouristBus();
        farmyardBarrier = new CyclicBarrier( 3 );

        new Car().start();
        new BusNo11().start();
        farmyardBarrier.await();

        System.out.println( "Tourist bus is about to depart after 3s" );
        TimeUnit.SECONDS.sleep( 3 );
        touristBus.start();
    }
}

输出内容如下：

[Fu Chang, Bing Lee] are going to the farmyard by car
[Zhen Wong] are taking bus number 11 to the farmyard
Car arrived at 14:18:52
Bus number 11 arrived at 14:19:01
Tourist bus is about to depart after 3s
[Zhen Wong, Fu Chang, Bing Lee] are leaving for the great water wall

倒数计数器，这个类和屏障类很相似，它允许一个或者多个线程等待计数变为零，任何线程都可以将计数器的值倒数：

//计数为3的倒数门栓
final CountDownLatch latch = new CountDownLatch( 3 );
latch.countDown(); //减少计数
new Thread() {
    public void run()
    {
        try
        {
            TimeUnit.SECONDS.sleep( 3 );
        }
        catch ( InterruptedException e )
        {
        }
        latch.countDown();//减少计数
        latch.countDown();//减少计数
    };
}.start();
latch.await();//等待计数为0

定义一个交换点（同步点），两个线程会在此点交换数据，先到达的线程会等待，直到配对的线程到达。下面举一个早教中心运动课的例子，参与的孩子们相互传球玩：

public class BallExchangeGame
{
    private static Exchanger<Ball> ballExchanger = new Exchanger<Ball>();

    private static class Ball
    {
        private String color;

        public Ball( String color )
        {
            super();
            this.color = color;
        }

        public String toString()
        {
            return color + " ball";
        }
    }

    private static class Child extends Thread
    {
        private Ball ownedBall;

        public Child( String name, Ball ownedBall )
        {
            super();
            setName( name );
            this.ownedBall = ownedBall;
        }

        @Override
        public void run()
        {
            for ( ;; )
            {
                try
                {
                    TimeUnit.SECONDS.sleep( RandomUtils.nextInt( 1, 10 ) );
                    ownedBall = ballExchanger.exchange( ownedBall );
                    System.out.println( getName() + " got " + ownedBall );
                }
                catch ( InterruptedException e )
                {
                }
            }
        }
    }

    public static void main( String[] args ) throws InterruptedException
    {
        new Child( "Cai Cai", new Ball( "Colorized" ) ).start();
        new Child( "Yu Han", new Ball( "Red" ) ).start();
        new Child( "Tiao Tiao", new Ball( "Black" ) ).start();
    }
}

 观察该程序输出时，会发现控制台总是成对的打印41行的内容，这是因为“交换”是相互的，先提出交换的孩子必须等待另外一个孩子也愿意交换。

JDK 1.5包含读写锁接口ReadWriteLock，它简单的包含两个方法，分别用于获得读锁（

Lock readLock()

Lock writeLock()

JDK自带的读写锁实现类是一个可重入的锁：

ReentrantReadWriteLock

从概念上讲，每个JVM线程在整个生命周期中，必然处于下列状态之一：

Java线程调度是基于优先级进行的，但是最终还是受制于具体的操作系统，大部分基于抢占式调度的OS能够很好的支持这种调度方式。

Java中定义了11个优先级，其中开发者可以用到其中的十个（从

Thread.MIN_PRIORITY

Thread.MAX_PRIORITY

需要注意的是，并不是优先级低的线程总是要等待优先级低的线程让出CPU，为了防止线程饥饿，OS会进行较为复杂的公式计算，来决定到底哪个线程被调度执行。

JDK提供的一些方法可以显式的影响线程调度，例如suspend()可以让当前线程保持在Blocked状态，resume()则让其恢复，但是这两个方法已经被废弃了。

Thread.yield()

The post Java线程与并发编程 appeared first on 绿色记忆.

泛型，也称为参数化类型，是很多语言支持的编程范式——在定义类型、接口或者方法时将类型作为参数。Java诞生以来最重大的语法改变当属泛型，它是Java5最重要的特性。Java泛型与C++的模板机制在形式上有些类似，但是Java泛型的实现方式——类型擦除导致二者有着根本性的不同。

使用泛型，可以获得以下好处：

1. 在编译期获得更好的类型检查
2. 消除不必要的强制转型代码
3. 允许编程人员实现泛型算法

使用泛型机制设计的类，最常见的是容器类，Java5的集合框架大量使用了泛型机制（类似于C++的STL库）：

public interface Collection<E>{};
public interface Set<E>{};
public interface List<E>{};
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{};
public interface Map<K,V> {}

但是，任何字段、方法参数、方法返回值需要参数化的类型，都可以从泛型机制获益，例如下面这个通用的回调接口： 

interface Callback<P,R>{
    R invoke(P p);
}

所谓泛型类型（ generic type），是指通过类型参数化的类/接口，这种类型的声明语法为：

class ClassName<T1,...Tn>{
    // T1...Tn是将ClassName参数化的类型形参（type parameter），或者叫类型变量（type variables），可以有1-N个
}
// 示例：
class Container<I> {
    private I item;
    void put(I i) {
        item = i;
    }
    I get() {
        return item;
    }
}

类型形参可以在类定义的任何地方引用。类型参数只是一个占位符，它可以表示任意一种非基本（non-primitive ）类型。根据惯例，类型形参使用单个大写字母表示，一般E表示“元素”、K表示“键”、N表示“数字”、T表示“类型”、V表示“值”，等等。

要在代码中使用一个泛型类型，必须进行泛型类型调用（generic type invocation），此时必须把类型形参（type parameter）替换为类型实参（ type argument），后者是真实的Java类型：

Container<Number> cn = new Container<Number>();
// Java 7引入了钻石操作符，可以根据cn的变量类型推倒构造器的type argument：
Container<Number> cn = new Container<>();

作为类型实参的Java类型，其本身也可以是泛型类型：

// 不管嵌套多少层，泛型类型的类型参数都不能是占位符
Container<List<String>> cn = new Container<>();
// 下面的语句非法，E不是可解析的真实类型
Container<List<E>> cn = new Container<>();

所谓原始类型，是指在不指定类型实参的情况下使用泛型，例如：

ArrayList list = new ArrayList()

混合使用泛型、原始类型，会在编译时得到未检查错误信息（Unchecked Error Messages），所谓Unchecked表示编译器无法得到足够的信息来完成类型推断以确保安全性。要禁止此类错误信息，可以使用编译选项

-Xlint:-unchecked

@SuppressWarnings("unchecked")

不但类可以设计为泛型，方法也可以。方法可以使用类声明的泛型形参，亦可自己声明泛型参数，声明自己的泛型参数的方法称为泛型方法（Generic method），例如：

public class Math {
    // 泛型方法，泛型形参列表必须在返回值之前声明：
    public static <RET, ARG0, ARG1> RET plus( ARG0 arg0, ARG1 arg1 ) {
        return (RET) null;
    }
}

调用泛型方法的完整语法如下：

Integer result = Math.<Integer, Double, Double>plus( 1.1, 1.2 );

指定泛型实参列表 不是必须的，通常编译器能够根据上下文推断。编译器的这种能力称为type inference。

Java泛型支持限制可作为泛型实参的类型的范围。例如上面的plus方法，可能仅仅支持数字类型。要声明受限泛型形参，需要使用extends关键字：

public static <RET, ARG0 extends Number, ARG1 extends Number> RET plus( ARG0 arg0, ARG1 arg1 ) {
    return (RET) null;
}

使用受限形参，方法体可以对形参的类型进行假设，这样就可以执行有意义的方法调用了：

public static <T extends Comparable<T>> int countGreaterThan( T[] anArray, T elem ) {
    int count = 0;
    for ( T e : anArray )
        // 调用比较方法，因为T必须是Comparable的子类型
        if ( e.compareTo( elem ) > 0 )
            ++count;
    return count;
} 

可以在限制泛型实参必须是某个类型或者其子类型的同时，限制它必须实现某些接口：

// 多个接口用 & 符号分隔
public static <T extends Entity & Serializable> void save(T t){}

可以在字段、方法形参、变量的声明中使用（不受限的）泛型通配符，使用

?

1. 泛型类中返回参数类型的方法，类型自动变为Object
2. 泛型类中需要参数类型作为入参的方法，将不能接受任何对象

例如泛型类：

public class Value<T> {
    private T t;
    public Value( T t ){
        this.t = t;
    }
    public void set( T t ){
        this.t = t;
    }
    public T get(){
        return t;
    }
}

如果声明参数类型为通配符：

Value<?> value = new Value<Integer>( 1 );
Object o = value.get(); //可以通过编译，你不知道是什么类型，所以我们给你一个根类型
value.set( 1 ); //无法通过编译，不是我们不限制类型，而是你不知道是什么类型

就意味着，你可以从泛型对获取参数类型对象，但是却不能提供了。 

Java 5还支持受限泛型通配符的声明，所谓受限是指，变量/返回值/参数的泛型参数必须满足限制：

1. Type<? extends PType>

    ：上限通配符（Upper Bounded Wildcard），表示变量的类型参数必须是PType或者PType的子类型

2. Type<? super PType>

    ：下限通配符（Lower Bounded Wildcard），表示变量的类型参数必须是PType或者PType的超类型

在设计一个接收泛型入参的接口时，如果你需要向入参提供一个对象，可以使用下限通配符，因为这可以确保你提供的对象可以被接受：

public static void addNumbers( List<? super Integer> list ) {
    // list的实参可以是Integer，或者Number，或者Object，但是必然能容纳int类型
    for ( int i = 1; i <= 10; i++ ) {
        list.add( i );
    }
}

在设计一个接收泛型入参的接口时，如果你需要使用入参提供的对象，可以使用上限通配符，这样你可以假设对象的类型：

public static void process( List<? extends Number> list ) {
    // list的实参可以是Integer，或者Number，或者Double，但是都可以针对其调用Number的接口
    for ( Number n : list ) {
        n.intValue();
    }
}

上面的两条，就是所谓的PECS原则：当泛型对象作为生产者（对外提供对象）时，将其泛型形参声明为上限通配符（extends）；当泛型对象作为消费者时，将其泛型形参声明为下限通配符（super） ，下面的例子有助于进一步理解PECS：

Value<? extends Number> valueExtend = new Value<Integer>( 1 );
//有了这个变量声明，我知道类型参数必然是Number的子类型：
Number num = valueExtend.get();
//但是，具体是Integer，还是Double，我不知道，因此我无法提供参数类型的实例
valueExtend.set( 1 ); //无法编译

Value<? super Number> valueSuper = new Value<Number>( 1 );
//有了这个变量声明，我知道类型参数必然是Number的超类型：
valueSuper.set( new Integer( 1 ) ); //那么，我当然可以提供Number的子类型给你
//但是，我却不知道类型参数的真实类型
Object obj = valueSuper.get(); //所以此变量提供的参数类型未知

class BoundedBuffer<T>
{
    private T[]             items;
}

但是，就像不能实例化参数类型一样，你也不能实例化参数类型的数组：

T t = new T();        //无法通过编译，无法提供数组需要的运行时信息
T[] ts  = new T[10];  //无法通过编译，编译器甚至无法确认T类型有默认构造器

不能实例化的原因是，Java中的数组在运行时必须知道其元素的类型。上述语法无法提供这一类型信息——因为T是什么在编译时根本不知道。因此泛型数组如果需要在泛型内部初始化，必须进行变通：

T[] ts = (T[]) new Object[10];

注意绝大部分的参数化类型信息都在编译期间擦除了，除了继承自泛型类的子类型，可以通过反射得到父类上的真实参数类型：

//它的泛型父类的类型信息String不会被擦除
class StringList extends ArrayList<String> //和C++的模板特化有些类似
{
    private static final long serialVersionUID = 1L;
}

//可以使用下面的代码获得泛型父类的真实参数类型
ParameterizedType type = (ParameterizedType) new StringList().getClass().getGenericSuperclass();
assert ( type.getActualTypeArguments()[0] == String.class );

需要注意泛型是“非协变”的，参数类型不同的泛型变量不能相互转换，即使这些参数类型之间存在继承关系：

//数组是协变的
Object oa[] = new Integer[] {};
//泛型不是，尽管泛型实参Object和Number具有父子类关系。但是List<Object>、List<Number>之类不存在父子类关系
List<Object> ol = new ArrayList<Number>(); //无法编译

使用上限通配符，可以解决非协变特性导致的无法赋值问题：

List<? extends Object> ol = new ArrayList<Number>();  

继承泛型类型时，可以将全部或者部分泛型参数“特化”：

// 完全特化
abstract class StringList implements List<String> {}
// 部分特化
abstract class StringKeyMap<V> implements Map<String,V> {}

注意：上面的例子中，任何StringList是List的子类型，StringKeyMap是Map的子类型。在特化类型参数的同时，你可以获得重写父类逻辑的机会。

注解在Java5中第一次成为可以影响编程方式的语言元素，注解可以为类、字段、方法、甚至注解本身提供元数据信息。注解的出现将很大程度上改变可配置化对XML高度依赖的现状。

声明注解需要使用特殊的类型说明符：

@interface

//某些注解可以用来修饰注解类型本身
@Retention ( RetentionPolicy.RUNTIME )
//提示该注解需要在运行期保留
@Target ( ElementType.METHOD )
//提示该注解只能作用于方法上
@interface AutoExtAjaxResult
{
    //注解中可以声明多个“方法”，用来指示注解实例的属性名
    String value(); //value是一个特殊属性，如果注解只有这一个属性，在实例化注解时，可以不指定属性名
    Class<?> type() default App.class; //注解属性可以提供默认值
}

需要注意的是，注解属性只支持有限的类型：基本类型、字符串、注解、枚举、Class，或者这些类型的一维数组。

要使用（实例化）注解，只需要在目标类/方法/字段的声明前面添加@注解名，并提供必要的参数，所有没有提供默认值的属性都需要提供值：

@AutoExtAjaxResult ( "Avalue" )
public String userInfo()
{
    return null;
}

要在运行时获取某个类/方法/字段上被附加的注解，需要使用反射机制，例如：

App.class.getMethod( "userInfo" ).getAnnotation( AutoExtAjaxResult.class ).value(); // Avalue

数组以及任何实现了

java.lang.Iterable

for ( char c : new char[] { 'H', 'E', 'L', 'L', 'O' } ) {
    System.out.println( c );
}
for ( String str : new ArrayList() ) {
    System.out.println( str );
}

现在基本类型与其包装类型的转换，可以自动进行了：

Number n = 1L;
Double d = 1.1d;
Boolean b = false;
boolean bp = Boolean.TRUE;
double dp = Double.valueOf( 1.1d );
long lp = new Long( 1l );

Java5中，枚举被作为一种特殊的类，可以使用enum关键字来声明，枚举类型不支持创建新实例。

枚举类型和普通类一样可以有字段、方法、构造器等部分，特别的是，枚举实例可以对方法进行覆盖。

public enum Color
{
    RED( "FF0000" ),
    GREEN( "00FF00" ),
    BLUE( "0000FF" )
    {
        //每个枚举值可以覆盖方法
        public String toString()
        {
            return "00F";
        }
    };
    //和普通类一样，枚举可以具有字段、方法、构造器
    private String code;

    private Color( String code )
    {
        this.code = code;
    }

    @Override
    public String toString()
    {
        return code;
    }
}

特殊的语法可以声明方法接受不定长度的参数，变长参数的声明必须位于形参列表的尾部：

public static void main( String[] args )
{
    varargsMethod( 1, 2, "1", "2", "3" );
    varargsMethod0( "1", "2", "3" );
}

private static void varargsMethod0( String... strs )
{
}

private static void varargsMethod( int i, int j, String... strs )
{
}

可以使用import static语法导入某些类中的静态方法，在当前文件中不需要提供这些类的名字就可以直接调用静态方法：

import static java.util.Collections.*;

public static void main( String[] args )
{
    sort( list ); //不需要提供Collections类名
}

这是一个Java5引入的专门用于并发编程的新包，该包主要有以下组件：

1. 支持并发的集合类型，位于java.util.concurrent包
2. 原子操作类，这些原子操作类受益于JVM引入了CAS（Compare-And-Set）机制，位于java.util.concurrent.atomic包
3. 新的同步原语，主要是一些锁类，位于java.util.concurrent.locks包
4. 并发相关工具，例如线程池、信号量等
5. 异步相关类，例如Future、Executor

concurrent中的集合类图如下（深色表示JDK 1.6追加）：

可以看到类很多，因此不一一描述，仅将类名中单词的含义列在下表：

concurrent.atomic包中的原子操作类包括：Boolean、Integer、Long、引用的原子类及其数组类型。

concurrent.locks包引入了一些用于支持锁定的类和接口，改变了Java只能依靠

synchronized

该包主要有三个接口：

synchronized

Condition)

synchronized

java.lang.Object

和异步编程有关的接口主要有四个：

1. Future接口表示一个“在未来某个时间点可用的结果”
2. Callable表示一个可调用对象
3. Executor接口可以用来执行一个Runnable
4. CompletionService则可用来调用Callable并（异步）获得结果

这些类的层次结构如下：

concurrent包包含的其它工具类有：

The post Java5新特性 appeared first on 绿色记忆.