Java进阶学习笔记（四） 多线程编程（一）线程状态简介、启动线程、线程方法

本文参考HOW2J教程、菜鸟教程

一、线程状态简介

• 新建状态:
  使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

• 就绪状态:
  当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

• 运行状态:
  如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

• 阻塞状态:
  如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

  • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

  • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

  • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

• 死亡状态:
  一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

---

二、启动线程

多线程有三种创建方法：

• 继承线程类：继承Thread，并且重写run方法
• 实现Runnable接口

1、继承线程类

我们继承线程类Thread并从写run()方法

public class ThreadLearn extends Thread {
    private String threadName;

    public ThreadLearn(String threadName) {
        this.threadName = threadName;
        System.out.println("获取到线程名:" + threadName);
    }

    @Override
    public void run() {
        for (int i = 0; i<20; i++) {
//            延时，睡眠 0.1秒
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.threadName);
        }
    }
}

测试代码如下：

    public static void main(String[] args) {
        ThreadLearn threadLearn = new ThreadLearn("一号");
        ThreadLearn threadLearn2 = new ThreadLearn("贰号");
        threadLearn.start();
        threadLearn2.start();
    }

结果如下，可看出来两个线程同时进行，而非一号线程执行完毕后，再执行二号线程。

获取到线程名:一号
获取到线程名:贰号
一号
贰号
一号
贰号
一号
。。。

为什么我们重写的run()，但是我们调用的是start()呢？
可以看看多线程简介中就绪状态，start（）使线程进入就绪状态，之后由线程调度器调度，若直接调用run()方法，即没有通过线程调度器调用

2、实现Runnable接口

新建类，继承runnable，重写run()，代码如下所示：

public class RunnableLearn implements Runnable {
    private String runnableName;

    public RunnableLearn(String runnableName) {
        this.runnableName = runnableName;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(runnableName);
        }
    }
}

测试方法如下所示：

    public static void main(String[] args) {
        RunnableLearn runnableLearn = new RunnableLearn("一号");
        RunnableLearn runnableLearn2 = new RunnableLearn("贰号");

        new Thread(runnableLearn).start();
        new Thread(runnableLearn2).start();
    }

运行结果如下,效果与继承Thread相同

一号
贰号
贰号
一号
贰号
一号
贰号

3、匿名类

匿名类的好处是可以访问外部变量，当需要完成一些简单的操作时，用匿名类很方便。

测试代码如下所示：

public class LearnApplication {
    private static void printNameLoop(String string) {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(string);
        }
    }

    public static void main(String[] args) {
        String name1 = "一号";
        String name2 = "贰号";
        //匿名类
        Thread t1= new Thread(){
            @Override
            public void run(){
                printNameLoop(name1);
            }
        };
        Thread t2= new Thread(){
            @Override
            public void run(){
                printNameLoop(name2);
            }
        };
        t1.start();
        t2.start();
    }
}

结果如下所示：

贰号
一号
一号
贰号
贰号
一号

三、线程方法

方法名	作用
sleep	当前线程暂停
join	加入到当前线程中
setPriority	线程优先级
yield	临时暂停
setDaemon	守护线程

1、sleep

Thread.sleep(1000); 表示当前线程暂停1000毫秒 ，其他线程不受影响
Thread.sleep(1000); 会抛出InterruptedException 中断异常，因为当前线程sleep的时候，有可能被停止，这时就会抛出 InterruptedException

若是写在线程中，则是线程暂停1000毫秒，若是写在main中，则是主线程暂停1000毫秒

        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(string);
        }

2、join

这个join的意思是当前线程，会加入主线程（即main），即需要等待当前线程运行完毕后，才会运行后续代码。
示例如下：

    public static void main(String[] args) throws InterruptedException {
        Thread thread= new Thread(){
            @Override
            public void run(){
                try {
                    sleep(2000);
                    System.out.println("run内容执行完毕");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        thread.start();
        thread.join();
        System.out.println("main走完了");
    }

结果如下，即thread成功加入了主线程，等到thread运行完毕后，才继续运行后续代码。

run内容执行完毕
main走完了

若没有thread.join()，结果如下所示

main走完了
run内容执行完毕

3、线程优先级

当线程处于竞争关系的时候，优先级高的线程会有更大的几率获得CPU资源
我们设置threadLearn2为最低优先级，让其先运行。
设置threadLearn1为最高有限期，让其后运行。

    public static void main(String[] args) throws InterruptedException {
        ThreadLearn threadLearn1 = new ThreadLearn("一号");
        ThreadLearn threadLearn2 = new ThreadLearn("贰号贰号贰号贰号");
        
//        设置优先级
        threadLearn1.setPriority(Thread.MAX_PRIORITY);//Thread.MAX_PRIORITY = 10
        threadLearn2.setPriority(Thread.MIN_PRIORITY);// Thread.MIN_PRIORITY = 1

        threadLearn2.start();
        threadLearn1.start();
    }

运行结果如下图所示，可发现threadLearn由于优先级极高，一开始就抢占了cpu，所以前面只能看到“一号”

获取到线程名:一号
获取到线程名:贰号贰号贰号贰号
一号
一号
一号
一号
一号
一号
......
贰号贰号贰号贰号

4、暂停

当某个线程调用yield()方法时，就会从运行状态转换到就绪状态后，CPU从就绪状态线程队列中只会选择与该线程优先级相同或者更高优先级的线程去执行。

    public static void main(String[] args) throws InterruptedException {
        Thread t1= new Thread(){
            @Override
            public void run(){
                while(true){
                    System.out.println("线程一");
                }
            }
        };

        Thread t2= new Thread(){
            @Override
            public void run(){
                while(true){
                    //临时暂停，使得t1可以占用CPU资源
                    Thread.yield();
                    System.out.println("二号二号二号");
                }
            }
        };

        t1.setPriority(5);
        t2.setPriority(5);
        t1.start();
        t2.start();
    }

执行结果如下所示：

线程一
线程一
线程一
线程一
线程一
二号二号二号
线程一
线程一

5、守护进程

setDaemon 可设置某个进程为守护进程

守护线程的概念是： 当一个进程里，所有的线程都是守护线程的时候，结束当前进程。

就好像一个公司有销售部，生产部这些和业务挂钩的部门。
除此之外，还有后勤，行政等这些支持部门。

如果一家公司销售部，生产部都解散了，那么只剩下后勤和行政，那么这家公司也可以解散了。

守护线程就相当于那些支持部门，如果一个进程只剩下守护线程，那么进程就会自动结束。

守护线程通常会被用来做日志，性能统计等工作。

    public static void main(String[] args) throws InterruptedException {
        Thread t1= new Thread(){
            @Override
            public void run(){
                int seconds =0;

                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.printf("运行了 %d 秒%n", seconds++);

                }
            }
        };
        t1.setDaemon(true);
        t1.start();
        Thread.sleep(5000);
        System.out.println("主进程结束，所有非守护进程均已结束");
    }