呵呵，今天开始学习java的多线程！可以作为以后的残口资料和总结！
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。
一，如何在java中运用Thread类呢？
有时候没必要理解概念性的问题，只要知道这个东西应该怎么用就OK！
下面的例子是实现多线程的第一种方法（继承Thread类）
1.demo1
1 class hello extends Thread { 2 3 public hello() { 4 5 } 6 7 public hello(String name) { 8 this.name = name; 9 } 10 11 public void run() { 12 for (int i = 0; i < 5; i++) { 13 System.out.println(name + "运行 " + i); 14 } 15 } 16 17 public static void main(String[] args) { 18 hello h1=new hello("A"); 19 hello h2=new hello("B"); 20 h1.run(); 21 h2.run(); 22 } 23 24 private String name; 25 }
【运行结果】：
A运行 0
A运行 1
A运行 2
A运行 3
A运行 4
B运行 0
B运行 1
B运行 2
B运行 3
B运行 4
我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。
当我们把上面的主函数修改为如下所示的时候：
public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.start(); h2.start(); }
然后运行程序，输出的可能的结果如下：
A运行 0
B运行 0
B运行 1
B运行 2
B运行 3
B运行 4
A运行 1
A运行 2
A运行 3
A运行 4
为需要用到CPU的资源，所以每次的运行结果基本是都不一样的，呵呵。
注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。
那么：为什么我们不能直接调用run（）方法呢？
我的理解是：线程的运行需要本地操作系统的支持。
如果你查看start的源代码的时候，会发现：
1 public synchronized void start() { 2 /** 3 * This method is not invoked for the main method thread or "system" 4 * group threads created/set up by the VM. Any new functionality added 5 * to this method in the future may have to also be added to the VM. 6 * 7 * A zero status value corresponds to state "NEW". 8 */ 9 if (threadStatus != 0 || this != me) 10 throw new IllegalThreadStateException(); 11 group.add(this); 12 start0(); 13 if (stopBeforeStart) { 14 stop0(throwableFromStop); 15 } 16 } 17 private native void start0();
但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。
通过实现Runnable接口：
大致框架是：
1 class 类名 implements Runnable{ 2 方法1; 3 方法2； 4 … 5 public void run(){ 6 // other code… 7 } 8 属性1； 9 属性2； 10 … 11 12 }
来先看一个小例子吧：
/** * @author Rollen-Holt 实现Runnable接口 * */ class hello implements Runnable { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i < 5; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1=new hello("线程A"); Thread demo= new Thread(h1); hello h2=new hello("线程Ｂ"); Thread demo1=new Thread(h2); demo.start(); demo1.start(); } private String name; }
【可能的运行结果】：
线程A运行 0
线程Ｂ运行 0
线程Ｂ运行 1
线程Ｂ运行 2
线程Ｂ运行 3
线程Ｂ运行 4
线程A运行 1
线程A运行 2
线程A运行 3
线程A运行 4
关于选择继承Thread还是实现Runnable接口？
其实Thread也是实现Runnable接口的：
class Thread implements Runnable { //… public void run() { if (target != null) { target.run(); } } }
其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html
Thread和Runnable的区别：
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
/** * @author Rollen-Holt 继承Thread类，不能资源共享 * */ class hello extends Thread { public void run() { for (int i = 0; i < 7; i++) { if (count > 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello h1 = new hello(); hello h2 = new hello(); hello h3 = new hello(); h1.start(); h2.start(); h3.start(); } private int count = 5; }
【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。
我们换为Runnable接口：
/** * @author Rollen-Holt 继承Thread类，不能资源共享 * */ class hello implements Runnable { public void run() { for (int i = 0; i < 7; i++) { if (count > 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello he=new hello(); new Thread(he).start(); } private int count = 5; }
【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1
总结一下吧：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
建议大家劲量实现接口。
/** * @author Rollen-Holt * 取得线程的名称 * */ class hello implements Runnable { public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) { hello he = new hello(); new Thread(he,"A").start(); new Thread(he,"B").start(); new Thread(he).start(); } }
【运行结果】：
A
A
A
B
B
B
Thread-0
Thread-0
Thread-0
说明如果我们没有指定名字的话，系统自动提供名字。
判断线程是否启动
/** * @author Rollen-Holt 判断线程是否启动 * */ class hello implements Runnable { public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he); System.out.println("线程启动之前---》" + demo.isAlive()); demo.start(); System.out.println("线程启动之后---》" + demo.isAlive()); } }
【运行结果】
线程启动之前---》false
线程启动之后---》true
Thread-0
Thread-0
Thread-0
主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。
线程的强制执行：
/** * @author Rollen-Holt 线程的强制执行 * */ class hello implements Runnable { public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he,"线程"); demo.start(); for(int i=0;i<50;++i){ if(i>10){ try{ demo.join(); //强制执行demo }catch (Exception e) { e.printStackTrace(); } } System.out.println("main 线程执行-->"+i); } } }
【运行的结果】：
main 线程执行-->0
main 线程执行-->1
main 线程执行-->2
main 线程执行-->3
main 线程执行-->4
main 线程执行-->5
main 线程执行-->6
main 线程执行-->7
main 线程执行-->8
main 线程执行-->9
main 线程执行-->10
线程
线程
线程
main 线程执行-->11
main 线程执行-->12
main 线程执行-->13
．．．
线程的休眠：
1 /** 2 * @author Rollen-Holt 线程的休眠 3 * */ 4 class hello implements Runnable { 5 public void run() { 6 for (int i = 0; i < 3; i++) { 7 try { 8 Thread.sleep(2000); 9 } catch (Exception e) { 10 e.printStackTrace(); 11 } 12 System.out.println(Thread.currentThread().getName() + i); 13 } 14 } 15 16 public static void main(String[] args) { 17 hello he = new hello(); 18 Thread demo = new Thread(he, "线程"); 19 demo.start(); 20 } 21 }
【运行结果】：（结果每隔2s输出一个）
线程0
线程1
线程2
线程的中断：
1 /** 2 * @author Rollen-Holt 线程的中断 3 * */ 4 class hello implements Runnable { 5 public void run() { 6 System.out.println("执行run方法"); 7 try { 8 Thread.sleep(10000); 9 System.out.println("线程完成休眠"); 10 } catch (Exception e) { 11 System.out.println("休眠被打断"); 12 return; //返回到程序的调用处 13 } 14 System.out.println("线程正常终止"); 15 } 16 17 public static void main(String[] args) { 18 hello he = new hello(); 19 Thread demo = new Thread(he, "线程"); 20 demo.start(); 21 try{ 22 Thread.sleep(2000); 23 }catch (Exception e) { 24 e.printStackTrace(); 25 } 26 demo.interrupt(); //2s后中断线程 27 } 28 }
【运行结果】：
执行run方法
休眠被打断
在java程序中，只要前台有一个线程在运行，整个java程序进程不会小时，所以此时可以设置一个后台线程，这样即使java进程小时了，此后台线程依然能够继续运行。
/** * @author Rollen-Holt 后台线程 * */ class hello implements Runnable { public void run() { while (true) { System.out.println(Thread.currentThread().getName() + "在运行"); } } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he, "线程"); demo.setDaemon(true); demo.start(); } }
虽然有一个死循环，但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。
线程的优先级：
/** * @author Rollen-Holt 线程的优先级 * */ class hello implements Runnable { public void run() { for(int i=0;i<5;++i){ System.out.println(Thread.currentThread().getName()+"运行"+i); } } public static void main(String[] args) { Thread h1=new Thread(new hello(),"A"); Thread h2=new Thread(new hello(),"B"); Thread h3=new Thread(new hello(),"C"); h1.setPriority(8); h2.setPriority(2); h3.setPriority(6); h1.start(); h2.start(); h3.start(); } }
【运行结果】：
A运行0
A运行1
A运行2
A运行3
A运行4
B运行0
C运行0
C运行1
C运行2
C运行3
C运行4
B运行1
B运行2
B运行3
B运行4
。但是不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源、
另外，主线程的优先级是5.
线程的礼让。
在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行。
/** * @author Rollen-Holt 线程的优先级 * */ class hello implements Runnable { public void run() { for(int i=0;i<5;++i){ System.out.println(Thread.currentThread().getName()+"运行"+i); if(i==3){ System.out.println("线程的礼让"); Thread.currentThread().yield(); } } } public static void main(String[] args) { Thread h1=new Thread(new hello(),"A"); Thread h2=new Thread(new hello(),"B"); h1.start(); h2.start(); } }
A运行0
A运行1
A运行2
A运行3
线程的礼让
A运行4
B运行0
B运行1
B运行2
B运行3
线程的礼让
B运行4
未完待续。、、、