线程的介绍
概念：线程是程序的执行路径，每一个线程都有自己的局部变量，程序计数器，以及各自的生命周期。
快速启动一个线程
认识Thread Class类
public static void main(String [] args){
new Thread(){
@Override
public void run(){
enjoyMusic();
}
}.start();
enjoyNews();
public static void enjoyMusic(){
for(;;){
System.out.println("我在播放音乐");
}
}
public static void enjoyNews(){
for(;;){
System.out.println("我在看新闻呢!");
}
}
执行结果
我在播放音乐和我在看新闻呢！ 交替输出
}
使用Jconsole观察线程
可以使用JDK的Bin目录下的Jconsole.exe 观察当前线程的信息
线程的生命周期
问题：线程Thread执行了start方法就表示该线程已近执行了忙？
下面看线程生命周期图
线程的生命周期
由以上图可以知道，线程的生命周期大致可以分为以下五个阶段：
NEW
RUNNABLE
RUNNING
BLOCKED
TERMINATED
1.NEW状态
当我们new出一个Thread类的时候，此时它并不在执行状态，并且它并没有调用Start方法，那么此时线程的状态为New。
NEW状态通过Start 方法进入RUNNABLE 状态
2.RUNNABLE状态
一个线程new出来之后，通过调用start方法进入RUNNABLE 状态，此时线程正在会立即执行忙？答案是否定的，线程和进程一样 都要听命于CPU调度（其实是在等待获取CPU时间片），此时它只具备可执行资格，但是并没有真正的执行，
并且线程存在RUNNING 状态 不会一下就进入阻塞状态(BLOCKED)状态和消亡状态（TERMINATED），即使是在线程运行期间执行，wait,sleep或者其他阻塞该线程的操作，也必须获得CPU调度的执行权 才可以。RUNNABLE 的线程只能进入RUNNING状态或者意外终止。
3.RUNNING 状态
一旦CPU轮询或者其他方式从任务可执行队列中选中了线程，才能真正的执行自己的代码，正在RUNNING 的线程其实也是RUNNABLE 的，则反过来不成立，在该状态中，线程可以发生如下的状态改变。
- 直接进入消亡状态(TERMINATED),比如执行了JDK已近不推荐的Stop方法。
- 进入阻塞状态(BLOCKED) ，如调用了Sleep()方法，或者wait方法。
- 进行了阻塞的IO操作，从而网络数据的读写进入了BLOCKED 状态 。
- 获取某个资源，从而加入到改锁的阻塞队列 ，从而进入了 BLOCKED状态。
- 由于CPU调度器轮询使该线程放弃执行，进入BLOCKED状态。
- 线程主动调用yield,放弃CPU执行权，进入BLOCKED状态。
4.BLOCKED状态
BLOCKED状态跟RUNNING状态类似，可以发生如下的状态改变 - 直接进入消亡状态(TERMINATED),比如执行了JDK已近不推荐的Stop方法。
- 线程阻塞的操作结束，比如读取到了想要读取的数据，进入RUNNABLED状态，
- 线程完成了休眠的状态，进入到了RUNNABLED状态
- Wait中的线程被其他线程唤醒(notify,notifyall)，进入到RUNNABLED状态
- 线程获取到了某个锁资源，进入到了RUNNABLED状态
- 线程在阻塞过程中，被打断（调用Interrupt），从而进入到了RUNNABLED状态，
5.TERMINATED 状态
TERMINATED 是一个最终 的状态，该线程的状态不会有TERMINATED 转换到其他的状态，进入到TERMINATED 状态，意味着该线程的声明周期结束了，以下操作，会让线程进入TERMINATED 状态 - 线程正常结束，进入TERMINATED状态
- 线程运行出错，意外终止
- JVM Crash 所有线程都结束
线程Start方法剖析
一个线程Thread new 出来之后，重写run()方法，并且 调用start方法，进入到了可执行状态（RUNNABLED）。那么run方法和start方法究竟是什么关系呢？看源码
private volatile int threadStatus = 0;
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)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
以上代码最关键的部分是调用了start0()这个方法，重写Run方法何时被调用了呢？在开始一个线程的时候JVM会调用该线程的Run方法，run方法是被JNI方法start0()调用的，查看源码我们发现以下问题：
1.当Thread被构造出new状态后，他的threadStatus 默认为0
2.不能两次启动,两次调用start方法，否则机会抛出IllegalThreadStateException 异常
3.线程启动会被加入ThreadGroup中，
4.一个线程的生命周期结束，也就是到了TERMINATED 状态，再次start方法，是不被允许的，也就是说TERMINATED 状态没有办法回到，RUNNABLED/RUNNING状态的
Thread t = new Thread(new Runnable() {
@Override
public void run() {
sleep(10);
}
});
t.start();
t.start();
上述代码会抛出 IllegalThreadStateException 异常，我们可以改动一下模拟线程的声明周期结束。
Thread t = new Thread(new Runnable() {
@Override
public void run() {
sleep(1);
}
});
t.start();
TimeUnit.SECONDS.sleep(2);//休眠是确保thread结束声明周期
t.start();//重新激活线程
以上两个例子都会抛出异常 ，但是意义是不一样的，第一个线程不能被启动两次，第二个启动是不被允许的。
模板模式在Thread中的应用
通过上述代码，我们不难看出，线程执行的业务逻辑在Run方法内部，我们用重写run方法 用start方法启动线程，其实Thread中的run方法和start是一个比较典型的模板设计模式，父类定义算法结构代码，子类实现业务逻辑。
下面举个列子
银行有四台取号机，每台取号机都有排队等候，当你进入业务大厅的时候需要取号，领取一张纸质号码，假设有四台出号机器， 每天最对受理30笔业务，ticketShow 代表出号机器
public class ticketShow extends Thread{
public final String name;
public static final int MAX = 50;
private int index = 1;
ticketShow (String name){
this.name = name;
}
@Overried
public void run(){
while(index <= MAX){
System.out.println("当前机器:"+name+",出的号码是："+(index++));
}
}
}
接下来编写一个main方法
public static void main(String [] args){
ticketShow ts = new ticketShow ("一号机器");
ts.start();
ticketShow ts = new ticketShow ("二号机器");
ts.start();
ticketShow ts = new ticketShow ("三号机器");
ts.start();
ticketShow ts = new ticketShow ("四号机器");
ts.start();
}
然而每台机器都是从1到50，四个线程并没有交互，获取唯一一个递增的号码，那么我们改进一下
public class ticketShow extends Thread{
public final String name;
public static final int MAX = 50;
private static int index = 1;
ticketShow (String name){
this.name = name;
}
@Overried
public void run(){
while(index <= MAX){
System.out.println("当前机器:"+name+",出的号码是："+(index++));
}
}
}
再次运行，发现四个出号机器，交替输出不同的号码，
通过对Index进行static 修饰，做到了多线程下共享资源的唯一性，看起来似乎满足了我们的需求，但是还是有些问题 比如我们的共享资源很多呢，要经过一些复杂的计算呢？等等等。。。
策略模式在Runnable在thread中的应用
很多文章中都会说，创建线程有两种方式，第一个是构造Thread，第二个是构造Runnable 其实这种说法是错误的，最起码是不严谨的，准确来说，创建线程只有一种方式，那就是构造Thread类，而实现线程的执行单元有两种方式，第一个是重写Thread中的run方法，第二个是重写runnable中的run方法，当然他们还是有些不同的，那就是Thread类中的run方法是不能共享的，也就是说线程A不能把线程B中的run方法当做自己的执行单元，然而runnable接口就很容易实现这一点。使用不同的runable构造不同的thread实例。
那我们对银行取票机代码进行 重构一下
public class ticketShow implements runnable{
public final String name;
public static final int MAX = 50;
private int index = 1; //不做static 修饰
ticketShow (String name){
this.name = name;
}
@Overried
public void run(){
while(index <= MAX){
System.out.println("当前机器:"+name+",出的号码是："+(index++));
sleep(100);
}
}
}
添加main方法
public static void main(String [] args){
final ticketShow ts = new ticketShow ();
Thread t1 = new Thread(ts,"一号机器");
t1.start();
Thread t2 = new Thread(ts,"二号机器");
t2.start();
Thread t3 = new Thread(ts,"三号机器");
t3.start();
Thread t4 = new Thread(ts,"四号机器");
t4.start();
}
可以看到上述代码的输入和继承Thread类实现并且是同样的效果，四个较好机器线程都实现了同一个接口Runnable，这样她们的资源都是共享的，不会出现每一个叫号机器从一到五十的情况。
网友评论