java多线程（2）Thread的实例方法

摘要：之前有简单介绍过多线程的使用，已经类和类，为了更好地理解多线程，本文就进行详细的分析。方法是强制停止线程的执行，是非安全的，不要使用此方法。比较简单，获取线程的名称。和方法的作用是等待线程执行完成，可以设置最长等待时间。

之前有简单介绍过java多线程的使用，已经Thread类和Runnable类，为了更好地理解多线程，本文就Thread进行详细的分析。

start方法是开启线程的方法，使用后java会创建一个新的线程执行run里的方法。这是一个小demo：

        for(int i=0;i<3;i++){
            Thread t= new Thread(new Runnable() {
                @Override
                public void run() {
            System.out.println(Thread.currentThread().getName()+" start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            System.out.println(Thread.currentThread().getName()+" end");
                }
            });
            t.start();
        }
        System.out.println("it is over");

执行结果：
it is over
Thread-1 start
Thread-0 start
Thread-2 start
Thread-0 end
Thread-1 end
Thread-2 end

由于多线程是有随机性的，所以每次的结果可能都不一样，这一点也是我们需要注意的，线程的执行顺序和调用顺序并不一致。

run方法就是调用Thread设置的Runnable的run方法，将上面的demo进行修改：

        for(int i=0;i<3;i++){
            Thread t= new Thread(new Runnable() {
                
                @Override
                public void run() {
            System.out.println(Thread.currentThread().getName()+" start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            System.out.println(Thread.currentThread().getName()+" end");
                }
            });
            t.run();
        }
        System.out.println("it is over");

执行结果：
main start
main end
main start
main end
main start
main end
it is over
run方法的直接结果和start有很大的差别，完全是按顺序执行，并没有开启新线程。

stop方法是强制停止线程的执行，是非安全的，不要使用此方法。在调用stop时， 会对锁定的资源进行释放，但这种释放是非一致的,容易引起程序问题。如果想要控制线程的停止，可以使用自定义变量来判断或者isInterrupted()方法:

class Thread1 extends Thread {
    @Override
    public void run() {
        //判断线程体是否运行
        while (!isInterrupted()) {
            // Do Something
        }
    }    
}

interrupt的作用是通知线程，你已经被中断的，但具体的中断执行需要在线程自定义处理，甚至你可以不理会继续执行。具体的中孤单是会线程执行join、wait、sleep方法时，抛出InterruptedException。

Thread t1 = new Thread(new Runnable() {
                @Override
                public  void  run() {
                        System.out.println(Thread.currentThread().getName()+" start");
                        try {
                            for(int i=0;i<100000;i++){
                                System.out.println(i+"");
                                Thread.sleep(1);
                            }
                        } catch (InterruptedException e) {
                            System.out.println("the thread is interrupted");//可以在这里做资源释放，日志记录等
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+" end");
                    }
            });
            t1.start();
            Thread.sleep(100);
            t1.interrupt();

执行结果：

65
66
67
68
the thread is interrupted
java.lang.InterruptedException: sleep interrupted
Thread-0 end
    at java.lang.Thread.sleep(Native Method)
    at com.wk.aqi.act.Test$1.run(Test.java:23)
    at java.lang.Thread.run(Thread.java:745)

判断线程是否中断，在执行上面的interrupt方法后，会return true。

设置线程的优先级和获取线程的优先级，cpu分配的资源给侧重给priority高的线程。

Thread t1 = new Thread(new Runnable() {
                @Override
                public  void  run() {
                        long t = System.currentTimeMillis();
                        System.out.println(Thread.currentThread().getName()+" start");
                        for(int i=0;i<1000;i++){
                            try {
                                Thread.sleep(1);
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                        System.out.println(Thread.currentThread().getName()+" t1 end "+(System.currentTimeMillis()-t));
                    }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public  void  run() {
                    long t = System.currentTimeMillis();
                    System.out.println(Thread.currentThread().getName()+" start");
                    for(int i=0;i<1000;i++){
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName()+" t2 end "+(System.currentTimeMillis()-t));
                }
            });
            t1.setPriority(10);
            t2.setPriority(1);
            t2.start();
            t1.start();

执行结果：

Thread-0 start
Thread-1 start
Thread-0 t1 end 1357
Thread-1 t2 end 1371

在优先级一样的情况下，t1和t2是几乎同时完成的，在优先级不一样的情况，有明显的差别。

比较简单，获取线程的名称。

jion方法的作用是等待线程执行完成，join(long millis)可以设置最长等待时间。比如主线程需要等待子线程完成，获取子线程的结果后才能继续往下执行，这时候就可以使用join方法

Thread t1 = new Thread(new Runnable() {
            @Override
            public  void  run() {
                    long t = System.currentTimeMillis();
                    System.out.println(Thread.currentThread().getName()+" start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" t1 end "+(System.currentTimeMillis()-t));
                }
        });
        t1.start();
        t1.join();
        System.out.println("等待t1执行完，再执行");

执行结果：

Thread-0 start
Thread-0 t1 end 1001
等待t1执行完，再执行