Java多线程大总结

转载：http://50vip.com/blog.php?i=151

 

Java多线程在任何互联网公司的任何笔试任何面试几乎都会有，下面对Java的Thread多线程做一个总结，目的在于看完这篇文章，多线程的笔试面试再也不是问题。（文中标红的地方为重中之重）

主要从以下几个方面说明：

一.两种实现Java多线程的方法、注意点及区别

二.Java多线程中对于线程操作的方法

三.Java多线程中资源同步的方法

---

一、实现Java多线程的方法

这部分大部分人看过书应该都很清楚，有两种方法：继承Thread类、实现Runnable接口。

1.继承Thread类

大致代码如下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

package com.vip.thread; /**  * 继承Thread类实现多线程  * @author Xewee.Zhiwei.Wang  * @version 2013-3-25 下午3:00:21  * @Contract [e-mail] or http://50vip.com/  */ public class ThreadTest extends Thread {     /**      * 重写run方法      */     public void run() {         for (int i = 0; i < 520; i++) {             System.out.println("I Love You...");         }     }     public static void main(String[] args) {         new ThreadTest().start();     } }

2.实现Runnable接口

大致代码如下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

package com.vip.thread; /**  * 多线程实现runnable接口  * @author Xewee.Zhiwei.Wang  * @version 2013-3-25 下午2:59:03  * @Contract [e-mail] or http://50vip.com/  */ public class RunnableTest implements Runnable {     public void run() {         for (int i = 0; i < 520; i++) {             System.out.println("I Love You...");         }     }     public static void main(String[] args) {         new ThreadTest().start();     } }

这两段代码需要注意的是：运行多线程使用的方法是start()，而不是覆写的run()方法，但是实际执行的代码块还是run()方法中的。为什么不能使用run()，主要原因是以为多线程操作会执行操作系统底层native方法，这一点你可以看start()方法的源代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public synchronized void start() {     /**      * This method is not invoked for the main method thread or "system"      * group threads created/set up by the VM. Any new functionality added      * to this method in the future may have to also be added to the VM.      *      * A zero status value corresponds to state "NEW".      */     if (threadStatus != 0 || this != me)             throw new IllegalThreadStateException();         group.add(this);     start0();     if (stopBeforeStart) {         stop0(throwableFromStop);     } } private native void start0();

从 代码可以看出：1.执行start()方法之后，此处调用的是start0（）。并且这个这个方法用了native关键字，此关键字表示调用本地操作系统 的函数。因为多线程的实现需要本地操作系统的支持。2.start()方法多次执行会抛出 java.lang.IllegalThreadStateException异常。

3.两种实现方式的区别，如何选择？

实际上，看到Thread类的源代码之后，你就会发现其实Thread也是实现Runnable接口的：

1 2 3 4 5 6 7

class Thread implements Runnable {     public void run() {         if (target != null) {              target.run();         }     } }

其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式，这是23种设计模式中的一种。

既然二者同宗同源，那么怎么选择使用哪种方式实现Java多线程？个人推荐使用实现Runnable接口的方法，它有以下几个优点：

1）适合多个相同的程序代码的线程去处理同一个资源；

2）可以避免java中的单继承的限制；

3）增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

最后，PS一个：main方法其实也是一个线程。 在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在java中，每次程序运行至少启动2个线程。一个是 main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际在就是在操作系统中启动了一 个进程。

---

二、Java多线程操作方法

主要操作方法有：isAlive()是否存活、join()强制执行、yield()暂停、sleep()休眠、interrupt()中断等等。另外还有设置线程优先级、守护线程的方法。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

package com.vip.thread; /**  * Java线程操作  * @author Xewee.Zhiwei.Wang  * @version 2013-3-25 下午3:29:38  * @Contract [e-mail] or http://50vip.com/  */ public class Test implements Runnable {     public void run() {         for (int i = 0; i < 520; i++) {             System.out.println(Thread.currentThread().getName() + ": I Love You...");         }     }     public static void main(String[] args) throws InterruptedException {         Thread t1 = new Thread(new Test(), "线程1");         t1.start();         System.out.println(t1.isAlive());         Thread.sleep(2000);         System.out.println(t1.isAlive());     } }

上述代码中用到了isAlive()、sleep()方法，程序执行结果是先true，后false。除此之外，其他的一些方法后面我会加入更多的、更有说服力的实例代码来说明。

