Java并发编程【1.2时代】

    本文介绍了Java原生的多线程技术（1.2），通过详细介绍wait和notify相关的机制、基础的多线程技术以及基于这些技术的等待超时、线程间的通信技术和线程池高阶技术，最后通过一个基于线程池的简单文本web服务器—MollyServer，来阐明多线程带来好处。通过介绍这些技术，展示了在没有使用Java并发包的时代（1.5-）是如何完成Java的多线程编程，为理解Java5提供了良好帮助。

线程简介

       Java从诞生开始就明智的选择内置对多线程的支持，这将Java语言同其他同一时期的语言相比，具有明显优势。线程作为操作系统最小的调度单元，多个线程同时执行，将会改善我们的代码，在多核环境中具有更加明显的好处，但是过多的创建线程和对线程的不当管理也容易造成问题。

启动线程

构造线程

       Java中启动线程必须要先行的构造一个Thread对象，然后调用这个对象的start方法。

线程的构造，最主要或者说也就是线程对象的初始化过程，在上述过程中，一个新构造的线程对象是由其parent线程来进行分配空间的，而child线程继承了parent的是否Daemon，优先级和加载资源的classloader，栈空间的大小并且还会分配一个唯一的ID来标识这个child线程，至此一个能够运行的线程对象就初始化好了，在堆内存中等待着运行。

启动线程

          调用Thread对象的start方法，就可启动一个新的线程，parent线程同步告知Java VM，只要线程规划器空闲，应立即启动这个线程。

         而启动线程，也是交给操作系统来完成，这里就是一个本地方法了。

         启动一个线程时，最好设置名称，这样在jstack分析时，就会好很多，自定义的线程最好能够起个名字。

        上述代码直接运行，可以通过jstack pid来观察栈信息，结果如下：

         可以看到一个Java程序在运行时，后台创建了很多的线程，所以一个Java程序，纵使只有main，它也是多线程的，其中可以看到ThreadNameJob这个线程，也可以看到本地以吞吐量优先的ParallelGC的线程，它的数量默认是和CPU相同的，其中有4个对新生代进行GC的线程。

终止线程

       线程从执行Runnalbe开始到结束。

理解中断

        中断是一种状态，它使一个运行中的线程能够感知到其他线程对自身作出了中断操作，也就是影响到了自己。线程工作检查自身是否被中断来作出响应的行为。而该状态并没有维护在Thread中，是通过native方法获得。

         可以通过当前线程对象的isInterrupted来判断是否被中断了。

上述程序输出：

INTERRUPTED IJ

CURRENT INTERRUPT STATUS IS InterruptedJobThread false

CURRENT INTERRUPT STATUS IS InterruptedJobThread true

可以看出一旦抛出InterruptedException，当前线程的中断状态就被清除，但是也可以调用Thread.interrupted()来清除当前的中断状态。

线程属性

        Java中创建的线程均会映射为操作系统层面的线程，在Java线程对象中有部分属性可以提供访问。线程状态是理解线程运行的关键。

线程优先级

         可以看到priority，这个代表着优先级，优先级的范围从1到10，优先级高的线程占有CPU时间长一些，这当然是在长时间运行时体现出来的，但是不能做为程序执行的依据。

         对priority可以通过对线程对象进行设置，使用setPriority来完成对线程优先级的设定。

下面的例子中，构建了三个不同的线程，它们的优先级不一样，从1到10，然后运行，优先级高的线程对times++执行的会多一些。

      执行结果如下：

lingdao : have 4347635

pming : have2661562

zhongchan : have2990803

       每次执行的可能都不一样，但是总的趋势是高优先级的线程对CPU的占用时间会多一些。

