线程的状态以及相关的操作方法

线程的状态：创建线程Thread name =  new Thread（）　　就绪状态　　运行状态　　堵塞状态　　死亡状态

线程的操作：1。在Thread类中可以通过getName（）和setName（）方法设置线程的名称，尽量避免名称的重复出现。要是在线程的操作过程中没有给线程一个名称，则在系统使用时会为线程分配一个名称，Thread-XX。并在其中Thread类中存在一个static属性。

 1 package Rubbableclass;
 2 class MyThread implements Runnable{
 3
 4     @Override
 5     public void run() {
 6         // TODO 自动生成的方法存根
 7         for(int i = 0;i<3;i++){
 8             System.out.println(Thread.currentThread().getName()+"运行，i = "+i);
 9             //public static Thread currentThread()返回对当前正在执行的线程对象的引用。
10             //    返回：当前执行的线程。
11
12         }
13
14     }
15
16 }
17 public class getNameThread {
18     public static void main(String[] args) {
19         // TODO 自动生成的方法存根
20         MyThread my = new MyThread();
21         new Thread(my).start();
22         new Thread(my, "线程-A").start();
23         new Thread(my, "线程-B").start();
24         new Thread(my).start();
25         new Thread(my).start();
26     }
27
28 }

Thread-0运行，i = 0
Thread-2运行，i = 0
Thread-1运行，i = 0
线程-A运行，i = 0
线程-B运行，i = 0
线程-A运行，i = 1
Thread-1运行，i = 1
Thread-2运行，i = 1
Thread-0运行，i = 1
Thread-0运行，i = 2
Thread-2运行，i = 2
Thread-1运行，i = 2
线程-A运行，i = 2
线程-B运行，i = 1
线程-B运行，i = 2

Java至少会启动两个线程。

判断线程是否启动：

package Rubbableclass;
/*判断线程是否启动*/
class MyThread_four implements Runnable{

    @Override
    public void run() {
        // TODO 自动生成的方法存根
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName()+"运行-->"+i);

        }

    }

}
public class four {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        MyThread_four my = new MyThread_four();
        Thread t = new Thread(my, "one");
        System.out.println("线程执行前-->"+t.isAlive());
        t.start();
        System.out.println("线程执行后-->"+t.isAlive());
    }

}

线程执行前-->false
线程执行后-->true
one运行-->0
one运行-->1
one运行-->2

主线程会比其他线程的优先级高

 1 package Rubbableclass;
 2 /*线程的强制运行*/
 3 class MyThread_five implements Runnable{
 4
 5     @Override
 6     public void run() {
 7         // TODO 自动生成的方法存根
 8         for(int i = 0;i<50;i++){
 9             System.out.println(Thread.currentThread().getName()+"运行，i = "+i);
10             //public static Thread currentThread()返回对当前正在执行的线程对象的引用。
11             //    返回：当前执行的线程。
12
13         }
14
15     }
16
17 }
18 public class five {
19
20     public static void main(String[] args) {
21         // TODO 自动生成的方法存根
22         MyThread_five my = new MyThread_five();
23         Thread t = new Thread(my);
24         t.start();
25         for(int i = 0;i<50;i++){
26             if(i>10){
27                 try {
28                     t.join();
29                 } catch (Exception e) {
30                     // TODO: handle exception
31                 }
32             }
33             System.out.println("Main 线程运行-->"+i);
34         }
35     }
36
37 }

 1 package Rubbableclass;
 2
 3 public class six {
 4     class MyThread implements Runnable{
 5
 6         @Override
 7         public void run() {
 8             // TODO 自动生成的方法存根
 9             for(int i = 5;i>0;i--){
10                 try {
11                     Thread.sleep(500);
12                     throw new Exception();
13                 } catch (Exception e) {
14                     // TODO: handle exception
15                     System.out.println(Thread.currentThread().isAlive());
16                 }finally{
17                     System.out.println(Thread.currentThread().getName()+"运行，"+i);
18                 }
19             }
20
21         }
22
23     }
24     public static void main(String[] args) {
25         // TODO 自动生成的方法存根
26         MyThread my = new six().new MyThread();
27         Thread t = new Thread(my, "线程A-");
28         t.start();
29     }
30
31 }

true
线程A-运行，5
true
线程A-运行，4
true
线程A-运行，3
true
线程A-运行，2
true
线程A-运行，1

在Java中，只要前台有一个线程在运行，则整个Java进程都不会消失，所以此时可以设置一个后台线程，这样即使Java进程结束了，此后台线程依然会继续执行。要想实现这样的操作，直接使用SetDaemom（）