在之前的学习过程中，已经不止一次地提到了并发啊，线程啊，同步异步的内容，但是出于内容的局部一体，之前总是几笔带过，并附上：以后学习的时候再细说。
那么，现在到了细说的时候，在翻阅并参考了介绍Java并发编程的书之后，突然感觉压力有些大，因为有些概念确实比较抽象。所以之后的内容不定长短，但是每天都会试着输出一些。
一个进程可以拥有多个线程，一个线程必须拥有一个父进程。
进程：当前操作系统正在执行的任务，也是操作系统运行程序的一次执行过程。
线程：是进程的执行单元，是进程中正在执行的子任务。
就好像我们正在使用的QQ，正在放歌的音乐软件，正在打的游戏，就是一个个的进程。我们在QQ进程中执行的各种操作，就是一个个的线程。
每个Java的应用程序运行的时候其实就是个进程，JVM启动之后，会创建一些进行自身常规管理的线程，如垃圾回收和终结管理，和一个运行main函数的主线程。
现在大部分的操作系统都是支持多进程并发运行的，就像我们现在正在使用电脑，可以通过任务管理器查查看，会发现有几十个几百个进程在“同时执行”。”同时执行“被打上了引号，显然事实上并不是。
并发：就拿进程来说，在同一个时刻，只能有一条指令执行，但是多个进程可以被快速地轮换执行，CPU的执行速度之快，让人产生这些个进程就是在同时执行。
并行：就是同一时刻，多条进程指令在多个处理器上同时执行。
看看下面的图就懂了：
接下来是我对于并发和并行假想场景：
并发场景：假设现在有一台只能一个人玩的电脑，老大和老二兄弟俩都想玩一小会儿，那没办法，得想办法解决啊。打一架吧，谁抢到算谁的。不管是谁抢到，他们一定玩到满足才会罢休，这就是现在操作系统所采用的高效率的抢占式多任务操作策略。
并行场景：现在有两台电脑，老大老二都各自玩各自的电脑，不争也不抢。
线程被称为轻量级进程，大多数情况下，进程中的多线程的执行是抢占式的，就和操作系统的并发多进程一样。
线程拥有自己的堆栈、程序计数器和局部变量，允许程序控制流的多重分支同时存在于一个线程，共享进程范围内的资源，因此，同一进程中的线程访问相同的变量，并从同一个堆中分配对象，实现良好的数据共享，但是如果处理不当，会为线程安全造成一定的隐患。
多线程相比于多进程的优势：
以下参考自《JAVA并发编程实战》：
- 一个单线程应用程序一次之能运行在一个处理器上。在双处理器系统中只运行一个应用程序，相当于其中一个处理器空闲，50%的CPU资源没有利用上。随着处理器的增多，单线程的应用程序放弃的CPU资源将会更多。这一点，正好也侧面反映了多线程能够更有效地利用空闲的处理器资源。
- 处理器在某些情况是空闲的，如在等待一个同步IO操作完成的时候。这个时候，暂且不论多处理器，仅仅针对单处理器，多线程的优势也是相当明显的，可以很好地利用处理器空闲的时间运行另外一个线程。
先来看看多线程编程中这个相当关键的类，java.lang.Thread，官方文档说了：有两种方式创建线程，就是下面这俩：
Thread的子类。Thread的run()方法。创建线程如下：
/*创建线程*/
//创建一个类继承Thread类
class TDemo extends Thread{
//线程要执行的任务在run方法中
@Override
public void run(){
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
}
}
启动线程如下：
public static void main(String[] args){
//创建了TDemo的实例
TDemo t1 = new TDemo();
//启动线程，并调用run方法
t1.start();
System.out.print("main");
}
//输出结果：main01234
创建TDemo的实例对象不等于启动了该实例所对应的线程，启动需要调用线程对象的start()方法。
new创建了TDemo的实例，只是创建了一个线程，此时它处于新建状态，有JVM分配内存，并初始化成员变量的值，是个配置的过程。
线程对象调用start()方法之后，线程就会处于就绪状态，JVM会为其创建方法调用栈和程序计数器，表示这个线程可以执行，但真正啥时候开始执行取决于JVM中线程调度器的调度。
之后才进入运行状态，执行run()方法中的方法体。
我们试着把start()方法换成run()方法看看结果：01234main
我们通过输出结果可以看到，调用start()方法，系统会把run()方法当成线程执行体处理，主线程和我们创建的线程将并发执行。但如果单纯调用run()方法，系统会把线程对象当成一个普通的对象，run()方法也只是普通对象方法的一部分，是主线程的一部分。
这是Runnable接口的内容，@FunctionalInterface注解表示函数式接口，和Java8新特性lambda表达式相关，之后再做学习总结。
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
//实现Runnable接口
class RDemo implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
}
}
//创建并启动线程
Thread t = new Thread(new RDemo());
t.start();
调用public Thread(Runnable target)构造器，将Runnble接口类型对象传入作为参数，构建线程对象。
当然还可以用匿名内部类的形式：
//匿名内部类创建并启动线程
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.print(i);
}
}
}).start();
这是Callable接口的内容：
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
除了上面两种方法之外，从书上看到还有一种Java5新增的方法，利用Callable接口，官方文档是这样描述的：
光有Callable接口还不行，毕竟隔了5年才出来，为了尽量避免修改之前的代码，适应当前环境，Java5还新增了配套的Future接口：
public interface Future<V> {
//试图取消Callable中任务的执行，如果任务已经完成、已经被取消、或因其他原因无法被取消，返回false。
boolean cancel(boolean mayInterruptIfRunning);
//如果此任务在正常完成之前被取消，则返回true
boolean isCancelled();
//如果此任务已完成（正常的终止、异常或取消），则返回true
boolean isDone();
//如果需要，则等待计算完成，然后检索其结果。
V get() throws InterruptedException, ExecutionException;
//如果需要，将等待最多给定的时间以完成计算，然后检索其结果。
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
通过继承关系可以发现，RunnableFuture接口同时继承了Runnable和Future接口，意味着实现RunnableFuture接口的类既是Runnable的是实现类，又是Future的实现类。FutureTask就是充当这样的角色，它的实例可以作为target传入Thread的构造器中。
通过查看源码，可以发现FutureTask内部维护了一个Callable的对象，可以通过下面的这个构造器初始化Callable对象。
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int i = 0;
while(i<10){
System.out.println(Thread.currentThread().getName());
i++;
}
return i;
}
});
public Thread(Runnable target, String name)将task对象作为参数创建新线程并启动。name参数是可以自定义线程的名字。new Thread(task,"name").start();
try {
System.out.println(task.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
继承类Thread和**实现接口（Runnable或Callable）**这两种方式的区别？
currentThread()。//继承Thread
System.out.print(this.getName()+i);
//实现Runnable接口
System.out.print(Thread.currentThread().getName()+i);
前者线程类每创建一个线程都需要创建一个对象，对象之间不能共享实例变量。而后者通过接口的实现类创建的多个线程可以共享同一个Runnable类型的target，也就是这个线程类的实例变量。
前者定义线程类需要继承Thread，而Java只支持单继承，支持接口多实现，显然在灵活性方面，后者优于前者。
本文作为个人学习笔记，仍停留在比较浅显的层面，还需要大量的实践去感悟并发编程的奥义。
参考资料：《JAVA并发编程实战》、《疯狂Java讲义》、《JAVA多线程设计模式》