Java多线程3：Thread中的实例方法

一、Thread类中的方法调用方式

　　学习Thread类中的方法是学习多线程的第一步。在学习多线程之前特别提出一点，调用Thread中的方法的时候，在线程类中，有两种方式，一定要理解这两种方式的区别：

　　1、this.XXX()

　　这种调用方式表示的线程是线程实例本身

　　2、Thread.currentThread.XXX()或Thread.XXX()

　　上面两种写法是一样的意思。这种调用方式表示的线程是正在执行Thread.currentThread.XXX()所在代码块的线程

　　当然，这么说，肯定有人不理解两者之间的差别。没有关系，之后会讲清楚，尤其是在讲Thread构造函数这块。讲解后，再回过头来看上面2点，会加深理解。

二、Thread类中的实例方法

　　从Thread类中的实例方法和类方法的角度讲解Thread中的方法，这种区分的角度也有助于理解多线程中的方法。实例方法，只和实例线程（也就是new出来的线程）本身挂钩，和当前运行的是哪个线程无关。看下Thread类中的实例方法：

　　1、start()方法

　　start()方法的作用讲得直白点就是通知"线程规划器"，此线程可以运行了，正在等待CPU调用线程对象的run()方法，产生一个异步执行的效果。补充知识点：怎样理解阻塞非阻塞与同步异步的区别？

　　举例：

