小学徒成长系列—线程
添加时间:2013-5-6 点击量:
如今很多面向对象说话中都有了操纵线程这个首要的功能，线程可以或许使错杂的一部代码变得更简单，大大的降落了错杂体系的开辟，跟着如今处理惩罚器数量的成长，充沛的哄骗线程，就可以或许更好的阐扬多处理惩罚器体系的强大才能。
1.根蒂根基概念
1.1线程和过程的关系
在刚开端的时辰，操纵体系（OS）为了使多个法度能并发履行，从而进步资料哄骗率和体系吞吐量，从而提出了过程，后来为了削减时空的开销，进步并发性和CPU的哄骗率，就提出了线程这个概念。
在OS中，其实线程包含于过程内的，一个法度只有一个过程，然则却可以有很多的线程，如图：
从图中，我们也可以很好的知道，过程是操纵体系中资料分派的根蒂根基单位，而线程只拥有运行时必不成少的资料，线程本身根蒂根基不拥有体系的资料，并且，因为附属 于过程，所以线程可以接见附属过程的资料，同一过程的线程间可以共享所属过程的资料，这也就呈现了后面我们必须采取办法处理惩罚线程间的同步题目。在运行时代，线程 才是操纵体系的调剂和分派的根蒂根基单位。同时，操纵体系在创建、撤销及切换线程的时辰，开销会比过程小。
1.2线程和过程的根蒂根基运行状况
其实，线程拥有的根蒂根基运行状况和过程一样，分别是以下3种：
1>履行状况，默示线程或者过程正获得处理惩罚机而运行；
2>伏贴状况，默示线程或者过程已经具备了各类履行前提，一旦获得CPU便可履行的状况；
3>梗阻状况，默示线程在履行中因为某时候而受阻，出于暂停履行时的状况。
它们的状况转换图具体如下：
1.3并发和并行
我们前面提到了并发这个词，日常平凡口中也经常提到并发和并行这两个词，很多人经常把他们混合来应用，然则，其实这两个词并不是等赞成义的，下面我们来看下他们的申明：
1>并发：是指两个或多个事务在同一时候间隔内产生；
2>并行：是指两个或多个事务在同一时刻产生；
1.4同步和异步
在操纵体系中，对同步和异步是如许描述的：
1>异步：多进（线）程按各自自力的，不成预知的速度向前推动；
2>同步：多个相干的进（线）程在履行次序长进行调和使之共享资料彼此合作。
或许直接如许子看概念会有点生涩难以懂得，那么就举一个经典的例子（临盆者与花费者）来共同窗习下吧。
假设我们如今有一个临盆过程和一个花费过程：
1>临盆过程在临盆产品并置于缓存（可以懂得为堆栈）的时代，花费过程不克不及进入缓存取临盆品，直到临盆产品临盆完产品开释它对缓存的掌控权之后，花费过程才可以进入缓存取临盆品，并且必须守候花费过程不再取临盆品并且开释了他对缓存的掌控权之后，临盆过程才可以再次进入缓存进行临盆。这个就是同步。
2>临盆过程将产品置于缓存之后并不关怀花费过程是否取走产品就持续临盆，也就是说在临盆过程临盆产品至于缓存的过程中，花费者过程也可以进入缓存取走产品。这个就是异步。
2.Java中的线程Thread
在Jdk中，已经连络体系的内核，给我们封装好了线程的把握API，我们只要创建一个线程对象，熟悉它的API，调用对应的函数，就可以把我们想要对线程进行的操纵传达给操纵体系，由操纵体系来帮我们完成，这就大大降落了进修者的进修难度，同时也大大雅便了开辟人员，进步了开辟效力。
2.1线程的实现体式格式
在Java中，我们有两种线程的实现体式格式
1>直接持续Thread类，重写父类的run（）办法，eg ：
1 package com.thread.first;
2
3 public class MyThread extends Thread {
4
5 //重写父类的run（）办法
6 ＠Override
7 public void run（） {
8 this.setName（The Thread To Print Number）;
9 for （int i = 0; i < 10; i++） {
10 System.out.println（this + + i）;
11 }
12 }
13
14 public static void main（String[] args） {
15 //重视，线程开端履行的办法是start（）而不是run（）办法
16 //具体差别后面会讲
17 new MyThread（）.start（）;
18 for （int i = 0; i < 10; i++） {
19 System.out.println（Main Thread : + i）;
20 }
21 }
22 }
因为线程在CPU中是并发履行瓜代履行的，所以履行成果并不独一，以下只是此中一种输出成果罢了，若是呈现跟下图不一样的成果，也不消愁闷，只要代码无误，能正常运行，就对了：
2>定义线程类并实现Runnable接口。因为Java是单持续了，若是持续了Thread类就不克不及持续其他的类了，而接口倒是可以实现多个的，同时这种体式格式还可以或许为多个线程供给共享的数据，所以在实际开辟中，我们都斗劲推荐应用这种体式格式定义线程类，eg:
1 package com.thread.second;
2
3 public class MyRunnable implements Runnable {
4
5 ＠Override
6 public void run（） {
7 //获取当火线程并且设置线程的名字
8 Thread.currentThread（）.setName（（The Thread To Print Number））;
9 for （int i = 0; i < 10; i++） {
10 System.out.println（Thread.currentThread（） + + i）;
11 }
12 }
13 }
1 package com.thread.second;
2
3 public class TestThread {
4 public static void main（String[] args） {
5 //重视将创建自定义的线程类对象并传进Thread类的机关办法中
6 new Thread（new MyRunnable（））.start（）;
7
8 for （int i = 0; i < 10; i++） {
9 System.out.println（Main Thread : + i）;
10 }
11
12 }
13 }
运行成果此次我就不贴出来啦，大师本身运行一下就知道的。
下面我们一路来看一下Runnable这个接口，其实它的源代码也很简单，就只有一个用来定义线程的运行体的run（）办法：
2.2线程的根蒂根基把握办法
2.2.1开端履行线程 start（）
其实这个，在前面我们的代码测试中已经用过了，我就不再别的给出一个代码啦，我们就直接讲一下run（）办法和start（）办法见的差别吧。
创建了一个线程对象之后，想要经由过程该对象开启线程，我们就要调用start（）办法，而不是run（）办法，因为经由过程run（）办法调用的只是办法的履行，还是属于当火线程的，也就是说依旧是单线程，我们经由过程一个简单的法度看看吧，eg：
1>直接调用run（）办法：
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 //输出当火线程的名字
8 System.out.println（in run menthod : + Thread.currentThread（）.getName（））;
9 }
10
11 public static void main（String[] args） {
12 //创建一个线程对象并且运行它的run办法
13 new TestThread（）.run（）;
14 //输出当火线程的名字
15 System.out.println（in main method : + Thread.currentThread（）.getName（））;
16 }
17 }
履行成果：
按照履行成果，我们发明，经由过程调用run（）办法并没有开启新的线程，也就是说依旧是单线程。下面我们再看看经由过程调用start（）办法的成果：
2>直接调用start（）办法：
//直接把上方一段代码中的run办法批改成调用start（）办法
//创建一个线程对象并且运行它的start（）办法
new TestThread（）.start（）;
履行成果：
按照履行成果，我们发明，经由过程调用start（）办法才是可以开启新的线程，也就是说实现线程并发的，具体为什么呢？我们再来看看Thread类中的项目组源代码吧。
1 public class Thread implements Runnable {
2 //Runnable接口
3 private Runnable target;
4
5 //这只是Thread的此中一个机关办法，
6 //其他的机关办法因为篇幅题目省略了
7 public Thread（Runnable target） {
8 init（null， target， Thread- + nextThreadNum（）， 0）;
9 }
10
11 //Thread经由过程实现Runnable接口重写的办法
12 ＠Override
13 public void run（） {
14 if （target != null） {
15 target.run（）;
16 }
17 }
18 public synchronized void start（） {
19
20 //.....
21 //前面省略了一项目组代码
22 boolean started = false;
23 try {
24 start0（）; //调用该办法启动线程
25 started = true; //设置线程开启状况为真
26 } finally {
27 try {
28 if （!started） {
29 group.threadStartFailed（this）;
30 }
31 } catch （Throwable ignore） {
32 / do nothing. If start0 threw a Throwable then
33 it will be passed up the call stack /
34 }
35 }
36 }
37
38 //经由过程JNI调用开启线程
39 private native void start0（）;
40 }
经由过程上述源代码我们知道，run（）办法中并没有开启线程，而是属于一个通俗的办常调用罢了，而start（）办法才有经由过程JNI调用线程。
2.2.2 断定线程存亡 isAlive（）
若是线程还存在，则返回true， 不然返回false;
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 //输出当火线程的名字
8 System.out.println（in run menthod : + Thread.currentThread（）.getName（））;
9 }
10
11 public static void main（String[] args） {
12 //创建一个线程对象
13 TestThread tt = new TestThread（）;
14 //线程还没有开启，下面语句将会输出false
15 System.out.println（线程还或者吗？ + tt.isAlive（））;;
16 tt.start（）;
17 //线程已经开启，下面语句将会输出true
18 System.out.println（线程还或者吗？ + tt.isAlive（））;;
19 }
20 }
当然啦，对线程的操纵，Java是不成能直接做到的，他也是经由过程JNI本地调用进行操纵的，源代码如下图：
2.2.3 线程的优先级 getPriority（） & setPriority（）
经由过程该办法可以设置线程的优先级，一般景象下，优先级越高的线程获得CPU调剂的时候片将会越长。java线程的优先级值默认为5，设置局限为1-10.
因为Java的线程是被映射到体系的原声线程上来实现的，所以线程调剂终极还是由操纵体系说了算的，固然很多线程都供给线程优先级的概念，然则并不剪得能与java线程的优先级一一对应，如Solaries中有231种优先级，Windows中就只有7中，并不必然能与java线程的优先级设置一一对应，是以，建议还是直接应用java本身自带的三个MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10）来设置优先级斗劲好，eg：
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 Thread currentThread = Thread.currentThread（）;
8 //输出当火线程的名字、优先等级
9 for （int i = 0; i < 50; i++） {
10 System.out.println（name : + currentThread.getName（）
11 + \t priopity : + currentThread.getPriority（） + + i）;
12 }
13 }
14
15 public static void main（String[] args） {
16 //创建优先级为5一个线程对象
17 TestThread ttNorm = new TestThread（）;
18 ttNorm.setPriority（NORM_PRIORITY）;
19 ttNorm.start（）;
20
21 //创建优先级为1一个线程对象
22 TestThread ttMin = new TestThread（）;
23 ttMin.setPriority（MIN_PRIORITY）;
24 ttMin.setPriority（MIN_PRIORITY）;
25 ttMin.start（）;
26
27 //创建优先级为10一个线程对象
28 TestThread ttMax = new TestThread（）;
29 ttMax.setPriority（MAX_PRIORITY）;
30 ttMax.start（）;
31
32 }
33 }
2.2.4线程睡眠时候sleep（）
讲当火线程指定睡眠毫秒数
1 ＠Override
2 public void run（） {
3 Thread currentThread = Thread.currentThread（）;
4 try {
5 Thread.sleep（1000）; //让线程休眠1秒钟
6 } catch （InterruptedException e） {
7 e.printStackTrace（）;
8 }
9 }
2.2.5线程归并join（）
归并某线程A的这个办法，将该线程与当火线程B归并，即守候该线程A履行完毕后再持续履行线程B，如图：
下面我们再来看看代码的实现，eg:
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 Thread currentThread = Thread.currentThread（）;
8 //输出当火线程的名字、优先等级
9 for （int i = 0; i < 50; i++） {
10 System.out.println（name : + currentThread.getName（）
11 + \t priopity : + currentThread.getPriority（） + + i）;
12 }
13 }
14
15 public static void main（String[] args） throws Exception {
16 //创建优先级为5一个线程对象
17 TestThread ttNorm = new TestThread（）;
18 ttNorm.setPriority（NORM_PRIORITY）;
19 ttNorm.start（）;
20 ttNorm.join（）; //归并线程
21 Thread currentThread = Thread.currentThread（）;
22 for （int i = 0; i < 50; i++） {
23 System.out.println（name : + currentThread.getName（）
24 + \t priopity : + currentThread.getPriority（） + + i）;
25 }
26 }
27 }
2.2.6 yield（）
让出CPU，当火线程进入伏贴队列守候调剂，测试代码如下：
1 package com.thread.first;
2
3 public class TestYield {
4 public static void main（String[] args） {
5 MyThread3 t1 = new MyThread3（t1）;
6 MyThread3 t2 = new MyThread3（t2）;
7 t1.start（）;
8 t2.start（）;
9 }
10 }
11
12 class MyThread3 extends Thread {
13 MyThread3（String s） {
14 super（s）;
15 }
16
17 public void run（） {
18 for （int i = 1; i <= 100; i++） {
19 System.out.println（getName（） + : + i）;
20 if （i ％ 10 == 0） {
21 yield（）;
22 }
23 }
24 }
25 }
运行成果我们会发明，t1线程和t2线程格子输出10个数字后就会进入守候队列把CPU让给了对方，所以他们轮流输出数字。
2.2.7线程暂停与唤醒 wait（） & notify（） & notifyAll（）
当火线程进入守候池（wait pool），wait办法经由过程参数可以指定守候的时长，若是没有指定参数，默认一向守候直到应用notify（）办法通知该线程或者notifyAll（）办法通知才会持续履行下去。须要重视的是，按照java文档的说法，调用这三个办法的对象的前提是当火线程是此对象把守器的所有者，换句话说，这履行这三个办法的对象必须被synchronized锁定，同时这三个办法在同步块中履行，不然会报以下错误：
Exception in thread main java.lang.IllegalMonitorStateException
at java.lang.Object.wait（Native Method）
at com.thread.second.TestWait.main（TestWait.java:23）
按照官方的申明就是：当火线程不是此对象把守器的所有者。下面我给出一个应用的例子吧，eg：
1 package com.thread.second;
2
3 public class TestWait extends Thread {
4 public TestWait（String name） {
5 super（name）;
6 }
7
8 ＠Override
9 public void run（） {
10 for （int i = 0; i < 30; i++） {
11 System.out.println（Thread.currentThread（）.getName（） + : + i）;
12 }
13 }
14
15 public static void main（String[] args） throws InterruptedException {
16 Thread t1 = new TestWait（t1）;
17 Thread t2 = new TestWait（t2）;
18
19 t1.start（）;
20
21 synchronized （t1） {
22 t1.wait（10）;
23 }
24 t2.start（）;
25
26 synchronized （t1） {
27 t1.notify（）;
28 }
29 }
30
31 }
2.3 sleep（） VS wait（）
sleep（）办法和wait（）办法都可以使得线程暂停守候，那么毕竟它们有什么共同点呢？有什么差别呢？
共同点：
1>都是在多线程的景象下，都可以或许使得线程暂停守候必然的时候;
2>都可以应用interrupt（）打断线程的守候状况，然则会使得线程对象立即抛出InterruptedException错误
差别：
1>起原不合，sleep（）是在Thread类中定义的，而wait（）是Object类定义的；
2>正如2.2.7中所说的，wait（）办法只能在同步块中应用，而sleep（）可以在任何处所应用；
3>应用sleep（）办法的时辰必须捕获异常，而wait（）办法不消
4>调用sleep（）办法并不会开释锁，睡眠时代，其他线程也无法接见这个对象；而wait（）办开释锁（临时的开释），守候时代，其他线程可以接见这个对象，关于这里的锁 ，并不是指synchronized，而是对象把守器，具体大师可以直接参考这个网址上说的：http://www.iteye.com/topic/310577
[本文为原创，转载请注明出处：http://www.cnblogs.com/xiaoxuetu]
原来，再大的房子，再大的床，没有相爱的人陪伴，都只是冰冷的物质。而如果身边有爱人陪伴，即使房子小，床小，也觉得无关紧要，因为这些物质上面有了爱的温度，成了家的元素。—— 何珞《婚房》#书摘#
如今很多面向对象说话中都有了操纵线程这个首要的功能，线程可以或许使错杂的一部代码变得更简单，大大的降落了错杂体系的开辟，跟着如今处理惩罚器数量的成长，充沛的哄骗线程，就可以或许更好的阐扬多处理惩罚器体系的强大才能。
1.根蒂根基概念
1.1线程和过程的关系
在刚开端的时辰，操纵体系（OS）为了使多个法度能并发履行，从而进步资料哄骗率和体系吞吐量，从而提出了过程，后来为了削减时空的开销，进步并发性和CPU的哄骗率，就提出了线程这个概念。
在OS中，其实线程包含于过程内的，一个法度只有一个过程，然则却可以有很多的线程，如图：
从图中，我们也可以很好的知道，过程是操纵体系中资料分派的根蒂根基单位，而线程只拥有运行时必不成少的资料，线程本身根蒂根基不拥有体系的资料，并且，因为附属 于过程，所以线程可以接见附属过程的资料，同一过程的线程间可以共享所属过程的资料，这也就呈现了后面我们必须采取办法处理惩罚线程间的同步题目。在运行时代，线程 才是操纵体系的调剂和分派的根蒂根基单位。同时，操纵体系在创建、撤销及切换线程的时辰，开销会比过程小。
1.2线程和过程的根蒂根基运行状况
其实，线程拥有的根蒂根基运行状况和过程一样，分别是以下3种：
1>履行状况，默示线程或者过程正获得处理惩罚机而运行；
2>伏贴状况，默示线程或者过程已经具备了各类履行前提，一旦获得CPU便可履行的状况；
3>梗阻状况，默示线程在履行中因为某时候而受阻，出于暂停履行时的状况。
它们的状况转换图具体如下：
1.3并发和并行
我们前面提到了并发这个词，日常平凡口中也经常提到并发和并行这两个词，很多人经常把他们混合来应用，然则，其实这两个词并不是等赞成义的，下面我们来看下他们的申明：
1>并发：是指两个或多个事务在同一时候间隔内产生；
2>并行：是指两个或多个事务在同一时刻产生；
1.4同步和异步
在操纵体系中，对同步和异步是如许描述的：
1>异步：多进（线）程按各自自力的，不成预知的速度向前推动；
2>同步：多个相干的进（线）程在履行次序长进行调和使之共享资料彼此合作。
或许直接如许子看概念会有点生涩难以懂得，那么就举一个经典的例子（临盆者与花费者）来共同窗习下吧。
假设我们如今有一个临盆过程和一个花费过程：
1>临盆过程在临盆产品并置于缓存（可以懂得为堆栈）的时代，花费过程不克不及进入缓存取临盆品，直到临盆产品临盆完产品开释它对缓存的掌控权之后，花费过程才可以进入缓存取临盆品，并且必须守候花费过程不再取临盆品并且开释了他对缓存的掌控权之后，临盆过程才可以再次进入缓存进行临盆。这个就是同步。
2>临盆过程将产品置于缓存之后并不关怀花费过程是否取走产品就持续临盆，也就是说在临盆过程临盆产品至于缓存的过程中，花费者过程也可以进入缓存取走产品。这个就是异步。
2.Java中的线程Thread
在Jdk中，已经连络体系的内核，给我们封装好了线程的把握API，我们只要创建一个线程对象，熟悉它的API，调用对应的函数，就可以把我们想要对线程进行的操纵传达给操纵体系，由操纵体系来帮我们完成，这就大大降落了进修者的进修难度，同时也大大雅便了开辟人员，进步了开辟效力。
2.1线程的实现体式格式
在Java中，我们有两种线程的实现体式格式
1>直接持续Thread类，重写父类的run（）办法，eg ：
1 package com.thread.first;
2
3 public class MyThread extends Thread {
4
5 //重写父类的run（）办法
6 ＠Override
7 public void run（） {
8 this.setName（The Thread To Print Number）;
9 for （int i = 0; i < 10; i++） {
10 System.out.println（this + + i）;
11 }
12 }
13
14 public static void main（String[] args） {
15 //重视，线程开端履行的办法是start（）而不是run（）办法
16 //具体差别后面会讲
17 new MyThread（）.start（）;
18 for （int i = 0; i < 10; i++） {
19 System.out.println（Main Thread : + i）;
20 }
21 }
22 }
因为线程在CPU中是并发履行瓜代履行的，所以履行成果并不独一，以下只是此中一种输出成果罢了，若是呈现跟下图不一样的成果，也不消愁闷，只要代码无误，能正常运行，就对了：
2>定义线程类并实现Runnable接口。因为Java是单持续了，若是持续了Thread类就不克不及持续其他的类了，而接口倒是可以实现多个的，同时这种体式格式还可以或许为多个线程供给共享的数据，所以在实际开辟中，我们都斗劲推荐应用这种体式格式定义线程类，eg:
1 package com.thread.second;
2
3 public class MyRunnable implements Runnable {
4
5 ＠Override
6 public void run（） {
7 //获取当火线程并且设置线程的名字
8 Thread.currentThread（）.setName（（The Thread To Print Number））;
9 for （int i = 0; i < 10; i++） {
10 System.out.println（Thread.currentThread（） + + i）;
11 }
12 }
13 }
1 package com.thread.second;
2
3 public class TestThread {
4 public static void main（String[] args） {
5 //重视将创建自定义的线程类对象并传进Thread类的机关办法中
6 new Thread（new MyRunnable（））.start（）;
7
8 for （int i = 0; i < 10; i++） {
9 System.out.println（Main Thread : + i）;
10 }
11
12 }
13 }
运行成果此次我就不贴出来啦，大师本身运行一下就知道的。
下面我们一路来看一下Runnable这个接口，其实它的源代码也很简单，就只有一个用来定义线程的运行体的run（）办法：
2.2线程的根蒂根基把握办法
2.2.1开端履行线程 start（）
其实这个，在前面我们的代码测试中已经用过了，我就不再别的给出一个代码啦，我们就直接讲一下run（）办法和start（）办法见的差别吧。
创建了一个线程对象之后，想要经由过程该对象开启线程，我们就要调用start（）办法，而不是run（）办法，因为经由过程run（）办法调用的只是办法的履行，还是属于当火线程的，也就是说依旧是单线程，我们经由过程一个简单的法度看看吧，eg：
1>直接调用run（）办法：
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 //输出当火线程的名字
8 System.out.println（in run menthod : + Thread.currentThread（）.getName（））;
9 }
10
11 public static void main（String[] args） {
12 //创建一个线程对象并且运行它的run办法
13 new TestThread（）.run（）;
14 //输出当火线程的名字
15 System.out.println（in main method : + Thread.currentThread（）.getName（））;
16 }
17 }
履行成果：
按照履行成果，我们发明，经由过程调用run（）办法并没有开启新的线程，也就是说依旧是单线程。下面我们再看看经由过程调用start（）办法的成果：
2>直接调用start（）办法：
//直接把上方一段代码中的run办法批改成调用start（）办法
//创建一个线程对象并且运行它的start（）办法
new TestThread（）.start（）;
履行成果：
按照履行成果，我们发明，经由过程调用start（）办法才是可以开启新的线程，也就是说实现线程并发的，具体为什么呢？我们再来看看Thread类中的项目组源代码吧。
1 public class Thread implements Runnable {
2 //Runnable接口
3 private Runnable target;
4
5 //这只是Thread的此中一个机关办法，
6 //其他的机关办法因为篇幅题目省略了
7 public Thread（Runnable target） {
8 init（null， target， Thread- + nextThreadNum（）， 0）;
9 }
10
11 //Thread经由过程实现Runnable接口重写的办法
12 ＠Override
13 public void run（） {
14 if （target != null） {
15 target.run（）;
16 }
17 }
18 public synchronized void start（） {
19
20 //.....
21 //前面省略了一项目组代码
22 boolean started = false;
23 try {
24 start0（）; //调用该办法启动线程
25 started = true; //设置线程开启状况为真
26 } finally {
27 try {
28 if （!started） {
29 group.threadStartFailed（this）;
30 }
31 } catch （Throwable ignore） {
32 / do nothing. If start0 threw a Throwable then
33 it will be passed up the call stack /
34 }
35 }
36 }
37
38 //经由过程JNI调用开启线程
39 private native void start0（）;
40 }
经由过程上述源代码我们知道，run（）办法中并没有开启线程，而是属于一个通俗的办常调用罢了，而start（）办法才有经由过程JNI调用线程。
2.2.2 断定线程存亡 isAlive（）
若是线程还存在，则返回true， 不然返回false;
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 //输出当火线程的名字
8 System.out.println（in run menthod : + Thread.currentThread（）.getName（））;
9 }
10
11 public static void main（String[] args） {
12 //创建一个线程对象
13 TestThread tt = new TestThread（）;
14 //线程还没有开启，下面语句将会输出false
15 System.out.println（线程还或者吗？ + tt.isAlive（））;;
16 tt.start（）;
17 //线程已经开启，下面语句将会输出true
18 System.out.println（线程还或者吗？ + tt.isAlive（））;;
19 }
20 }
当然啦，对线程的操纵，Java是不成能直接做到的，他也是经由过程JNI本地调用进行操纵的，源代码如下图：
2.2.3 线程的优先级 getPriority（） & setPriority（）
经由过程该办法可以设置线程的优先级，一般景象下，优先级越高的线程获得CPU调剂的时候片将会越长。java线程的优先级值默认为5，设置局限为1-10.
因为Java的线程是被映射到体系的原声线程上来实现的，所以线程调剂终极还是由操纵体系说了算的，固然很多线程都供给线程优先级的概念，然则并不剪得能与java线程的优先级一一对应，如Solaries中有231种优先级，Windows中就只有7中，并不必然能与java线程的优先级设置一一对应，是以，建议还是直接应用java本身自带的三个MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10）来设置优先级斗劲好，eg：
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 Thread currentThread = Thread.currentThread（）;
8 //输出当火线程的名字、优先等级
9 for （int i = 0; i < 50; i++） {
10 System.out.println（name : + currentThread.getName（）
11 + \t priopity : + currentThread.getPriority（） + + i）;
12 }
13 }
14
15 public static void main（String[] args） {
16 //创建优先级为5一个线程对象
17 TestThread ttNorm = new TestThread（）;
18 ttNorm.setPriority（NORM_PRIORITY）;
19 ttNorm.start（）;
20
21 //创建优先级为1一个线程对象
22 TestThread ttMin = new TestThread（）;
23 ttMin.setPriority（MIN_PRIORITY）;
24 ttMin.setPriority（MIN_PRIORITY）;
25 ttMin.start（）;
26
27 //创建优先级为10一个线程对象
28 TestThread ttMax = new TestThread（）;
29 ttMax.setPriority（MAX_PRIORITY）;
30 ttMax.start（）;
31
32 }
33 }
2.2.4线程睡眠时候sleep（）
讲当火线程指定睡眠毫秒数
1 ＠Override
2 public void run（） {
3 Thread currentThread = Thread.currentThread（）;
4 try {
5 Thread.sleep（1000）; //让线程休眠1秒钟
6 } catch （InterruptedException e） {
7 e.printStackTrace（）;
8 }
9 }
2.2.5线程归并join（）
归并某线程A的这个办法，将该线程与当火线程B归并，即守候该线程A履行完毕后再持续履行线程B，如图：
下面我们再来看看代码的实现，eg:
1 package com.thread.first;
2
3 public class TestThread extends Thread{
4
5 ＠Override
6 public void run（） {
7 Thread currentThread = Thread.currentThread（）;
8 //输出当火线程的名字、优先等级
9 for （int i = 0; i < 50; i++） {
10 System.out.println（name : + currentThread.getName（）
11 + \t priopity : + currentThread.getPriority（） + + i）;
12 }
13 }
14
15 public static void main（String[] args） throws Exception {
16 //创建优先级为5一个线程对象
17 TestThread ttNorm = new TestThread（）;
18 ttNorm.setPriority（NORM_PRIORITY）;
19 ttNorm.start（）;
20 ttNorm.join（）; //归并线程
21 Thread currentThread = Thread.currentThread（）;
22 for （int i = 0; i < 50; i++） {
23 System.out.println（name : + currentThread.getName（）
24 + \t priopity : + currentThread.getPriority（） + + i）;
25 }
26 }
27 }
2.2.6 yield（）
让出CPU，当火线程进入伏贴队列守候调剂，测试代码如下：
1 package com.thread.first;
2
3 public class TestYield {
4 public static void main（String[] args） {
5 MyThread3 t1 = new MyThread3（t1）;
6 MyThread3 t2 = new MyThread3（t2）;
7 t1.start（）;
8 t2.start（）;
9 }
10 }
11
12 class MyThread3 extends Thread {
13 MyThread3（String s） {
14 super（s）;
15 }
16
17 public void run（） {
18 for （int i = 1; i <= 100; i++） {
19 System.out.println（getName（） + : + i）;
20 if （i ％ 10 == 0） {
21 yield（）;
22 }
23 }
24 }
25 }
运行成果我们会发明，t1线程和t2线程格子输出10个数字后就会进入守候队列把CPU让给了对方，所以他们轮流输出数字。
2.2.7线程暂停与唤醒 wait（） & notify（） & notifyAll（）
当火线程进入守候池（wait pool），wait办法经由过程参数可以指定守候的时长，若是没有指定参数，默认一向守候直到应用notify（）办法通知该线程或者notifyAll（）办法通知才会持续履行下去。须要重视的是，按照java文档的说法，调用这三个办法的对象的前提是当火线程是此对象把守器的所有者，换句话说，这履行这三个办法的对象必须被synchronized锁定，同时这三个办法在同步块中履行，不然会报以下错误：
Exception in thread main java.lang.IllegalMonitorStateException
at java.lang.Object.wait（Native Method）
at com.thread.second.TestWait.main（TestWait.java:23）
按照官方的申明就是：当火线程不是此对象把守器的所有者。下面我给出一个应用的例子吧，eg：
1 package com.thread.second;
2
3 public class TestWait extends Thread {
4 public TestWait（String name） {
5 super（name）;
6 }
7
8 ＠Override
9 public void run（） {
10 for （int i = 0; i < 30; i++） {
11 System.out.println（Thread.currentThread（）.getName（） + : + i）;
12 }
13 }
14
15 public static void main（String[] args） throws InterruptedException {
16 Thread t1 = new TestWait（t1）;
17 Thread t2 = new TestWait（t2）;
18
19 t1.start（）;
20
21 synchronized （t1） {
22 t1.wait（10）;
23 }
24 t2.start（）;
25
26 synchronized （t1） {
27 t1.notify（）;
28 }
29 }
30
31 }
2.3 sleep（） VS wait（）
sleep（）办法和wait（）办法都可以使得线程暂停守候，那么毕竟它们有什么共同点呢？有什么差别呢？
共同点：
1>都是在多线程的景象下，都可以或许使得线程暂停守候必然的时候;
2>都可以应用interrupt（）打断线程的守候状况，然则会使得线程对象立即抛出InterruptedException错误
差别：
1>起原不合，sleep（）是在Thread类中定义的，而wait（）是Object类定义的；
2>正如2.2.7中所说的，wait（）办法只能在同步块中应用，而sleep（）可以在任何处所应用；
3>应用sleep（）办法的时辰必须捕获异常，而wait（）办法不消
4>调用sleep（）办法并不会开释锁，睡眠时代，其他线程也无法接见这个对象；而wait（）办开释锁（临时的开释），守候时代，其他线程可以接见这个对象，关于这里的锁 ，并不是指synchronized，而是对象把守器，具体大师可以直接参考这个网址上说的：http://www.iteye.com/topic/310577
[本文为原创，转载请注明出处：http://www.cnblogs.com/xiaoxuetu]
