Java多线程（二）——Thread类的相关属性及方法

Thread类的构造方法

Thread()

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("hello Thread");
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();

        System.out.println("hello main");
    }
}

Thread(Runnable target)

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("hello Thread");
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();

        System.out.println("hello main");
    }
}

Thread(String name),Thread(Runnable target, String name):这两种都是给线程取了个名字为了调试的时候知道哪个线程在被调度

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello Thread");
            }
        },"thread-1");
        t.start();

        System.out.println("hello main");
    }
}

这里的thread-1就是找个线程的名字

Thread 的几个常见属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程	isDeamon()
是否存活	isAlive()
是否被中断	isInterrupted()

ID：是线程的唯一标识，不同线程不会重复
名称：是各种调试工具用到
状态：表示线程当前所处的一个情况，下面我们会进一步说明
优先级：高的线程理论上来说更容易被调度到
后台线程：需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
是否存活：即简单的理解，为 run 方法是否运行结束了
这里主要讲解几个比较重要的属性；

是否是后台线程

举个例子，你的手机同时打开了微信和QQ两个应用，当你在微信聊天时，微信就是前台线程，QQ就是后台线程；这里的后台线程我们往往也会成为守护线程
前台线程：会阻止进程结束，某一前台线程没有结束整个进程也不会结束
后台线程：不会阻止进程结束，后台线程工作没有完成，进程也可以结束

代码中手动创建的线程往往都是前台线程（比如刚才创建的t线程以及主线程main），jvm自带的线程一般默认为后台线程,前台线程直接影响整个进程是否结束（前台线程不结束进程不会结束），代码如下：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello Thread");
            }
        });
        t.start();
    }
}

这个线程内的方法会一直打印hello Thread，因为创建的线程属于前台线程，不执行完整个进程不会停止，当我们用setDaemon方法把该线程设置为后台线程时进程就会停止（哪个线程调用setDemo方法并把它设置成true哪个线程就会变成后台线程），代码如下：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello Thread");
            }
        });
        t.setDaemon(true);
        t.start();
    }
}

通过结果可以看出此时t线程被设置成后台线程之后，即使后台线程的run方法没有执行完也可以结束整个进程（因为此时这里的main线程为前台线程，main线程执行完毕进程就会结束。

是否存活

isAlive方法是判断此时操作系统内核是否有线程
线程的生命周期：在未调用start方法时，没有创建线程，此时isAlive方法的返回值为false，调用start方法之后真正创建了线程，此时返回值为true（但是如果线程执行完run方法之后，操作系统内核创建的PCB随之销毁，此时isAlive方法的返回值也是false）；
注意：这里线程会随之销毁，但是t对象不会立刻被回收，t对象直到没有人引用时被GC回收。
举个例子：

 public static void main(String[] args) {
        Thread t = new Thread(()-> {
            while (true) {
                
            }
        });
        t.start();
        System.out.println(t.isAlive());
    }

t线程一直进行循环（一直存在），此时调用isAlive方法之后会输出true；

当我们在调用isAlive方法之前休眠一下会有什么结果：

Thread t = new Thread(()-> {
            System.out.println("hello thread");
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t.isAlive());

此时在调用isAlive方法之前进行休眠，会先执行先创建的线程，执行完run方法之后线程也会随之销毁，所以此时的返回值为false。

线程终止

线程终止的意思是系统告诉你该线程要停止了，不是立刻停止，具体怎么执行看你的代码是如何书写的，举个例子：
假如你正在打游戏，你妈妈喊你吃饭，此时你就会有三种处理方式：

1. 立刻停止打游戏去吃饭；
2. 打完这一把游戏再去吃饭；
3. 完全当作没听见不做任何处理；
   线程也是这样的，具体怎么执行还是看你的代码如何书写。

线程终止的方式有两种：
1. 使用标志位来控制线程是否要终止；
2. 使用Thread自带的标志位来进行判定。

使用标志位来控制线程是否要终止

public static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (flag) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        flag = false;
    }

定义了一个flag类型的布尔变量，flag为true时，t线程会一直运行，当将flag修改为false时，t线程运行结束；
这里的flag就是自己定义的标志位，但是自定义标志位有一个缺点就是不能及时响应（每一次进行循环判断的时候都需要等待sleep休眠结束），所以有了第二种使用Thread自带的标志位进行判断；

使用Thread自带的标志位来进行判定

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (! Thread.currentThread().isInterrupted()) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(3000);

        t.interrupt();
    }

为什么这里抛完异常之后程序会继续执行？我们需要了解interrput所做的事情！
interrput会做两件事：

1. 把线程内部的标志位（boolean）设置成true
2. 如果线程正在sleep，就会触发异常，唤醒sleep

这也充分证实了通知线程终止并不意味着线程马上终止，线程是否会立刻终止取决于内部的代码实现！！！

Thread的常见方法

等待一个线程（join）

作用：每个线程之间的执行顺序是随机（例如上面创建的新线程和主线程main，在不做任何处理的情况下，他们打印的顺序是随机的），等待一个线程控制了线程的执行顺序。

public static void main(String[] args) {
        Thread t = new Thread(()-> {
            for (int i = 0; i < 3; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello main");
    }

这里加入了join方法之后看到打印结果是先执行的t这个线程再执行的main这个主线程（注意调用join方法时需要抛异常，哪个线程里面调用的join，哪个线程就需要进行等待）

获取当前线程引用（Thread.currentThread()）

作用：返回当前线程对象的引用，通常搭配getName()方法使用（因为Thread这个类没有重写toString方法）

休眠当前线程（sleep）

作用：让线程休眠，不参与调度（此时线程将会进入阻塞队列，休眠结束之后，该线程会重新进入就绪队列等待系统调度）

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("hello thread");
        });
        t.start();
        Thread.sleep(1000);
        System.out.println("hello main");
    }

这里的sleep是为了让主线程进行休眠（阻塞等待），让t线程先被操作系统内核调度，从而在一定程度上控制上控制线程之间的调度顺序（后面的wait，notify将会更好的控制多线程的执行顺序）