2.2多线程（java学习笔记）线程状态及线程操作的相关方法

一、线程的状态

线程一般具有五种状态，即创建、就绪、运行、阻塞、终止。

它们之间的关系：

二、线程操作相关方法

1.设置和取得线程名称。

如果不设置线程名称，系统会自动分配线程名，一般格式为Thread-Xx

获取当前线程用Thread.currentThread.getName();

线程名称的设置，Thread类中已经建好了各种构造器。

中间带有String的基本都是设置线程名称的，大家可以自行看下。

public class TestThread {
    public static void main(String[] args) {
        TestSleep s = new TestSleep();
        Thread t1 = new Thread(s, "线程t1");
        Thread t2 = new Thread(s, "线程t2");
        Thread t3 = new Thread(s);
        
        t1.start();
        t2.start();
        t3.start();
    }
}

class TestSleep implements Runnable{
    public void run(){
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + " i:" + i );
        }
    }
}

运行结果：
线程t1 i:0
Thread-0 i:0
线程t2 i:0
Thread-0 i:1
线程t1 i:1
Thread-0 i:2
线程t2 i:1
Thread-0 i:3
线程t1 i:2
Thread-0 i:4
线程t2 i:2
线程t1 i:3
线程t1 i:4
线程t2 i:3
线程t2 i:4

2.判断线程是否启动

判断当前线程是否“”活着“”，可能大家对于线程活着这个定义不是很清楚。说明点就是线程启动了，而且也没有死亡就称之为活着。

public class TestThread {
    public static void main(String[] args) {
        TestSleep s = new TestSleep();
        Thread t1 = new Thread(s, "线程t1");
        Thread t2 = new Thread(s, "线程t2");
        System.out.println(t1.isAlive());    //false
        System.out.println(t2.isAlive());    //false
        t1.start();                        
        System.out.println(t1.isAlive());    //ture
        System.out.println(t2.isAlive());    //flase
        t2.start();                        //着这里加个延迟几秒就会发现下面会打印false。
        System.out.println(t1.isAlive());  //这里的状态是不定的，假如指向到这t1和t2没有执行完，那么就是true
        System.out.println(t2.isAlive());  //如果已经执行完毕进入死亡状态，这里就是false
    }
}

class TestSleep implements Runnable{
    public void run(){
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + " i:" + i );
        }
    }
}

false
false
true
false
true
true
线程t1 i:0
线程t1 i:1
线程t1 i:2
线程t1 i:3
线程t1 i:4
线程t2 i:0
线程t2 i:1
线程t2 i:2
线程t2 i:3
线程t2 i:4

当现场处于就绪状态和运行状态都是true，可能又会有疑问那处于堵塞状态了。

我们接下里就测试下处于堵塞状态下isAlive（）；

public class TestThread {
    public static void main(String[] args) {
        TestSleep s = new TestSleep();
        Thread t1 = new Thread(s, "线程t1");
        Thread t2 = new Thread(s, "线程t2");
        System.out.println(t1.isAlive());
        System.out.println(t2.isAlive());
        t1.start();
        System.out.println(t1.isAlive());
        System.out.println(t2.isAlive());
        t2.start();
        System.out.println(t1.isAlive());
        System.out.println(t2.isAlive());
    }
}

class TestSleep implements Runnable{
    synchronized public void run(){
        try {
            this.wait();                          //当前线程等待，即进堵塞状态
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + " i:" + i );
        }
    }
}

运行结果：
false
false
true
false
true
true

可以发现最后两个线程都堵塞了，但最后打印的状态还是true，处于堵塞状态的线程也是存活的。

3.线程的强制加入

public class TestThread {
    public static void main(String[] args) {
        TestSleep s = new TestSleep();
        Thread t1 = new Thread(s, "线程t1");
        t1.start();
        for(int i = 0; i < 10; i++){
            if(i == 5){
                try {
                    t1.join();   //当i为5时，强制加入线程t1
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

class TestSleep implements Runnable{
    synchronized public void run(){
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + " i:" + i );
        }
    }
}

main0
main1
main2
main3
main4
线程t1 i:0
线程t1 i:1
线程t1 i:2
线程t1 i:3
线程t1 i:4
main5
main6
main7
main8
main9

强制加入的线程运行完毕后才会让出资源。

4.线程的休眠

public class TestThread {
    public static void main(String[] args) {
        TestSleep s = new TestSleep();
        Thread t1 = new Thread(s, "线程t1");
        t1.start();
    }
}

class TestSleep implements Runnable{
    synchronized public void run(){
        for(int i = 0; i < 5; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " i:" + i );
        }
    }
}

sleep（填入的数字代表毫秒），上图中填入的是1000代表休眠1s，运行后我们会发现每隔一秒打印一次线程名+ i的值。

5.线程的中断。

可以使用interrupt()方法中断线程的运行。

public class TestThread {
    public static void main(String[] args) {
        TestSleep s = new TestSleep();
        Thread t1 = new Thread(s, "线程t1");
        t1.start();
        t1.interrupt();
    }
}

class TestSleep implements Runnable{
            public void run(){
            System.out.println("开始休眠10s");
            try {
                Thread.sleep(10000);
                System.out.println("完成休眠");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                System.out.println("当前线程被中断，休眠失败");
            }
20             System.out.println("run正常运行结束");
    }
}

如上代码没有被中断应是线程进入run中“开始休眠10s”，10s后会打印出“休眠完成”，"正常运行结束。"

运行我们会发现一运行就出现了“开始休眠10s”，"当前线程被中断，休眠失败"，说明执行t1.interrupt()后t1线程被中断了执行。

运行结果：
开始休眠10s
当前线程被中断，休眠失败

6.线程的礼让

public class TestThread {
    public static void main(String[] args) {
        TestSleep s = new TestSleep();
        Thread t1 = new Thread(s, "线程t1");
        t1.start();
        for(int i = 0; i < 10; i++){
            if(i == 5){
                System.out.println("开始礼让：");
                Thread.currentThread().yield();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

class TestSleep implements Runnable{
    public void run(){
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + " i:" + i );
        }
    }
}

用yield（）可以让当前线程暂停，暂时让其他线程来运行。

是暂时让一会不是一直让，只让一会就不让了，具体调度要看CPU。

运行结果：
main0
main1
main2
main3
main4
开始礼让：
线程t1 i:0
main5
main6
main7
main8
线程t1 i:1
main9
线程t1 i:2
线程t1 i:3
线程t1 i:4