java基础--线程（oracle文档的摘录）

此文是oracle关于Concurrency的文档的部分翻译，只摘取了部分内容，并且由于水平原因，翻译的并不准确，这里只做为java学习的一个笔记。有任何疑问可以参考原文：http://docs.oracle.com/javase/tutorial/essential/concurrency/index.html

在并发编程中，有两个执行的基本单元：进程和线程。在java中，并发编程更关注线程。

计算机系统拥有多个处理器或多核的处理器越来越普遍，这加强了系统并发运行进程和线程的能力。

进程：

一个进程拥有独立的(self-contained)执行环，一般一个线程会拥有一个完整的，私有的基本运行时资源的集合。特别是拥有自己的内存空间。

java程序可以通过ProcessBuilder对象来创建新的进程。

线程：

线程有时候可以当作轻量级线程。线程和进程都提供了一个可执行的环境，但是创建一个新线程所需的资源比创建一个新进程所需的资源少。

线程存在进程内部——每个进程至少有一个线程。线程共享进程的资源，包括内存和公开文档（oracle官方文档是这样写的open files，但是不知道具体该如何翻译）。

想创建Thraed的实例需要提供将在该线程中运行的代码，有两种方式实现：

1. 提供一个实现Runnable接口的对象
2. 继承Thread类

应该使用哪种风格(idioms)呢？第一种更常用，不仅仅因为它更灵活，而且可以在以后被高级的线程管理接口覆盖。不过Thread类定义了一些有用的线程管理方法，包括可以提供调用方法的线程信息和管理调用方法的线程状态的static方法，也有其他线程调用来管理线程和线程对象的方法。 These include static methods, which provide information about, or affect the status of, the thread invoking the method. The other methods are invoked from other threads involved in managing the thread and Thread object.）

中断interrupts：

interrupt表明一个线程应该停止当前正在执行的代码，而去执行别的代码。一个线程如何响应一个interrupt有程序员决定，非常普遍的是终止该线程。

joins：

join方法允许一个线程等待另一个线程执行完成。当前线程会暂停，等待调用join方法的线程执行完成。join的重载方法可以指定等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。和sleep方法一样，join方法也是依赖底层系统的计时器，所以不要期望join会刚好等待你输入的时间。

同步性：

线程和线程通信主要通过共享访问字段和引用字段指向的对象。这种通信模式非常高效，但是有可能产生两种错误：线程冲突和内存一致性错误。用来避免这两种错误的工具是同步。

然而当两个或以上的线程尝试同时访问相同资源的时候，同步会造成线程争夺资源。

线程冲突：

当两种操作，运行在不同的线程上，但是操作同一个数据，交错执行，就会发送冲突。意味着两个操作包含多个步骤，而这些步骤的顺序有重叠。

内存一致性错误：

两不同线程对本该看到相同数据，实际上却不同的时候会发生内存一致性错误。程序员并不需要详细了解导致该错误的原因，只需要有策略避免就可以。避免该错误的关键是了解之前发生(happens-before)的关系。确保内存通过具体的语句写入数据对另一条具体语句是可见的。

有几种方法来建立happens-before关系，其中一种就是同步。

同步函数：

java编程语言提供两种基本的同步风格：同步函数和同步代码块。

不可能两次调用同一个对象的同步方法发生交错。当执行一个对象的同步函数时，其他线程调用同一个对象的同步函数将会阻塞，直到第一个线程结束。当一个同步函数存在时它就自动和随后 对同一对象的同步函数的调用 建立了happens-before关系

构造函数不能被synchronized关键字修饰。Synchronizing constructors doesn't make sense, because only the thread that creates an object should have access to it while it is being constructed.

内在锁和同步Intrinsic Locks and Synchronization

每个对象都有一个和它相关的内在锁。 By convention, a thread that needs exclusive and consistent access to an object's fields has to acquire the object's intrinsic lock before accessing them, and then release the intrinsic lock when it's done with them. 

同步函数中的锁Locks In Synchronized Methods

当一个线程调用一个同步函数，它自动获取那个函数对象的内部锁，并且当函数返回的时候释放该锁。即使是不可捕捉异常导致的返回也会释放锁。

