多线程

对于Java开发人员，多线程应该是必须熟练应用的知识点，特别是开发基于Java语言的产品。本文将深入浅出的表述Java多线程的知识点，在后续的系列里将侧重于Java5由Doug Lea教授提供的Concurrent并行包的设计思想以及具体实现与应用。
    如何才能深入浅出呢，我的理解是带着问题，而不是泛泛的看。所以该系列基本以解决问题为主，当然我也非常希望读者能够提出更好的解决问题的方案以及提出更多的问题。由于水平有限，如果有什么错误之处，请大家提出，共同讨论，总之，我希望通过该系列我们能够深入理解Java多线程来解决我们实际开发的问题。
    作为开发人员，我想没有必要讨论多线程的基础知识，比如什么是线程？ 如何创建等 ，这些知识点是可以通过书本和Google获得的。本系列主要是如何理深入解多线程来帮助我们平时的开发，比如线程池如何实现？ 如何应用锁等。

（1）方法Join是干啥用的？ 简单回答，同步，如何同步？ 怎么实现的？ 下面将逐个回答。
    自从接触Java多线程，一直对Join理解不了。JDK是这样说的：
   join
    public final void join(long millis)throws InterruptedException
    Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever.
大家能理解吗？ 字面意思是等待一段时间直到这个线程死亡，我的疑问是那个线程，是它本身的线程还是调用它的线程的，上代码：
package concurrentstudy;
/**
*
* @author vma
*/
public class JoinTest {
    public static void main(String[] args) {
        Thread t = new Thread(new RunnableImpl());
        t.start();
        try {
            t.join(1000);
            System.out.println("joinFinish");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
    
        }
    }
}
class RunnableImpl implements Runnable {

