用Java实现多线程

本文部分学习和参考了这篇文章：http://blog.csdn.net/evankaka/article/details/44153709#t2

之前学习了关于进程和线程的理论知识，但是关于他们是怎么实现的，还缺乏实践。这两天学习了一些关于Java实现多线程的知识，特此总结一下。目前所学知识多线程中很小的一部分，还会持续更新。想了解进程与线程知识可以参看我的这篇文章：漫谈进程与线程。

一般来说，Java实现多线程的方式有两种：继承java.lang.Thread类，实现java.lang.Runnable接口。

1、继承Thread类

一个类可以通过继承Thread类来实现多线程，这是一种比较常见的方法(但并不是一种推荐的方法)。继承之后可以重载其run()方法，看下面的例子：

package com.multiThread.learning;/** * multi thread example 1 * @author nelson * */public class Thread1 extends Thread{private String name;public Thread1(String s) {this.name = s;}@Overridepublic void run() {for(int i=0; i<5; i++){System.out.println(name + " is running=======" + i);try {sleep((int)Math.random()*10);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {Thread1 t1 = new Thread1("A");Thread1 t2 = new Thread1("B");t1.start();t2.start();}}//输出信息/*A is running=======0B is running=======0A is running=======1A is running=======2A is running=======3A is running=======4B is running=======1B is running=======2B is running=======3B is running=======4*/

从程序运行的结果可以发现，多线程程序是乱序执行。这是因为start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。
Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。
上诉代码每次运行的结果都可能不一样。

但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

2、实现java.lang.Runnable接口

采用Runnable也是非常常见的一种，我们只需要重写run方法即可。下面也来看个实例

package com.multiThread.learning;public class Thread2 implements Runnable{private String name;public static void main(String[] args) {Thread2 t1 = new Thread2("C");Thread2 t2 = new Thread2("D");new Thread(t1).start();new Thread(t2).start();}public Thread2(String inputName) {this.name = inputName;}@Overridepublic void run() {for(int i=0; i<5; i++){System.out.println(name + " is running=======" + i);try {Thread.sleep((int)Math.random()*10);} catch (InterruptedException e) {e.printStackTrace();}}}}/*

输出结果C is running=======0D is running=======0C is running=======1D is running=======1D is running=======2D is running=======3D is running=======4C is running=======2 */

说明：
Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的

3、两种方式对比

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去处理同一个资源
2. 可以避免java中的单继承的限制
   
3. 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
   
4. 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类
   

关于资源共享，继承Thread虽然也能实现，但是却比Runnable麻烦，目前先不研究怎样通过Thread实现资源共享。将上诉例子做修改，看看Runnable如何实现的。

package com.multiThread.learning;/** *  * @author nelson * */public class Thread1 extends Thread{private String name;private int num = 5;public Thread1(String s) {this.name = s;}@Overridepublic void run() {for(int i=0; i<5; i++){//System.out.println(name + " is running=======" + i);System.out.println(this.name + " 当前的num是：" + this.num--);try {sleep((int)Math.random()*10);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {Thread1 t1 = new Thread1("A");Thread1 t2 = new Thread1("B");t1.start();t2.start();}}/* * 运行结果A 当前的num是：5B 当前的num是：5A 当前的num是：4B 当前的num是：4A 当前的num是：3B 当前的num是：3A 当前的num是：2B 当前的num是：2A 当前的num是：1B 当前的num是：1 */

package com.multiThread.learning;public class Thread2 implements Runnable{private String name;private int num = 5;public static void main(String[] args) {Thread2 t1 = new Thread2("C");Thread2 t2 = new Thread2("D");new Thread(t1).start();new Thread(t2).start();}public Thread2(String inputName) {this.name = inputName;}@Overridepublic void run() {for(int i=0; i<5; i++){//ystem.out.println(name + " is running=======" + i);System.out.println(this.name + " 当前的num是：" + this.num--);try {Thread.sleep((int)Math.random()*10);} catch (InterruptedException e) {e.printStackTrace();}}}/* *输出结果C 当前的num是：5D 当前的num是：5D 当前的num是：4D 当前的num是：3D 当前的num是：2D 当前的num是：1C 当前的num是：4C 当前的num是：3C 当前的num是：2C 当前的num是：1 */}

package com.multiThread.learning;public class Thread2 implements Runnable{private String name;private int num = 5;public static void main(String[] args) {Thread2 t1 = new Thread2("C");new Thread(t1).start();new Thread(t1).start();}public Thread2(String inputName) {this.name = inputName;}@Overridepublic void run() {for(int i=0; i<5; i++){//ystem.out.println(name + " is running=======" + i);System.out.println("ID:" + Thread.currentThread().getId() + " 当前的num是：" + this.num--);try {Thread.sleep((int)Math.random()*10);} catch (InterruptedException e) {e.printStackTrace();}}}/* *输出结果ID:10 当前的num是：5ID:11 当前的num是：4ID:10 当前的num是：3ID:10 当前的num是：1ID:10 当前的num是：0ID:10 当前的num是：-1ID:11 当前的num是：2ID:11 当前的num是：-2ID:11 当前的num是：-3ID:11 当前的num是：-4 */}

从上面这几个程序可以看出，Runnable可以通过给不同的Thread赋同一个实体类，来实现资源共享

4、常用函数

1、join()方法：等待某一线程终止。在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。看下面两个例子

没有用join()的情况：

package com.multiThread.learning;class JoinThread implements Runnable{private String name;public JoinThread(String inputName) {this.name = inputName;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "开始运行！");for(int i=0; i<5; i++){System.out.println(Thread.currentThread().getName() + "===" + i);try {Thread.sleep((int)Math.random()*10);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}System.out.println(Thread.currentThread().getName() + "运行结束！");}}public class JoinTest {public static void main(String[] args) {System.out.println("主线程开始运行！");JoinThread j1 = new JoinThread("A");JoinThread j2 = new JoinThread("B");new Thread(j1).start();new Thread(j2).start();System.out.println("主线程结束运行！");}/* * 输出结果主线程开始运行！主线程结束运行！Thread-1开始运行！Thread-0开始运行！Thread-1===0Thread-0===0Thread-1===1Thread-0===1Thread-1===2Thread-0===2Thread-1===3Thread-0===3Thread-1===4Thread-0===4Thread-1运行结束！Thread-0运行结束！ */}

加入join()方法：

package com.multiThread.learning;class JoinThread implements Runnable{private String name;public JoinThread(String inputName) {this.name = inputName;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "开始运行！");for(int i=0; i<5; i++){System.out.println(Thread.currentThread().getName() + "===" + i);try {Thread.sleep((int)Math.random()*10);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}System.out.println(Thread.currentThread().getName() + "运行结束！");}}public class JoinTest {public static void main(String[] args) {System.out.println("主线程开始运行！");JoinThread j1 = new JoinThread("A");JoinThread j2 = new JoinThread("B");Thread t1 = new Thread(j1);Thread t2 = new Thread(j2);t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("主线程结束运行！");}/* * 输出结果主线程开始运行！Thread-1开始运行！Thread-1===0Thread-0开始运行！Thread-0===0Thread-1===1Thread-1===2Thread-1===3Thread-1===4Thread-0===1Thread-1运行结束！Thread-0===2Thread-0===3Thread-0===4Thread-0运行结束！主线程结束运行！ */}

不难发现，在加入join()方法后，主线程会等子线程运行完毕后再接着运行。

2、暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。看下面例子

package com.multiThread.learning;public class YieldTest {public static void main(String[] args) {Thread2 t1 = new Thread2("C");Thread2 t2 = new Thread2("D");new Thread(t1).start();new Thread(t2).start();}}class YieldThread implements Runnable{private String name;public YieldThread(String inputName) {this.name = inputName;}@Overridepublic void run() {for(int i=0; i<6; i++){System.out.println(name + "===" + i);if(i == 3){Thread.yield();}}}}

这段程序可以使一个线程运行到i=3时，暂时让出cpu。

3、sleep()方法:使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用，目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
　　 sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
　　在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。 

4、wait（）方法。wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
　　wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
　　wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。
5、sleep()和yield()的区别
        sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
        sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。 

6、sleep()和wait()的区别：两者最大的区别是sleep()不释放资源，而wait()会释放资源。

5、CyclicBarrier

CyclicBarrier是一个线程计数器，初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。

CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

看如下例子：

package com.multiThread.learning;import java.util.concurrent.BrokenBarrierException;import java.util.concurrent.CyclicBarrier;public class CyclicBarrierTest {private static final int THREAD_NUM = 5;public static void main(String[] args){CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {@Overridepublic void run() {System.out.println("when do I execute?");}});for(int i=0; i<THREAD_NUM; i++){new Thread(new WorkThread(cb)).start();}}}class WorkThread implements Runnable{int i = 0;CyclicBarrier cb;public WorkThread(CyclicBarrier inputCb) {this.cb = inputCb;}@Overridepublic void run() {try {System.out.println(Thread.currentThread().getId() + " thread is waiting");cb.await();System.out.println(Thread.currentThread().getId() + " thread is working");} catch (InterruptedException | BrokenBarrierException e) {e.printStackTrace();}}}/*10 thread is waiting11 thread is waiting12 thread is waiting13 thread is waiting14 thread is waitingwhen do I execute?11 thread is working13 thread is working12 thread is working10 thread is working14 thread is working */