public class Thread01 implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i < 5; i++) {
            try {
                Thread.sleep((int) Math.random() * 5000);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable runnable = new Thread01();
        Thread thread = new Thread(runnable);
        thread.start();
        for(int i = 0; i < 5; i++) {
            try {
                Thread.sleep((int) Math.random() * 5000);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

　　第一次运行结果：

Thread-0
main
Thread-0
main
Thread-0
main
Thread-0
main
Thread-0
main

　　第二次运行结果：

main
Thread-0
main
Thread-0
main
Thread-0
Thread-0
Thread-0
main
main

　　可以看到，CPU调用哪个线程具有不确定性。再举例说明start()方法的顺序是否就是线程启动的顺序？

public class Thread01 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable runnable = new Thread01();
        //创建线程1
        Thread thread1 = new Thread(runnable);
        //创建线程2
        Thread thread2 = new Thread(runnable);
        //创建线程3
        Thread thread3 = new Thread(runnable);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

　　第一次运行的结果：

Thread-1
Thread-0
Thread-2

　　第二次运行的结果：

Thread-2
Thread-0
Thread-1

　　尽管启动线程的顺序是thread1，thread2，thread3，但是被调用的顺序却不是按照启动顺序来的。即：调用start()方法的顺序不代表线程的启动顺序，线程的启动顺序具有不确定性。

　　2、run()方法

　　线程开始执行，虚拟机调用的是线程run()方法中的内容，当线程没有通过start()方法让其处于被调用状态的时候，其线程的run()方法不会被执行的。但是如果直接通过.run()来调用的话，还是可以调用的到，但这个时候run()方法所在线程就是主线程了，仅仅只是一个普通方法而已，不在充当线程中的run()方法的作用。

　　举例：通过.start()方法获取run()方法所在的线程

public class Thread01 implements Runnable{
    @Override
    public void run() {
        System.out.println("run方法所在的线程为：" + Thread.currentThread().getName());
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable runnable = new Thread01();
        //创建线程
        Thread thread1 = new Thread(runnable);
        thread1.start();
    }
}

　　结果：

run方法所在的线程为：Thread-0

　　可以看到run()方法所在的线程就是我们创建的线程，而不再main主线程内。

　　通过.run()方法获取run()方法所在的线程

public class Thread01 implements Runnable{
    @Override
    public void run() {
        System.out.println("run方法所在的线程为：" + Thread.currentThread().getName());
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable runnable = new Thread01();
        //创建线程
        Thread thread1 = new Thread(runnable);
        thread1.run();
    }
}

　　结果：

run方法所在的线程为：main

　　可以看到，此时run()方法所在的线程就是main主线程，而不再是我们自己创建的那个线程。

　　所以，通过start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。不通过start()方法来直接调用的话，run()方法只是thread的一个普通方法，还是在主线程里执行。

　　3、isAlive()方法

　　判断线程是否处于活动状态，只要线程处于启动且没有终止，返回的就是true。

/**
     * Tests if this thread is alive. A thread is alive if it has
     * been started and has not yet died.
     *
     * @return  <code>true</code> if this thread is alive;
     *          <code>false</code> otherwise.
     */
    public final native boolean isAlive();

　　举例：

public class Thread01 extends Thread{
    @Override
    public void run() {
        System.out.println("线程run时的isAlive=====" + this.isAlive());
    }
}

public class Test {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        System.out.println("线程被new出来还未被调用时的isAlive======" + thread01.isAlive());
        thread01.start();
        System.out.println("线程通过start被调用时的isAlive======" + thread01.isAlive());
        try {
            thread01.sleep(1000);
            System.out.println("线程执行完时的isAlive======" + thread01.isAlive());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

　　结果：

线程被new出来还未被调用时的isAlive======false
线程通过start被调用时的isAlive======true
线程run时的isAlive=====true
线程执行完时的isAlive======false

　　看到在start()之前，线程的isAlive是false，start()之后就是true了。main函数中加上Thread.sleep(100)的原因是为了确保Thread06的run()方法中的代码执行完，否则有可能end这里打印出来的是true，如下去掉sleep方法之后　

public class Test {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        System.out.println("线程被new出来还未被调用时的isAlive======" + thread01.isAlive());
        thread01.start();
        System.out.println("线程通过start被调用时的isAlive======" + thread01.isAlive());
        
        System.out.println("线程执行完时的isAlive======" + thread01.isAlive());
    }
}

　　结果：

线程被new出来还未被调用时的isAlive======false
线程通过start被调用时的isAlive======true
线程执行完时的isAlive======true
线程run时的isAlive=====true

　　产生这种结果的原因是main线程和thread01这两个线程并发执行，main线程执行完了的时候，thread01 线程还未开始执行，所以其isAlive的值是true。

　　4、getID()方法

　　这个方法比较简单，返回的就是当前线程对应的tid(Thread ID)，这个tid是通过全局唯一的线程ID生成器threadSeqNumber来维护的，每new出一个线程threadSeqNumber都会自增一次，并赋予线程的tid属性，这个是Thread自己做的，用户无法自己制定tid。

　　举例：

public class Thread01 extends Thread{
    @Override
    public void run() {
        System.out.println("线程run时的isAlive=====" + this.isAlive());
    }
}

public class Test {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        Thread01 thread02 = new Thread01();
        System.out.println(thread01.getId());
        System.out.println(thread02.getId());
    }
}

　　结果：

11
12

　　5、getName()方法

　　new一个线程的时候，可以指定线程的名字，也可以不指定。如果指定，线程的名字就是我们指定的名字，getName()返回的就是我们指定的线程的名字。如果不指定，getName()返回的是"Thread-" + threadInitNumber，其中threadInitNumber是一个int型全局唯一的线程初始号生成器，threadInitNumber通过自增来维护线程初始号，所以返回的就是Thread-0，Thread-1，Thread-2等等。

　　举例：

public class Test {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        Thread01 thread02 = new Thread01();
        System.out.println(thread01.getName());
        System.out.println(thread02.getName());
    }
}

　　结果：

Thread-0
Thread-1

　　6、getPriority()和setPriority(int newPriority)

　　这两个方法用于获取和设置线程的优先级，优先级高的线程获取CPU的资源比较多，会比较容易先执行（不是一定会先执行）。线程的优先级别为1-10，其中1优先级最低，10优先级最高，即优先级越高的线程越先执行。

　　举例：未设置优先级时

public class Thread01 extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 100000; i++) {

        }
        System.out.println("※※※" + "的优先级为：" + this.getPriority());
    }
}

public class Thread02 extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 100000; i++) {

        }
        System.out.println("======" + "的优先级为：" + this.getPriority());
    }
}

public class Test {
    public static void main(String[] args) {
        for(int i = 0; i < 5; i++) {
            Thread01 thread01 = new Thread01();
            Thread02 thread02 = new Thread02();
            thread01.start();
            thread02.start();
        }
    }
}

　　结果：

※※※的优先级为：5
======的优先级为：5
※※※的优先级为：5
======的优先级为：5
======的优先级为：5
※※※的优先级为：5
※※※的优先级为：5
======的优先级为：5
======的优先级为：5
※※※的优先级为：5

