JAVA多线程（一）

2019-04-17 本文已影响0人以南之南_b9a1

线程的介绍

概念：线程是程序的执行路径，每一个线程都有自己的局部变量，程序计数器，以及各自的生命周期。

快速启动一个线程

认识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，这样她们的资源都是共享的，不会出现每一个叫号机器从一到五十的情况。

JAVA多线程（一）

线程的介绍

快速启动一个线程

使用Jconsole观察线程

线程的生命周期

线程Start方法剖析

模板模式在Thread中的应用

策略模式在Runnable在thread中的应用

猜你喜欢

热点阅读