当一个静态同步函数被调用时，由于静态方法和类关联而不是和对象，线程获取和类关联的Class对象的内部锁，因此，访问类的静态字段由锁控制 这个锁和类的实例的锁不同。Thus access to class's static fields is controlled by a lock that's distinct from the lock for any instance of the class.

同步代码块Synchronized Statements

和同步函数不同，同步代码块必须指定提供内部锁的对象。

原子访问Atomic Access

原子操作要么一次性执行完，要么不执行，原子操作不能中途停下来。

java.util.concurrent包中的一些类提供不依赖同步的原子方法。

活性Liveness

活性是一个并发程序以一种及时的方式执行的能力。A concurrent application's ability to execute in a timely manner is known as its liveness.

死锁Deadlock

死锁描述了一种两个或以上的线程互相等待，永远阻塞的情形。

饥饿和活锁Starvation and Livelock

Starvation描述的是一个线程不能获取共享资源的常规访问而且不能前进的情形。

Livelock一般是对另一个线程的响应。Livelock和Deadlock一样不能前进，但是线程都没有阻塞。好比迎面走来的两个人互相让路，A向左让，B向右让。

不可变对象Immutable Object

一个对象被认为是不可变的如果在被构造后它的状态不能改变。

锁对象Lock Object

锁对象和同步代码使用的隐士锁工作很相像。

锁对象比隐士锁的最大优势在于有收回尝试获得锁的能力，尝试获取锁的时候，如果当前锁不可用或者过一段时间可用tryLock方法收回。

执行器接口Executor Interfaces

java.util.concurrent包定义了三种执行器接口：

Executor，简单接口，支持创建新任务。

ExecutorService ，是Executor的子接口，增加了帮助管理独立任务和执行器本身生命周期的特性。

ScheduledExecutorService，是ExecutorService的子接口，支持定时执行任务。

Executor接口

只提供了一个execute方法，被设计来替代一般的Thread-creation风格。

(new Thread(r)).start()  可用 e.executor(r);  -------r是Runnable对象，e是Executor对象。

ExecutorService接口

ExecutorService接口提供和execute相似但是更通用的submit方法，submit不仅接收Runnable对象，也接收Callable对象，Callable对象允许任务返回Future对象，Future用来取回Callable对象和管理Callable、Runnable任务的状态。

ScheduledExecutorService接口

ScheduledExecutorService接口除了提供父类Executor和ExecutorService 的函数外，还定义了scheduleAtFixedRate和scheduleWithFixedDelay，可以以指定的间隔重复执行指定任务。

线程池 Thread Pools

一个常用的线程池类型是fixed thread pool，这种类型的线程池一般有一个指定数量的线程在运行。当一个正在运行的线程莫名的终止了，它会自动被一个新线程替代。固定线程池的一个重要优势是应用程序用它平稳的降级。An important advantage of the fixed thread pool is that applications using it degrade gracefully.

newCachedThreadPool方法创建可扩展的线程池，这种Executor适合多个生存周期短的的任务。

newSingleThreadExecutor方法一次创建可以执行一个任务的executor。

Fork  /  Join  （Beta Draft In JDk 8 ）

fork/join框架是ExecutorService接口的实现，可以帮助充分利用多处理器的优势。它能将任务递归地分解成更小的片。该框架使用了一种叫work-stealing的算法。工作线程在运行完任务后可以从仍然忙碌的线程中“偷”任务。fork/join框架的中心是ForkJoinPool类，ForkJoinPool实现了核心work-stealing算法。

并发集合 Concurrent Collections

BlockingQueue 定义了一个先进先出的数据结构，当尝试向满队列增加或者检索空队列的时候会阻塞或超时。

ConcurrentMap 是java.util.Map的子接口，定义了有用的原子操作。

ConcurrentNavigableMap 是ConcurrentMap的子接口，支持近似匹配。

以上这些集合通过定义增加元素和随后访问或删除元素的操作之间的happends-before关系有助于避免内存一致性错误。 All of these collections help avoid Memory Concurrent Erroers by defining a happens-before relationship between an operation that adds an object to the collection with subsequent operations that access or remove that object.