Java中的并发——（并发的意义与难点、线程机制，如何定义线程任务）

一、并发的意义

并发通常是提高运行在单处理机上的程序的性能
这样说的原因是：首先我们会发现在单处理机上运行的并发程序开销应该比该程序的所有部分都顺序执行的开销大，因为其中会增加所谓的上下文切换（也就是进程间的切换，从一个任务切换到另一个任务）。因此从表面上看，如果将程序的所有部分看作是单个任务的运行开销会变小，并且节省了上下文切换的时间。
但是让问题变的不同的是阻塞。如果程序中的某个任务因为该程序控制范围之外的某些条件（比如I/O）而导致不能继续执行，那这个任务或者线程就可以说是被阻塞了。如果没有并发，则整个程序都将停止下来，知道外部条件发生变化。但是如果用并发来编写程序，那么当一个任务被阻塞时，程序中的其它任务还是可以继续执行，因此这个程序可以保持继续向前执行。事实上，从性能的角度来看，如果任务不会被阻塞，那么单处理机上使用并发就没有任何意义

二、并发的难点

实现并发最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包容程序。多任务操作系统可以通过周期性的将CPU从一个进程切换到另一个进程，来实现同时运行多个进程（程序），尽管这使得每个进程看起来在执行过程中是歇歇停停的。操作系统会将进程互相隔开，因此进程之间不会相互干涉，这使得用进程编程相对容易一些。但是像Java所使用的这中并发系统会共享内存和I/O这样的共享资源，因此编写多线程程序最基本的困难在于协调不同线程驱动的任务之间对这些资源的是使用，以使得这些资源不会被多个任务同时访问。

三、java中的线程机制

我们可以这样理解程序中的任务就像是一个函数一样，有自己的功能，某些编程语言被设计为可以将并发任务彼此隔离，这些语言通常被称为函数型语言，其中每个函数的调用都不会产生任何副作用（即不会干涉其它的函数），并因此可以作为独立多的任务来驱动。想Erlang这样的语言，包含了任务之间彼此通信的安全机制。
但是Java采用传统的方式，在顺序型语言的基础上提供对线程的支持，与之前所说的操作系统中的多任务不同，线程机制是在由执行程序表示的单一进程中创建任务，这种方式带来的好处是操作系统的透明性。
java中的线程机制是抢占式的，表明调度机值会周期性的中断线程，将上下文切换到另一个线程，从而为每个线程都由CPU提供时间片，使得每个线程都会分配到数量合理的时间去驱动它的任务。
并发编程使得我们可以将程序划分为多个分离的独立运行的任务。通过使用多线程机制，这些独立任务中的每一个都将由执行线程来驱动。一个线程就是在进程中的一个单一顺序控制流，因此，单个进程可以拥有多个并发执行的任务，但是你的程序使得每个任务都好像有自己的CPU一样，起始是因为底层的CPU时间分片机制造成的，通常不需要考虑。

四、如何定义线程任务

1. 通过runnable接口来定义任务，将任务编写run()方法里，使得该任务可以执行你的命令。

public class LiftOff implements Runnable {
	protected int countDown = 10;//倒计时10秒
	private static int taskCount = 10;//相当于线程的唯一标志
	private final int id = taskCount++;//一旦被定义就不能被修改
	//构造函数
	public LiftOff() {
		super();
	}
	//构造函数
	public LiftOff(int countDown) {
		super();
		this.countDown = countDown;
	}

	public String status(){
		return id+"("+(countDown >0 ? countDown : "LiftOff")+")";//如果当前计时大于0就输出时间，等于0就点火发射
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(countDown-->0){
			System.out.println(status());
			Thread.yield();
		}
	}
}

run()中的方法一般都伴随着循环，因此一般也会设定跳出循环的条件，因此如何安全的结束run()方法也是很有意义的。Thread.yield();的调用是对线程调度器的（java线程机制的一部分，可以将CPU从一个线程转移到另一个线程）一种建议。它代表着：“我现在已经执行完当前线程最重要的部分，此刻正是你切换给其它任务执行一段时间的最好时机”。注意直接调用run()方法相当于只是执行了一个类中的一个方法而已，即她并木有任何内在的线程能力，线程的驱动，应该显示的将**任务附着在线程（Thread）**上。

2. Thread类
   将runnable对象转变为工作任务的传统方式是把他提交给一个Thread构造器

public class BasicThreads {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t = new Thread(new LiftOff()); //一个线程
		t.start();//线程驱动
		System.out.println("等待发射");
	}

}

输出结果

等待发射
0(9)
0(8)
0(7)
0(6)
0(5)
0(4)
0(3)
0(2)
0(1)
0(点火发射)

