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