Java中线程的常用方法

1.start方法

start方法是我们开启一个新的线程的方法，但是并不是直接开启，而是告诉CPU我已经准备好了，快点运行我，这是启动一个线程的唯一入口

void    start()
// 导致此线程开始执行; Java虚拟机调用此线程的run方法。

2.run方法

线程的线程体，当一个线程开始运行后，执行的就是run方法里面的代码，我们不能直接通过线程对象来调用run方法，因为这并没有产生一个新的线程，仅仅只是一个普通对象的方法调用

void    run()
// 如果这个线程使用单独的Runnable运行对象构造，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。

3.getName方法

获取线程名称的方法

String  getName()
//返回此线程的名称

4.优先级

我们创建的多个线程的执行顺序是由CPU决定的。Java中提供了一个线程调度器来监控程序中启动后进入就绪状态的所有的线程，优先级高的线程会获取到比较多

运行机会

 /**
     * 最小的优先级是 1
     */
    public final static int MIN_PRIORITY = 1;
​
   /**
     * 默认的优先级都是5
     */
    public final static int NORM_PRIORITY = 5;
​
    /**
     * 最大的优先级是10
     */
    public final static int MAX_PRIORITY = 10;

大家会发现，设置了优先级后输出的结果和我们预期的并不一样，这是为什么呢？优先级在CPU调动线程执行的时候会是一个参考因数，但不是决定因数

5.sleep方法

将当前线程暂定指定的时间

static void	sleep(long millis)
// 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。

6.isAlive

获取线程的状态

public class IsAliveDemo {

    /**
     * isAlive方法
     * @param args
     */
    public static void main(String[] args) {

        System.out.println("main  start ...");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " .... ");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println("线程的状态："+t1.isAlive());
        t1.start();
        System.out.println("线程的状态："+t1.isAlive());
        System.out.println("main  end ...");
    }
}

输出结果

main  start ...
线程的状态：false
线程的状态：true
main  end ...
Thread-0 .... 

7.join

调用某线程的该方法，将当前线程和该线程合并，即等待该线程结束，在恢复当前线程的运行

public class JoinDemo {

    /**
     * 线程的合并
     *     join方法
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("main  start ...");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0 ; i < 10; i++){
                    System.out.println(Thread.currentThread().getName() + " 子线程执行了...");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        });
        t1.start();
        System.out.println(t1.isAlive());
        try {
            t1.join(); // 线程的合并，和主线程合并  相当于我们直接调用了run方法
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t1.isAlive());
        System.out.println("main end ...");
    }
}

输出结果

main  start ...
true
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
false
main end ...

8.yield

让出CPU，当前线程进入就绪状态

public class YieldDemo extends Thread{

    public YieldDemo(String threadName){
        super(threadName);
    }

    /**
     * yield方法  礼让
     *
     * @param args
     */
    public static void main(String[] args) {
        YieldDemo f1 = new YieldDemo("A1");
        YieldDemo f2 = new YieldDemo("A2");
        YieldDemo f3 = new YieldDemo("A3");

        f1.start();
        f2.start();
        f3.start();
    }

    @Override
    public void run() {
        for(int i = 0 ; i < 100; i ++){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if(i%10 == 0 && i != 0){
                System.out.println(Thread.currentThread().getName()+" 礼让：" + i);
                Thread.currentThread().yield(); // 让出CPU
            }else{
                System.out.println(this.getName() + ":" + i);
            }
        }
    }
}