线程状态

        线程在运行的生命周期中可能处于下面的6种不同的状态，在一个时刻，线程可能处于CPU上处于运行，或者暂时的没有分配到CPU资源而处于就绪（准备运行），或者处于阻塞的状态。具体内容如下面的表格所示：

        可以使用如下状态迁移来描述线程的状态：

        线程在一个时刻将会处于上述的三种状态之一，这个模型将有效的理解Java线程对象，但是其中处于等待状态的线程可能会在等待I/O和等待同步时无法被中断，虽然运行的线程已经被中断标识，但是不会像休眠和等待一样通过InterruptedException来直接返回。

       运行的结果是：

      这时整个线程挂在is.read上，这时随意从控制台输入一个字符，主线程退出：

     123

     Main Thread is interrupted ? true

       可以看出对阻塞于同步I/O的线程被中断后，中断标识被打上，但是不会抛出异常退出。

线程规划

        对高I/O的线程尽量给予高优先级的设定，对于低I/O以CPU运算为主的线程尽量降低优先级，避免过多的占用CPU。因此，不能依据线程优先级的高低来运行程序，需要保证每个线程都有运行的机会。

并发访问对象

      Java支持多个线程同时的访问一个对象，或者对象的变量，由于每个线程可以拥有这个变量的拷贝（这么做的目的是能够快速的执行，虽然变量分配的内存在共享内存中，但是每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行，这是现代多核处理器的一个显著特性）。因此，程序在执行过程中，可能一个线程看到的变量并不一定是最新的。

Volatile

     Volatile关键字，就是告知任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新会共享内存。

       比如，表示一个程序是否运行的变量，boolean on = true，那么可能是另一个线程来对它进行关闭动作，因此将其设置成为volatile boolean on，这样就会再其他线程对它进行改变时，能够让原有的线程立刻感知到。

       但是过多的使用volatile是不必要的，相反它会降低程序执行的效率。

Synchronized

        同步，在带来可见性的同时，它主要是对多个线程在同一个时刻，只能有一个处于方法或者块中。

        可以通过将synchronized关键字加在方法前面或者采用同步快的方式来进行表现：

}

        Java同步是针对普通的Java对象而言的，每个Java对象均有一把“锁”，这个锁在一个线程进入时会排斥其他线程进入，是一个排他锁。通过javap来观察字节码，可以看到：

          当出现命令monitorenter时代获得了该对象的锁，当运行命令monitorexit时代表释放了该对象的锁。

同步化集合

同步化访问

        在Java的集合api中有非常多的同步集合，比如：Vector和Hashtable，这些集合的所有方法都是synchronized，也就是说对这些集合的访问是同步的，但是如果每个接口都有一个专属的同步集合实现是非常不现实的，因此用过使用Collections.synchronizedXxx方法，可以包装一个同步的集合对象进行使用。

        比如，摘自Collections

        该方法返回的就是一个实现了List接口的同步数据结构，这个同步的数据结构每个方法均是同步的，但是如果需要对其进行额外的操作，需要将其加入到同步块中。

        上面可以看到同步集合均是对自身进行同步。

         上述执行的结果：

       Main-thread1

       AccessSynchronizedCollections1

         可以看到，在自定义对集合操作，比如缺少就添加，就需要将集合进行同步，然后在进行操作，否则很容易在判定过程中加入了其他线程对集合的操作。

安全复制集合

         有时一个集合对象是进程内共享的，可能会发生一些变化，因此在作出一些操作的时候，希望能够拿到一份瞬时的拷贝，这个拷贝可能和执行中的这一时刻的集合有了变化，但是能够保证是稳定的。就像我们出门买了一份报纸，我们回家阅读报纸的时候，上面的新闻可能随时会发生变化，但是这并不妨碍我们去阅读它。

第一种复制的方式：

第二种复制的方式：

         第一种比较简单，第二种对于new String[0]没有做过多的浪费，但是时间测算，第二种没有第一种好，因为主要比拼的是toArray的实现，在给定的数组大于等于列表时，将会使用给定的数组，否则将会通过反射构造一个数组，而这个还是很高效的。

         因此对于集合的数组复制，使用第一种方式是比较适合的。

