Thread的基本方法初解

首先实现一个线程类

public class CountOperate extends Thread
{
    public CountOperate(){
        System.out.println("CountOperate开始初始化");
        System.out.println("该线程对象在Thread.currentThread().getName()="+Thread.currentThread().getName()+"线程中创建");
        System.out.println("this.getName()="+this.getName());
        System.out.println("CountOperate初始化完成");
    }

    @Override
    public void run() {
        System.out.println("线程开始跑起来了\r\nThread.currentThread().getName()="+Thread.currentThread().getName()
        +"\r\nthis.getName()="+this.getName()+"\r\n线程执行结束了");
    }

    public static void main(String[] args) {
        Thread t=new CountOperate();
        t.setName("线程1");
        t.start();
        System.out.println("------------------分割线");
        Thread t2=new CountOperate();
        t2.start();
    }
}

运行结果：

CountOperate开始初始化
该线程对象在Thread.currentThread().getName()=main线程中创建
this.getName()=Thread-0
CountOperate初始化完成
------------------分割线
CountOperate开始初始化
该线程对象在Thread.currentThread().getName()=main线程中创建
this.getName()=Thread-1
CountOperate初始化完成
线程开始跑起来了
Thread.currentThread().getName()=线程1
this.getName()=线程1
线程执行结束了
线程开始跑起来了
Thread.currentThread().getName()=Thread-1
this.getName()=Thread-1
线程执行结束了

每个线程对象在被初始化时，会有一个默认的name，Thread-1，Thread-0等等，所以在构造方法中的getName就是Thread-1这种，而使用了setName方法之后，就变成了设置的名字，在run方法中就有体现。

对于currentThread().getName方法，获取的是当前代码段的执行线程，这里构造方法是在main线程中调用的，所以构造方法中获取的Thread.currentThread().getName()是main。而run方法是被新创建的线程调用的，所以Thread.currentThread().getName()获取的是新线程的名字。

线程中断：
interrupt不会中断运行中的线程可以中断睡眠中的线程。

线程中断最优方式：

@Override
    public void run() {
                try {
                    for (int i=1;i<=5000;i++) {
                        if (this.isInterrupted()) {
                            throw new InterruptedException();
                        }
                        System.out.println("i=" + i);
                    }
                } catch (InterruptedException e) {
                    System.out.println("成功中断");
                    e.printStackTrace();
                }

    }

t.suspend()会暂停线程，运行中的线程。
t.resume()会恢复暂停的线程。
这2个方法已经过时，可能导致死锁。

 public static void main(String[] args) {
        Thread t=new InterruptThread();
//        Thread.currentThread().stop();
        t.start();
        try {
            Thread.sleep(2000);
            t.suspend();
            System.out.println("线程t  1："+Thread.interrupted());
            System.out.println("线程t  2："+t.isInterrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

执行结果：

i=1
i=2

System.out.println(“线程t 1：”+Thread.interrupted());没有得到执行，
因为，system.out.println()中有获取锁，但是锁被t持有了，所以死锁。

设置线程优先级setPriority(); 1-10
线程优先级具有继承性，继承父线程的优先级（这里指创建改线程的线程）

优先级高的线程，理论上会先执行完，但是，这不是一定的。具有不确定性

 @Override
    public void run() {
        long s1= System.currentTimeMillis();
                try {
                    for (int i=1;i<=50000000;i++) {
//                                            Thread.yield();
                        if (this.isInterrupted()) {
                            throw new InterruptedException();
                        }
//                        System.out.println("i=" + i);
//                        Thread.sleep(1000);
                    }

                } catch (InterruptedException e) {
                    System.out.println("成功中断");
                    e.printStackTrace();
                }
        System.out.println(this.getName()+"用时:"+(System.currentTimeMillis()-s1));
    }

 Thread t=new InterruptThread();
//        Thread.currentThread().stop();
        t.setPriority(6);
        t.setName("6的线程");
        t.start();
        Thread t2=new InterruptThread();
//        Thread.currentThread().stop();
        t2.setPriority(9);
        t2.setName("9的线程");
        t2.start();

运行结果：

9的线程用时:53
6的线程用时:62