    @Override
    public void run() {
        try {
            System.out.println("Begin sleep");
            Thread.sleep(1000);
           System.out.println("End sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
结果是：
Begin sleep
End sleep
joinFinish
明白了吧，当main线程调用t.join时，main线程等待t线程，等待时间是1000，如果t线程Sleep 2000呢
public void run() {
        try {
            System.out.println("Begin sleep");
            // Thread.sleep(1000);
            Thread.sleep(2000);
           System.out.println("End sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
结果是：
Begin sleep
joinFinish
End sleep
也就是说main线程只等1000毫秒，不管T什么时候结束，如果是t.join()呢， 看代码： 
public final void join() throws InterruptedException {
    join(0);
    }
就是说如果是t.join() = t.join(0) 0　JDK这样说的 A timeout of 0 means to wait forever 字面意思是永远等待，是这样吗？
其实是等到t结束后。
这个是怎么实现的吗？ 看JDK代码：
    /**
     * Waits at most <code>millis</code> milliseconds for this thread to
     * die. A timeout of <code>0</code> means to wait forever.
     *
     * @param      millis   the time to wait in milliseconds.
     * @exception  InterruptedException if any thread has interrupted
     *             the current thread.  The <i>interrupted status</i> of the
     *             current thread is cleared when this exception is thrown.
     */
    public final synchronized void join(long millis)
    throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
        wait(0);
        }
    } else {
        while (isAlive()) {
        long delay = millis - now;
        if (delay <= 0) {
            break;
        }
        wait(delay);
        now = System.currentTimeMillis() - base;
        }
    }
    }
其实Join方法实现是通过wait（小提示：Object 提供的方法）。 当main线程调用t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程，比如退出后。

这就意味着main 线程调用t.join时，必须能够拿到线程t对象的锁，如果拿不到它是无法wait的，刚开的例子t.join(1000)不是说明了main线程等待1秒，如果在它等待之前，其他线程获取了t对象的锁，它等待时间可不就是1毫秒了。上代码介绍：
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package concurrentstudy;
/**
*
* @author vma
*/
public class JoinTest {
    public static void main(String[] args) {
        Thread t = new Thread(new RunnableImpl());
       new ThreadTest(t).start();
        t.start();
        try {
            t.join();
            System.out.println("joinFinish");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
    
        }
    }
}
class ThreadTest extends Thread {

    Thread thread;

    public ThreadTest(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {
        holdThreadLock();
    }

    public void holdThreadLock() {
        synchronized (thread) {
            System.out.println("getObjectLock");
            try {
                Thread.sleep(9000);

            } catch (InterruptedException ex) {
             ex.printStackTrace();
            }
            System.out.println("ReleaseObjectLock");
        }

    }
}

class RunnableImpl implements Runnable {

    @Override
    public void run() {
        try {
            System.out.println("Begin sleep");
            Thread.sleep(2000);
           System.out.println("End sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}



关于ThreadLocal的用法，之前一直不太清楚，直到最近看了网上一篇文章《深入研究java.lang.ThreadLocal类》，再结合SUN的API，才对这个类有了一定的了解。

ThreadLocal的核心思想很简单：为每个独立的线程提供一个变量的副本。

我们知道在多线程的情况下，几个线程同时访问同一变量的情况很常见，Java提供的synchronized关键字使用了“同步锁”的机制来阻止线程的竞争访问，即“以时间换空间”。

ThreadLocal则使用了“拷贝副本”的方式，人人有份，你用你的，我用我的，大家互不影响，是“以空间换时间”。每个线程修改变量时，实际上修改的是变量的副本，不怕影响到其它线程。

ThreadLocal的一个最常见应用是为每个线程分配一个唯一的ID，例如线程ID，事务ID，一般保存在ThreadLocal中的变量都是很少需要修改的。

为了加深对ThreadLocal的理解，下面我使用一个例子来演示ThreadLocal如何隔离线程间的变量访问和修改：

【1】SerialNum类
package example.thread.threadLocal;

public class SerialNum {

    private static int nextSerialNum = 1;

    @SuppressWarnings("unchecked")
    private static ThreadLocal serialNum = new ThreadLocal() {
        protected synchronized Object initialValue() {
            return new Integer(nextSerialNum++);     
        }                                                          
    };

    public static int get() {
        return ((Integer) (serialNum.get())).intValue();
    }
   
    @SuppressWarnings("unchecked")
    public static void set(Integer newSerial){
        serialNum.set(newSerial);
    }
}

【2】GetSerialNumThread
package example.thread.threadLocal;

public class GetSerialNumThread implements Runnable {

    public static void main(String args[]) {

        GetSerialNumThread serialNumGetter = new GetSerialNumThread();
        Thread t1 = new Thread(serialNumGetter, "Thread A");
        Thread t2 = new Thread(serialNumGetter, "Thread B");
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }   
        t2.start();           
    }

    public void run() {
        int mySerialNum = getSerialNum();
        System.out.println("线程 " + Thread.currentThread().getName()
                + " 获取到的序列号是" + mySerialNum);
        System.out.println("线程 " + Thread.currentThread().getName()
                + " 修改了序列号为" + (mySerialNum * 3));
        setSerialNum(mySerialNum * 3);
        System.out.println("线程 " + Thread.currentThread().getName()
                + " 再次获得的序列号是" + getSerialNum());
    }

    private int getSerialNum() {
        return SerialNum.get();
    }

    private void setSerialNum(int newSerialNum) {
        SerialNum.set(new Integer(newSerialNum));
    }
}

运行的结果如下：
线程 Thread A 获取到的序列号是1
线程 Thread A 修改了序列号为3
线程 Thread A 再次获得的序列号是3
线程 Thread B 获取到的序列号是2
线程 Thread B 修改了序列号为6
线程 Thread B 再次获得的序列号是6

可见第一个线程在调用SerialNum.set(int)方法修改static变量时，其实修改的是它自己的副本，而不是修改本地变量，第二个线程在初始化的时候拿到的序列号是2而不是7。

为什么会这样呢？明明serialNum是静态变量啊？其实我们只需要看看ThreadLocal的内部构造就知道了：

A. ThreadLocal的get()方法：
/**
     * Returns the value in the current thread's copy of this thread-local
     * variable.  Creates and initializes the copy if this is the first time
     * the thread has called this method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            return (T)map.get(this);

        // Maps are constructed lazily.  if the map for this thread
        // doesn't exist, create it, with this ThreadLocal and its
        // initial value as its only entry.
        T value = initialValue();
        createMap(t, value);
        return value;
    }

B. ThreadLocal的set()方法：
/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Many applications will have no need for
     * this functionality, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current threads' copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

可以看到ThreadLocal在内部维护了一个Map，将变量的值和线程绑定起来，get/set方法都是对该线程对应的value进行操作，所以不会影响到其它线程。



在使用java线程的时候，特别是初学者总会有几点很常见的误区，下面以以下代码为例：

线程类：
package threadtest1;
public class ReturnThreadInfo extends Thread {
    private String str;

    public ReturnThreadInfo() {
        this.str = "Hello";
    }
  
    public void run(){
        try{
            this.str = "Hello World!";
        }catch(Exception ex){
          
        }
    }
  
    /*返回线程信息：str变量的值*/
    public String getThreadInfo(){
        return this.str;
    }
}

主类：
package threadtest1;
public class Main extends Thread {
  
    public Main() {
    }
  
    public static void main(String[] args) {
        ReturnThreadInfo returnThreadInfo = new ReturnThreadInfo();
        returnThreadInfo.start();
        System.out.println(returnThreadInfo.getThreadInfo());
    }
}

大家可以看到这个程序主要功能是返回线程returnThreadInfo对象的变量str的值并输出，那么str的值到底是什么，一些人可能会认为

是"Hello world!"或是null，其实如果大家运行下就会知道输出的str的值实际是"Hello"。为什么呢？其实认为输出结果是"Hello world"或是

null的人存在着两个比较常见的误区：
1、误区一：认为returnThreadInfo对象中的run方法一定在主类的System.out.println(returnThreadInfo.getThreadInfo())之间运行。
   这是比较常见的一个误区，稍微了解一些java编译原理的人应该清楚，java源文件的代码编译是自上而下的，也就是处在同一文件上面的代

码会在下面的代码之间被编译和运行。所以很多人认为returnThreadInfo.start()先被运行，returnThreadInfo线程被启动，然后run()方法被

调用，str被赋值："hello world!"，然后线程结束并返回到主类，最后调用System.out.println(returnThreadInfo.getThreadInfo())将str

的值输出就是"Hello world!"。
   如果returnThreadInfo不是一个线程而是一个普通类的对象，那么输出的结果是"Hello world"，但是正因为returnThreadInfo是一个线程

，所以run方法并不一定在System.out.println(returnThreadInfo.getThreadInfo())之前运行。因为实际上主类Main在运行时也是一个线程，

当调用returnThreadInfo.start()方法来启动returnThreadInfo线程后，此时系统中运行的实际上就是Main和returnThreadInfo两个线程，那

么这两个线程就会竞争CPU，谁先抢到CPU的控制权，谁就会先运行（实际上线程谁能优先抢到CPU运行时间是靠优先级来决定的，优先级可以通

过线程的setPriority(int newPriority)来设置，newPriority的取值是1-10,newPriority值越大，线程的优先级就越高，优先强占CPU的几率

就越大。线程默认的优先级是5）。由于Main和returnThreadInfo的优先级都默认为5，所以它们争抢CPU的几率是相同的。又因为Main线程实际

上是比returnThreadInfo线程先启动的，所以在这个程序中，Main的System.out.println(returnThreadInfo.getThreadInfo())反而比

returnThreadInfo的run方法更早运行，所以输出的str值还是初始的"Hello"。
2、误区二：认为线程运行完毕后，线程消亡的同时，线程对象也会一并被回收。
   下面对ReturnThreadInfo类的源代码进行修改，将ReturnThreadInfo线程的优先级设置为10：
    public ReturnThreadInfo() {
        this.str = "Hello";
this.setPriority(10);
    }
   这样returnThreadInfo线程的run()方法就会在Main类的System.out.println(returnThreadInfo.getThreadInfo())语句之前被运行。因此

有很多人会认为当returnThreadInfo线程的run()方法运行完毕并返回后，线程就会死亡，那么Main类的最后一句System.out.println

(returnThreadInfo.getThreadInfo())就会出问题，等于调用了已经不存在的对象：returnThreadInfo。
   实际上这存在着很大的一个误区，线程的死亡并不意味着线程对象的销毁和回收。线程的死亡指的是当线程的run方法结束后，该线程就无

法被重用和启动，但它的对象还存在并且它的属性和方法还一样可以被使用，因此System.out.println(returnThreadInfo.getThreadInfo())

输出的并不是NULL而是"Hello World!"，只有当整个应用程序都结束后，returnThreadInfo对象才会被销毁和回收。