死锁

          两个线程或者多个线程在请求其永远无法获取资源的锁时，就是死锁状态。这里不演示死锁产生的范例。

          避免死锁的主要原则：

          首先，对于资源的加锁时间必须足够短，也就是必要时进行锁；

          其次，访问资源过程中的锁需要按照一致的顺序进行获取，否则需要提升出一个更大的锁来确保资源的获取；

          最后，尽量通过封装的形式，避免将锁暴露给外部，从而造成不必要的资源死锁。

线程间通信

         线程开始运行，就如同一个脚本一样，有自己的栈空间，按照既定的代码一步一步的执行，直到最后的终结。但是每个运作中的线程，如果仅仅是孤立的运作，那么没有一点用处，或者说用处很少，但是多个运作的线程能够相互配合，各司其职将会带来巨大的好处。

线程间通信的必要性

         一个运作的脚本（线程）修改了一个对象的值，另一个线程捕获到这个对象的变化，然后进行对应的操作，这个过程事件的触发启于一个线程，而最终的执行又是一个线程。因此前者好比生产者，后者就是消费者，这样的模式隔开了生产和消费，在功能上和架构上具有良好的伸缩性。但是在Java语言中怎样能够做到上述的过程呢？

         当然，简单的办法是不断的循环去查看，比如：

while (value != desire) {

Thread.sleep(1000);

}

doXxx

        这段伪码就是相当与如果值不是这个消费线程所要的，那么就睡眠一段时间，这样的方式看似能够解决这个问题，但是有两个矛盾的问题。

        第一个，在睡眠时，基本不消耗CPU，但是如果睡得久，那么就不能及时的发现value已经变化，也就是及时性难以保证；

        第二个，如果降低睡眠的时间，比如睡1毫秒，这样消费者能更加迅速的捕获出变化，但是它却占用了更多的CPU时间，造成了无端的浪费。

        面对这个矛盾，Java通过固有的wait/notify机制能够很好的实现这个模式。

等待/通知机制

         等待通知机制，是指一个线程调用了对象A上的wait方法，而另外的一个线程在进行了某些操作后，在对象A上的notify或者notifyAll方法，这样完成了两个线程之间的交互。而这个wait和notify之间的关系就像一个信号量一样来完成二者之间的交互工作。

        一个标准的wait和notify的例子，这个例子有两个线程，第一个等待共享的一个值为false，当为false时它进行print，另外一个在睡眠了一段时间后，将这个值由原有的true改为false并notify。

      从上面的例子中能够提炼出经典的等待和通知机制，对于等待的一方，遵循如下的原则：

（1）获得对象的锁；

（2）如果条件不满足，那么调用对象的wait，释放锁，被通知后继续检查（2）

（3）条件已经满足，执行对应的逻辑。

synchronized(OBJ) {

while(Condition not hold) {

OBJ.wait();

}

// Condition hold

do XXX;

}

       通知的一方，遵循如下原则：

（1）获得对象的锁；

（2）更新变量或者条件，然后通知。

synchronized(OBJ) {

value = newvalue;

OBJ.notifyAll();

}

等待/通知的API

等待和通知机制被深深植入了Java语言中，在Object方法中有5个final的方法，也就是子类不能复写的方法。

        这里要说明notify方法不会释放对象的锁，而也只有释放了对象的锁，另一个线程才能从wait中竞争获得对象的锁并从wait方法中返回。

       程序的输出：

Thread[Thread-0,5,main] still true. wait……Sun Jun 24 20:53:03 CST 2012

Thread[Thread-0,5,main] is false. doXXX.Sun Jun 24 20:53:14 CST 2012

        可以看到，二者之间相差了10秒，也就是Thread.sleep(10000)这段代码造成的，可以看出Notifier没有释放OBJ的锁，而Waiter在对方没有释放前是不会返回的。

PipedStream管道

      Piped这个词就是管道，相当于从一端入一端出的输入输出流。只是不是从网络和文件上读入内容，而是在线程之间传递数据，而传输的媒介为内存。

       管道主要包括了：