另外再贴一段关于Thread的wait,notify,wait,sleep简单演示代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public class Test extends Thread {     Object lock = null;     boolean notifyFlag = false;     public Test(Object lock, boolean notifyFlag) {         this.lock = lock;         this.notifyFlag = notifyFlag;     }     @Override     public void run() {         synchronized (lock) {             System.out.println((notifyFlag == true ? "(notifyThread)" : "") + Thread.currentThread().getName()                     + " hava in partA");             try {                 // Thread.sleep(10000); // A                 if (notifyFlag)                     lock.notifyAll();  // C                 // lock.notify();      // B                 else                     lock.wait();             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println((notifyFlag == true ? "(notifyThread)" : "") + Thread.currentThread().getName()                     + " hava in partB");         }     }     public static void main(String[] args) throws InterruptedException {         Object lock = new Object();         new Test(lock, false).start();         new Test(lock, false).start();         new Test(lock, false).start();         Thread.sleep(10000);         new Test(lock, true).start();     } }

最后，在Java多线程操作方法结束之前PS一个：主线程（main方法线程）也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。在 java程序中，只要前台有一个线程在运行，整个java程序进程不会消失，所以此时可以设置一个后台守护线程，这样即使java进程小时了，这个后台线 程依然能够继续运行。在Eclipse中执行下面的代码，你会发现Eclipse标志程序运行的红色点点变灰了之后，表示主线程已经退出消失，但是在任务 管理器中仍然可以看到javaw.exe进程，这就是守护线程的作用。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package com.vip.thread; /**  * Java线程操作  * @author Xewee.Zhiwei.Wang  * @version 2013-3-25 下午3:29:38  * @Contract [e-mail] or http://50vip.com/  */ public class Test implements Runnable {     public void run() {         while (true) {             System.out.println(Thread.currentThread().getName() + ": I Love You...");         }     }     public static void main(String[] args) throws InterruptedException {         Thread t1 = new Thread(new Test(), "线程1");         t1.setDaemon(true);         t1.start();     } }

 

---

三、Java多线程的资源同步（线程同步）

前面的一、二都是基础，几乎是用过Java多线程的孩子都知道上面的，但是简单实用过Java的确不一定知道资源或者线程的同步问题，所以这个问题也是面试官考核你对Java多线程的掌握程度。

学 过数据库系统的都知道：DBMS在进行数据库操作时必须遵守几个原则：一致性、完整性、永久性、原子性。遵守这几个原则的原因是防止多客户端操作时的数据 读脏问题，特别是对于数据一致性比较重要的时候，比如书本上最喜欢的例子就是银行存款取款问题。那么要遵守这几个原则我们在程序中该怎么做呢？那就是事务 操作，要么commit，要么rollback。

同样的，多线程操作和DBMS的事务操作类似，需要对共同访问的数据和资源进行同步（事务一致性），除此之外，线程同步还需要考虑线程造成死锁的情况，那么线程同步有哪些方式方法？所谓同步就是在同一时间，只能有一个线程在访问共享资源。

1.synchronized关键字

synchronized可以修饰一个代码块，也可以修饰一个方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

package com.vip.thread; /**  * Java线程操作  * @author Xewee.Zhiwei.Wang  * @version 2013-3-25 下午3:29:38  * @Contract [e-mail] or http://50vip.com/  */ public class Test implements Runnable {     public void run() {         for(int i = 0; i < 520; ++i){             synchronized (this) {                 System.out.println(Thread.currentThread().getName() + ": I Love You...");             }         }     }     public static void main(String[] args) throws InterruptedException {         Thread t1 = new Thread(new Test(), "线程1");         Thread t2 = new Thread(new Test(), "线程2");         t1.start();         t2.start();     } }

上述代码是用synchronized修饰一个代码块的，其中，虽然有两个线程，但是这两个线程不可能同时运行被synchronized包围的代码块（本示例中并没有线程之间的共享资源）。

下面在举一个使用synchronized修饰方法的例子，这个例子很常见的就是在单例模式中（单例模式也是一个很重要的笔试面试点），直接贴代码，知道单例模式的再学习一下，不知道的好好学习一下，并google其他的博文。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package com.vip.singleton; /**  * 单例模式  * @author Xewee.Zhiwei.Wang  * @version 2013-3-25 下午4:13:17  * @Contract [e-mail] or http://50vip.com/  */ public class Singleton {     private static Singleton INSTANCE = null;     // Private constructor suppresses     private Singleton() {}     // default public constructor     public synchronized static Singleton getInstance() {         if (INSTANCE == null) {             INSTANCE = new Singleton();         }         return INSTANCE;     } }

写在synchronized的最后，还是PS一下：synchronized是一个大考点，需要说明一下的情况是：当一个类A的多个方法（b、c）都用synchronized修饰时，再new 2了线程，这两个线程持有同一个A的对象时，线程1调用b方法的同时，线程2可以调用c方法吗？答案是不行的。因此，在一个项目中如果过多的使用synchronized关键字，将会导致过多资源的同步，首先造成的就是程序执行效率低，另外一个问题就是容易造成死锁：因此，线程资源同步的粒度越小越好...

有关于synchronized的问题，我会另外开博文详细说明清楚，这里就点到为止。

2.java.util.concurrent.locks包下的接口Lock

Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题。示代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

public class LockTest {     public static void main(String[] args) {         final Outputter1 output = new Outputter1();         new Thread() {             public void run() {                 output.output("zhangsan");             };         }.start();              new Thread() {             public void run() {                 output.output("lisi");             };         }.start();     } } class Outputter1 {     private Lock lock = new ReentrantLock();// 锁对象     public void output(String name) {         // TODO 线程输出方法         lock.lock();// 得到锁         try {             for(int i = 0; i < name.length(); i++) {                 System.out.print(name.charAt(i));             }         } finally {             lock.unlock();// 释放锁         }     } }

这 样就实现了和sychronized一样的同步效果，需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而是用 Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内。

如果说这 就是Lock，那么它不能成为同步问题更完美的处理方式，下面要介绍的是读写锁(ReadWriteLock)，我们会有一种需求，在对数据进行读写的时 候，为了保证数据的一致性和完整性，需要读和写是互斥的，写和写是互斥的，但是读和读是不需要互斥的，这样读和读不互斥性能更高些，这种精确的加锁方式是 synchronized无法实现的。来看一下不考虑互斥情况的代码原型：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public class ReadWriteLockTest {     public static void main(String[] args) {         final Data data = new Data();         for (int i = 0; i < 3; i++) {             new Thread(new Runnable() {                 public void run() {                     for (int j = 0; j < 5; j++) {                         data.set(new Random().nextInt(30));                     }                 }             }).start();         }               for (int i = 0; i < 3; i++) {             new Thread(new Runnable() {                 public void run() {                     for (int j = 0; j < 5; j++) {                         data.get();                     }                 }             }).start();         }     } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

class Data {        private int data;// 共享数据     private ReadWriteLock rwl = new ReentrantReadWriteLock();       public void set(int data) {         rwl.writeLock().lock();// 取到写锁         try {             System.out.println(Thread.currentThread().getName() + "准备写入数据");             try {                 Thread.sleep(20);             } catch (InterruptedException e) {                 e.printStackTrace();             }             this.data = data;             System.out.println(Thread.currentThread().getName() + "写入" + this.data);         } finally {             rwl.writeLock().unlock();// 释放写锁         }     }       public void get() {         rwl.readLock().lock();// 取到读锁         try {             System.out.println(Thread.currentThread().getName() + "准备读取数据");             try {                 Thread.sleep(20);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println(Thread.currentThread().getName() + "读取" + this.data);         } finally {             rwl.readLock().unlock();// 释放读锁         }     } }

这个代码就是说明如何使用手动加锁的方式进行线程资源同步，并获得更高的性能。

3.ThreadLocal

早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。

ThreadLocal和线程同步机制相比有什么优势呢？ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

在 同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写， 什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。而ThreadLocal则从另一个角度来解决多线程的并发访 问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就 没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

由 于ThreadLocal中可以持有任何类型的对象，低版本JDK所提供的get()返回的是Object对象，需要强制类型转换。但JDK 5.0通过泛型很好的解决了这个问题，在一定程度地简化ThreadLocal的使用，概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换 空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变 量，因此可以同时访问而互不影响。

ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

void set(Object value)

设置当前线程的线程局部变量的值。

public Object get()

该方法返回当前线程所对应的线程局部变量。

public void remove()

将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

protected Object initialValue()

返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

值 得一提的是，在JDK5.0中，ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal<T>。API方法也相应进 行了调整，新版本的API方法分别是void set(T value)、T get()以及T initialValue()。

有关于ThreadLocal的内容非常之多，很多数据库连接池就是基于ThreadLocal的，例如OSChina的数据库链接池就是使用ThreadLocal自己封装的。关于ThreadLocal的内容大家可以自己再搜索学习一下。