线程的基本使用方法

线程的基本使用方法

---

前言

线程的基本使用方法

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、线程的基本使用方法

1，join方法：
当前线程等待另一个线程执行完才会继续操作（或者说哪个线程执行了join哪个线程就会被挂起）
可以设置等待时间，时间结束后自动恢复到运行状态，但如果另一个线程提前执行完了，则立即恢复为运行状态，不会等待时间结束

public final void join() throws InterruptedException

2，yield方法：
这是一个静态的native方法，让当前运行的线程让出CPU，然后CPU会重新选择线程执行，避免CPU的计算资源长期被一个线程占用。一般用于while死循环时，减少循环的时间，但是仍然有可能该线程再次被CPU选中
yield执行后，相当于线程状态从RUNNING变成“就绪”状态

// 静态 native方法
public static native void yield();

3，sleep方法：
同样是静态的native方法，意思是线程的休眠
需要设置睡眠的毫秒数，相当于从“运行”状态变成“等待”状态，或者说阻塞住了，而且在睡眠期间不会释放锁，其他线程只能等待

	//  可以设置毫秒和纳秒
    public static void sleep(long millis, int nanos)
    throws InterruptedException {
    	// 睡眠数是负数报错
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
		// 纳秒的设置范围校验
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
		// 如果设置的纳秒数大于等于0.5毫秒，则设置为1毫秒
        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
		// 调用native方法
        sleep(millis);
    }
    // 静态的native方法
    
    public static native void sleep(long millis) throws InterruptedException;

4，interrupt方法
设置中断标志位。一般用于线程的打断，结束线程
如果线程是“等待”状态（WAITING， TIMED_WAITING），则抛出InterruptedException异常，可以通过捕捉该异常，判断线程是否需要结束
运行wait，sleep，join或LockSupport的part方法后，会进入等待状态，此时被打断时会抛出InterruptedException异常

// 检查当前线程的标志位，默认false
Thread.currentThread().isInterrupted()

// 当前线程设置标志位
Thread.currentThread().interrupt();
// 再次检查，输出true
System.out.println(Thread.currentThread().isInterrupted());

// 调用Thread内部的interrupted方法，会自己复位。打印true
System.out.println(Thread.interrupted());
// 打印false
System.out.println(Thread.interrupted());

二、结束线程的方式

1.stop

已废弃

2.volatile方式结束

代码如下（示例）：

public class volatileTest {

    // 保证可见性，每次读到的都是最后一次修改后的
    // 并且防止指令重排
    private static volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (flag) {
                // ...
            }
            System.out.println("break");
        });

        thread.start();

        // 保证子线程一定会启动起来
        Thread.sleep(100);

        // 停止子线程
        flag = false;
    }
}

其实volatile被解析后，会插入内存屏障来防止指令重排。其本身就是一个轻量级的锁，但相对于锁，volatile的优势在于性能上，所以牺牲掉了原子性

3.interrupt

1，调用 interrupt方法，如果当前状态不是等待状态，可以通过检测中断标志位的方式判断是否break
2，线程在等待状态，设置中断标志位后，通过捕捉InterruptedException方法，可以自行结束线程
（第二种用的会多一些，但是对BLOCKED阻塞状态不生效）

---