从结果可以看到，我们通过调用**Thread.start()**方法为为该线程执行必须的初始化操作，其中会自动启用Runnable的run()方法。但是欧诺个结果可以倒计时任务是在“等待发射”语句输出之前执行的，但是结果却先返回了，那是否说明线程任务先执行完了呢？
当然不是！start()调用的run()方法还没有完成，只是这个run是由其它的线程执行的因此你仍旧可以执行main()线程中的其它操作（任何一个线程都可以启动凄其它线程）。因此，程序会运行两个方法，main()和LiftOff.run()是程序中同时执行的代码（底层是CPU的时间分片机制，我不在我们的考虑范围中）

通过这样的方式，我们可以添加多个执行线程到程序中，比如

public class MoreBasicThreads {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=0;i<5;i++){
			new Thread(new LiftOff()).start();;
		}
		System.out.println("等待发射");
	}

}

输出结果

0(9)
等待发射
2(9)
1(9)
2(8)
4(9)
........
.......
....
3(1)
1(点火发射)
3(点火发射)

这里我没有截取完所有的输出，大致你也能知道就是创建了四个线程，四个都是在倒计时，最后都会输出点火发射，但是我们可以从输出看到它们之间并不是顺序执行的，而且等待发射也跑到了第二行，不同的线程在执行的时被换进换出才会由上面这种情况，而且每一次运行还可能带来不同的结果。（线程调度器默默的分发线程）

3. 从任务中产生返回值（Callable是一个具有类型参数的范型）
   Runnable是执行任务工作的独立任务，不带返回值。如果希望任务完成时能够返回一个值，可以实现Callable接口，任务返回交由**call()来执行，而不是run()，并且必须使用ExecutorService().submit()**调用。

import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService exec = Executors.newCachedThreadPool();//将为每一个任务创建一个线程
		ArrayList<Future<String>> results = new ArrayList<Future<String>>();
		for(int i=0;i<10;i++){//
			results.add(exec.submit(new TaskWithResult(i)));//submit()方法会产生Future对象
		}
		//用results列表来接收exec.submit()的返回值
		for(Future<String> fs : results){
			try{
				System.out.println(fs.get());//调用get()将会阻塞直到结果准备就绪
			}catch(InterruptedException e){
				System.out.println(e);
			}catch(ExecutionException e){
				System.out.println(e);
			}finally{
				exec.shutdown();//
			}
		}
	}

}

4. 使用Executor
   上面使用了java.util.concurrent包中的执行器（Executor），可以用Executor来管理我们的Thread对象，简化并发编程。Executor允许你管理异步任务的执行，而无需显示地管理线程的生命周期。
   下面是使用Executor来代替前面显示的创建Thread对象。ExecutorService知道如何构建恰当的上下文来执行Runnable对象。通过调用Executors的静态方法（CachedThreadPool()）可以产生一个ExecutorService对象。如下。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import threadFromJavaThinking.LiftOff;

public class CachedThreadPool {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService exec = Executors.newCachedThreadPool();
		for(int i=0;i<5;i++){
			exec.execute(new LiftOff(i));
		}
		exec.shutdown();
		//调用shutdown()可以防止新的任务被提交给到这个Executor，当前线程将执行
		//完在调用这个方法之前所提交的所有任务，程序会在执行完任务后尽快退出。
		
		//exec.shutdownNow();还有一个方法是shutdownNow(),这个方法也会防止新的任务被提交；并且尽可能的去停止当前正在执行的任务。
	}
}

5. 有限的线程集FixedThreadPool
   FixedThreadPool可以让我们一次性的预先执行代价高昂的线程分配，因此也就可以限制线程的数量，这样你也就不会滥用资源，因此资源在最开始就被限制了（一般来说还是推荐使用CachedThreadPool，因为它会在程序执行的过程中创建与所需数量相同的线程）。

使用FixedThreadPool与使用CachedThreadPool的代码不会有太大差别，也就是ExecutorService exec = Executors.newFixedThreadPool();变化而已，输出结果也看不出什么，这里就不写出来了。

使用SingleThreadExecutor单线程即就相当于数量为1的FixedThreadPool

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import threadFromJavaThinking.LiftOff;

public class SingleThreadExecutor {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService exec = Executors.newSingleThreadExecutor();
		for(int i=0;i<5;i++){
			exec.execute(new LiftOff());
		}
		exec.shutdown();
	}

}

输出结果

0(点火发射)
1(9)
...
1(1)
1(点火发射)
2(9)
...
2(1)
2(点火发射)
3(9)
...
3(1)
3(点火发射)
4(9)
...
4(1)
4(点火发射)

从结果可以看出，即使你向SingleThreadExecutor提交了多任务，这些任务也不会因为是单线程集就被丢弃，而是相当于被排队了一样被再执行。事实就是每个任务就是按照它们被提交的顺序，并且在下一个任务开始前完成（所以结果才会那么有序！！）。因此1可以说SingleThreadExecutor可以序列化所有提交给它的任务，并且维护这个任务队列。

参考资料：《Thinking in Java》!