PipedOutputStream、PipedInputStream、PipedReader和PipedWriter四个，面向的处理内容为字节和字符。

        上述程序，以main线程作为输入，而另外的Print作为输出。对于Piped类型的流，必须要进行connect，如果没有绑定，对于该流的访问会抛出异常。

ThreadLocal

       ThreadLocal线程变量，这是一个以ThreadLocal对象为Key，一个Object为value的存储结构。它被附带在线程上，也就是说一个线程可以根据一个ThreadLocal拥有一个变量。

       在线程对象中，有一个成员变量，类型如下：

        可以看到线程对象中的这个ThreadLocalMap是以ThreadLocal作为Key的。那么对于一个ThreadLocal在线程对其调用get方法时，会获取对应的Object，下面是get方法。

       下面对这些代码做些说明：

       首先调用方会获得掉用线程Thread t = Thread.currentThread();

      其次会获得线程对象的ThreadLocalMap对象；

      然后在ThreadLocalMap对象上，以this，也就是ThreadLocal为key去获得对应的值；

      如果ThreadLocalMap这个对象为NULL，这里做延迟加载，通过setInitialValue()方法来初始化线程对象的ThreadLocalMap变量。

      可以看出只有线程执行了任意ThreadLocal的get方法后，才会拥有ThreadLocalMap这个对象，而该变量又是包访问级别的，所以不会担心被其他类修改。

完全等待超时

             有时我们需要在调用一个方法时等待一段时间（一般来说是设置一个值，有更改），等待条件的满足，而等待是有时限的，比如：1000ms，如果在1000ms后无法满足条件那么返回，否则在时限内如果成功则立刻返回。

模式

        之前提到了基于wait的经典模式，即：同步，while，wait加doXxx的逻辑，那么这种模式无法做到一点，就是能够让客户端超时返回。

        如果加入超时的话，对于经典模式的修改其实不会很复杂，假设超时时间是t ms，那么可以推知在now + t之后就会超时，则定义：

remaining = t;

future = now + t;

          这时仅需要wait(remaining)即可，在醒来之后会将future – now，这个会设置到remaining上，但是如果remaining为负数，则直接退出。

         在while的判断中加入了remained > 0的约束。这个模式就可以实现等待超时，在mills毫秒内无法获取到result或者result已经获取到了，都会返回。

使用实例与场景

        这里我们模拟一个数据库链接获取的过程，这是一个消费者和生产者的案例。

         生产者每1000ms生产一个链接到池子中，每个消费者从池子中获取一个链接，如果在800ms获取不到，那么就返回，并告知获取链接超时。初始的池子里有10个链接，消费者有5个，生产者有2个。

Connection的定义

ConnectionPool的定义

          这里主要看一下fecthConnection，它提供了完全超时的实现，主要是通过计算出将要超时的时间点futureTime，和超时的时间距离deltaTime，在这个基础上复用了仅点的同步、while和do的结构，只不过是在while的不通过条件中增加了时间距离的消耗判断，如果小于0直接返回，当然面对过早通知，将会更新deltaTime。

           当执行从pool.wait方法中返回后，有可能是超时，也有可能是已经满足了池中有连接的状况，因此如果有连接则直接返回，否则返回空。

测试用例

这是一个执行了一段时间的结果：

          可以看到，因为生产者少，所以每次生产连接后，都被等待的消费者取走，而超时是完全超时，如果我们吧等待的时间长度调整到2000ms，就可以看到如下结果：

         有部分消费者，等待了2000ms没有得到连接后，就返回了，这里就非常类似数据库链接池的实现。

阻塞队列（FIFO）

         阻塞队列是对于资源获取和释放的一个良好数据结构，比如：作为资源的生产方，如果生产方生产的数据没有位置存放，那么生产方将会阻塞在生产的这个方法上，当然也可以选择阻塞多少毫秒。消费方也是同样的道理。

阻塞队列