java线程的方法

本文将讲述关于java线程的以下方法：

1.取得线程的名称：Thread.currentThread().getName()

2.判断线程是否启动：isAlive()

3.线程的强制执行：join()

4.线程的休眠：Thread.sleep(2000)

5.线程的中端：interrupt()

6.后台线程：setDaemon(true)

7.线程的优先级：setPriority(8)

8.线程的礼让：yield()

一、取得线程的名称

/**
 * 取得线程的名称
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        hello he = new hello();
        new Thread(he, "A").start();
        new Thread(he, "B").start();
        new Thread(he).start();
    }
}

结果可能如下：

A
Thread-0
B
Thread-0
A
Thread-0
B
A
B

说明：如果我们没有指定名字的话，系统自动提供名字。

二、判断线程是否启动

提醒一下大家：main方法其实也是一个线程。在java中所有的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际就是在操作系统中启动了一个进程。

/**
 * 判断线程是否启动
 */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
 
    public static void main(String[] args) {
        hello he = new hello();
        Thread t = new Thread(he);
        System.out.println("线程启动之前---" + t.isAlive());
        t.start();
        System.out.println("线程启动之后---" + t.isAlive());
    }
}

运行结果：

线程启动之前---false
线程启动之后---true
Thread-0
Thread-0
Thread-0

主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。

三、线程的强制执行

/**
 * 线程的强制执行
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        hello he = new hello();
        Thread t = new Thread(he, "A");
        t.start();
        for (int i = 0; i < 50; ++i) {
            if (i > 10) {
                try {
                    t.join(); // 强制执行t
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main 线程执行--" + i);
        }
    }
}

结果：

main 线程执行--0
A
main 线程执行--1
A
main 线程执行--2
A
main 线程执行--3
main 线程执行--4
main 线程执行--5
main 线程执行--6
main 线程执行--7

.......

四、线程的休眠

/**
 * 线程的休眠
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
 
    public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.start();
    }
}

【运行结果】：（结果每隔2s输出一个）

线程0

线程1

线程2

五、线程的中端

/**
 * 线程的中断
 * */
class hello implements Runnable {
    public void run() {
        System.out.println("执行run方法");
        try {
            Thread.sleep(10000);
            System.out.println("线程完成休眠");
        } catch (Exception e) {
            System.out.println("休眠被打断");
            return;  //返回到程序的调用处
        }
        System.out.println("线程正常终止");
    }
 
    public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.start();
        try{
            Thread.sleep(2000);
        }catch (Exception e) {
            e.printStackTrace();
        }
        demo.interrupt(); //2s后中断线程
    }
}

【运行结果】：

执行run方法

休眠被打断

六、后台线程

/**
 * 后台线程
 * */
class hello implements Runnable {
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "在运行");
        }
    }
 
    public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.setDaemon(true);
        demo.start();
    }
}

虽然有一个死循环，但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。

七、线程的优先级

/**
 * 线程的优先级
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<3;++i){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
        }
    }
 
    public static void main(String[] args) {
        Thread h1=new Thread(new hello(),"A");
        Thread h2=new Thread(new hello(),"B");
        Thread h3=new Thread(new hello(),"C");
        h1.setPriority(8);
        h2.setPriority(2);
        h3.setPriority(6);
        h1.start();
        h2.start();
        h3.start();
         
    }
}

【运行结果】

A运行0
A运行1
C运行0
B运行0
B运行1
B运行2
C运行1
A运行2
C运行2

但是请读者不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源

另外，主线程的优先级是5.

八、线程的礼让

在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行。

/**
 * 线程的优先级
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
            if(i==3){
                System.out.println("线程的礼让");
                Thread.currentThread().yield();
            }
        }
    }
 
    public static void main(String[] args) {
        Thread h1=new Thread(new hello(),"A");
        Thread h2=new Thread(new hello(),"B");
        h1.start();
        h2.start();
         
    }
}

【运行结果】可能是

A运行0
B运行0
A运行1
B运行1
A运行2
B运行2
A运行3
B运行3
线程的礼让
B运行4
线程的礼让
A运行4