　　可以看到，未设置线程的优先级的时候，线程的优先级别默认是5，此时※与=代表的线程并没有明显的先后执行顺序，下面设置一下线程的优先级

public class Test {
    public static void main(String[] args) {
        for(int i = 0; i < 5; i++) {
            Thread01 thread01 = new Thread01();
            Thread02 thread02 = new Thread02();
            thread01.setPriority(10);
            thread02.setPriority(1);
            thread01.start();
            thread02.start();
        }
    }
}

　　结果：

※※※的优先级为：10
※※※的优先级为：10
※※※的优先级为：10
======的优先级为：1
======的优先级为：1
※※※的优先级为：10
※※※的优先级为：10
======的优先级为：1
======的优先级为：1
======的优先级为：1

　　可以看到，优先级别为10的线程会比较容易先执行，但并不是优先级高的线程执行完了在执行优先级低的线程，而是在该时间片内，优先级高的线程会容易先执行。

 　　7、isDaemon()方法和setDaemon()方法

　　daemon：[ˈdi:mən] 守护的意思。讲解两个方法前，首先要知道理解一个概念。Java中有两种线程，一种是用户线程（user thread），一种是守护线程（daemon thread），守护线程是一种特殊的线程，它的作用是为其他线程的运行提供便利的服务，最典型的应用便是GC线程。如果进程中不存在非守护线程（即用户线程）了，那么守护线程自动销毁，因为没有存在的必要，为别人服务，结果服务的对象都没了，当然就销毁了。

　　举例：thread01不设置成守护线程

public class Thread01 extends Thread{
    private int i = 1;
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(200);
                System.out.println(i);
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        thread01.start();
        System.out.println("thread01是否是守护线程==" + thread01.isDaemon());
        System.out.println("main线程是否是守护线程==" + Thread.currentThread().isDaemon());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main主线程执行完了");
    }
}

　　说明：此程序中存在两个线程，一个是main主线程（用户线程），一个是thread01（用户线程），两个线程并发执行，所以main线程执行完了之后并不影响thread01 线程的继续执行，因为thread01中的while一致为true，所以thread01会一直执行下去

　　结果：

thread01是否是守护线程==false
main线程是否是守护线程==false
1
2
3
4
main主线程执行完了
5
6
7
8
9
...
...
...
...
...

　　thread01设置成守护线程后

public class Test {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        thread01.setDaemon(true);
        thread01.start();
        System.out.println("thread01是否是守护线程==" + thread01.isDaemon());
        System.out.println("main线程是否是守护线程==" + Thread.currentThread().isDaemon());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main主线程执行完了");
    }
}

　　结果：

thread01是否是守护线程==true
main线程是否是守护线程==false
1
2
3
4
main主线程执行完了

　　说明：将thread01线程设置成守护线程后，该程序中的两个线程（main线程和thread01线程）并发执行，但是当main线程执行完之后，作为守护线程的thread01自动销毁，不在继续执行。

　　关于守护线程，有一个细节注意下，setDaemon(true)必须在线程start()之前设置（This method must be invoked before the thread is started）。

　　8、interrupt()方法

　　这是一个有点误导性的名字，实际上Thread类的interrupt()方法无法中断线程。

　　举例：

public class Thread01 extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 50000; i++) {
            System.out.println("i = " + (i + 1));
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        thread01.start();
        thread01.interrupt();
    }
}

　　结果：

.............
.............
i = 49997
i = 49998
i = 49999
i = 50000

　　看结果还是打印到了50000。也就是说，尽管调用了interrupt()方法，但是线程并没有停止。interrupt()方法的作用实际上是：在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞状态。换句话说，没有被阻塞的线程，调用interrupt()方法是不起作用的。关于这个会在之后讲中断机制的时候，专门写一篇文章讲解。

　　9、isInterrupted()方法

　　测试线程是否处于中断状态，但是不清除状态标识。（Tests whether this thread has been interrupted. The interrupted status of the thread is unaffected by this method）。这个和interrupt()方法一样，在后面讲中断机制的文章中专门会讲到。

　　10、join()方法

　　该方法暂时不写，后续会补上。

参考资料：

　　[Java] Thread的start()和run()函数区别

       Java多线程之interrupt()的深度研究