Java之线程详解（三）——多线程常用API、七种状态、优先级、Lock锁
一、多线程常用API
- join() 方法
多线程环境下，如果需要确保某一线程执行完毕后才可继续执行后续的代码，就可以通过使用 join 方法完成这一需求设计。
eg：
public class Thread01 {public static void main(String[] args) {Thread t1 = new Thread(() -> System.out.println(Thread.currentThread().getName()+",线程执行"), "t1");Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {try {t1.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+",线程执行");}}, "t2");Thread t3 = new Thread(new Runnable() {@Overridepublic void run() {try {t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+",线程执行");}}, "t3");t1.start();t2.start();t3.start();}
}
除了无参的 join 方法以外， Thread 类还提供了有参 join 方法，public final synchronized void join(long millis)。
该方法的参数 long millis 代表的是毫秒时间。
方法作用：等待 millis 毫秒终止线程，假如这段时间内该线程还没执行完，也不会再继续等待。
- sleep()方法
sleep()可以让当前正在执行的线程进入休眠（暂时停止执行）指定的毫秒数，即当前线程会从“运行状态”进入到“超时等待状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“超时等待状态”变成“就绪状态”，从而等待cpu的调度执行。
在服务器中，死循环while(true)方法会导致服务器死循环一直运行着，如果没有添加sleep()方法那么下面的代码会直接占用100%的cpu，导致别的应用没有执行权。这种情况叫做CPU空转如果加了sleep()，cpu的占用率会明显减低。
eg：
while(true){try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
}
- yield() 方法
yield()：主动释放cpu执行权。
eg：
public class Thread07 extends Thread{public Thread07(String name){super(name);}@Overridepublic void run() {for (int i=0; i<50; i++){if(i == 30){System.out.println(Thread.currentThread().getName()+",释放cpu执行权");this.yield();//主动释放cpu执行权}System.out.println(Thread.currentThread().getName()+","+i);}}public static void main(String[] args) {new Thread07("t1").start();new Thread07("t2").start();}
}
- 守护线程与用户线程
（1）守护线程：是一种特殊的线程，在后台默默地完成一些系统性的服务，比如垃圾回收线程、JIT 线程都是守护线程。
（2）用户线程：可以理解为是系统的工作线程，它会完成这个程序需要完成的业务操作。如我们使用 Thread 创建的线程在默认情况下都属于用户线程。
通过 Thread.setDaemon(false) 方法可以设置为用户线程；
通过 Thread.setDaemon(true) 方法可以设置为守护线程；
如果不设置线程的属性，那么默认为用户线程，线程属性的设置要在线程启动之前。
守护线程是为用户线程服务的，当一个程序中的所有用户线程都执行完成之后程序就会结束运行，程序结束运行时不会管守护线程是否正在运行。
用户线程是独立存在的，不会因为其他用户线程退出而退出。
用户线程：
当主线程执行完毕后，用户线程还会继续执行。
public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() -> {while (true) {try {Thread.sleep(1000);System.out.println("我是用户线程......");} catch (InterruptedException e) {e.printStackTrace();}}});thread.start();Thread.sleep(3000);System.out.println("主线程执行完毕......");
}
守护线程：
当主线程执行完毕后，用户线程不会继续执行。
public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() -> {while (true) {try {Thread.sleep(1000);System.out.println("我是用户线程......");} catch (InterruptedException e) {e.printStackTrace();}}});// 设置为守护线程thread.setDaemon(true);thread.start();Thread.sleep(3000);System.out.println("主线程执行完毕......");
}
- 如果停止一个线程
（1）可以使用Thread.stop()方法，但不推荐使用此方法，虽然它确实可以停止一个正在运行的线程，但是这个方法是不安全的，而且是被弃用作废的。因为Thread.stop()方法会直接把线程停止，这样就没有给线程足够的时间来处理想要在停止前保存数据的逻辑，任务戛然而止，会导致出现数据完整性等问题。
（2）停止一个线程还可以使用Thread.interrupt()方法，但这个方法不会终止一个正在运行的线程，还需要加入一个判断才可以完成线程的停止。
（3）使用退出标志使线程正常退出。
eg：
Thread.interrupt()方法停止：
public class Thread05 {static class MyThread extends Thread {public void run() {try {while (true) {if (isInterrupted()) {throw new InterruptedException();}}} catch (InterruptedException e) {System.out.println("由于异常退出线程");e.printStackTrace();} finally {System.out.println("线程的finally");}}}public static void main(String[] args) {try {MyThread thread = new MyThread();thread.start();Thread.sleep(2000);thread.interrupt();while(true){ //主线程将一直运行}} catch(Exception e){e.printStackTrace();}}
}
使用退出标志使线程正常退出：
public class Thread06 implements Runnable{private static volatile boolean canceled = false;@Overridepublic void run() {int i = 0;while (!canceled&&i<=1000){i++;try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" "+i+" 线程执行中...");}System.out.println(Thread.currentThread().getName()+" 线程关闭...");}public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new Thread06());thread.start();Thread.sleep(10);canceled = true;}
}
- join()、wait()、sleep()方法之间的区别
Thread.sleep(long)：
sleep(long)是Thread的静态方法；
使当前所在线程进入阻塞；
只是让出CPU，并没有释放锁；
由于睡眠时间结束后不一定立即被CPU调度，因此线程休眠的时间可能大于传入的参数；
如果被终端则抛出InterruptedException。
Object.wait()：
wait()是Ojbect的静态方法；
让出CPU，释放对象锁；
在调用前需要先拥有对象锁，所以一般在synchronized中同步块使用；
使该线程进入该对象的监视器的等待队列；
如果不指定等待时长，需要手动notify/notifyAll唤醒。
join()：
join()是Thread的非静态方法；
join等于synchronized+Object.wait();
线程合并，调用线程会进入阻塞状态，需要等待被调用线程结束后才可以执行；
应用场景：当一个线程必须等待其他线程执行完毕才能继续执行。
二、多线程的七种状态
1、初始（NEW）：刚被创建，还没运行（未执行线程的start()方法）。
2、就绪状态（READY）：线程在可运行线程池中，但未获得CPU执行权，和RUNNING并称运行。
3、运行中状态（RUNNING）：线程执行并获得CPU执行权，和READY并称运行。
4、阻塞（BLOCK）：等待其他线程释放锁的状态。
5、等待（WAITING）：需要其他线程做出一些约定好的动作，或被唤醒（通知或中断）。
6、超时等待（TIME_WAITING）：和等待的不同点在于可以在指定的时间自行醒来。
7、终止（TERMENATED）：线程已经执行完毕。
1、new Thread()，该线程为初始状态；
2、调用start()方法会使得该线程开始执行，进入就绪状态；
3、当CPU调度执行该线程，则该线程进入运行中状态；
4、当run代码执行完毕，则该线程进入终止状态；
5、当在运行状态时，调用yield()方法，则该线程暂停执行并释放CPU执行权，进入就绪状态；
6、当在运行状态时，调用 wait()、join() 等方法，则该线程进入等待状态，并释放CPU执行权，当调用notify()、notifyAll() 等方法，重新进入就绪状态；
7、当在运行状态时，执行时一直没有获取到锁，则该线程进入阻塞状态，获取到锁重新进入就绪状态；
8、当在运行状态时，调用sleep(long)、wait(long)、join(long)等方法，则该线程进入超时等待状态，当调用notify()、notifyAll() 等方法，重新进入就绪状态。
三、多线程的优先级
线程优先级用数字表示，范围从1~10：
Thread.MIN_PRIORITY = 1；
Thread.MAX_PRIORITY = 10；
Thread.NORM_PRIORITY = 5；
默认为5设置优先级：setPriority(int)
获取优先级：getPriority()
public class Thread08 {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {int t1Count = 0;for (; ;) {System.out.println(Thread.currentThread().getName() + "--" + t1Count++);}},"t1");Thread t2 = new Thread(() -> {int t2Count = 0;for (; ;) {System.out.println(Thread.currentThread().getName() + "--" + t2Count++);}},"t2");t1.setPriority(Thread.MAX_PRIORITY);t2.setPriority(Thread.MIN_PRIORITY);t1.start();t2.start();}
}
四、Lock锁
- 常用方法
| 方法 | 描述 |
|---|---|
| void lock() | 获得锁。如果锁不可用，则当前线程将被禁用以进行线程调度，并处于休眠状态，直到获取锁。 |
| void unlock() | 释放锁。 |
| void lockInterruptibly() | 获取锁，如果可用则立即返回。如果锁不可用，那么当前线程将被禁用以进行线程调度，并且处于休眠状态，和lock()方法不同的是在锁的获取中可以中断当前线程。 |
| boolean tryLock() | 只有在调用时才可以获得锁。如果可用，则获取锁，并立即返回值为true；如果锁不可用，则此方法将立即返回值为false 。 |
| boolean tryLock(long time, TimeUnit unit) | 超时获取锁，当前线程在以下三种情况下会返回： 1. 当前线程在超时时间内获得了锁；2.当前线程在超时时间内被中断；3.超时时间结束，返回false |
注意：
如果采用Lock，必须主动去释放锁，在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。
tryLock()方法表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit
unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false，如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
eg：
public class Lock01 implements Runnable{private int count = 100;private final ReentrantLock lock = new ReentrantLock();@Overridepublic void run() {while (true) {try {Thread.sleep(30);lock.lock();//开启锁if (count > 0) {System.out.println(Thread.currentThread().getName() + ",--" + count--);}else{break;}} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();//关闭锁，一般都将unlock写入到finally块中}}}public static void main(String[] args) {Lock01 lock01 = new Lock01();Thread t1 = new Thread(lock01,"a");Thread t2 = new Thread(lock01,"b");t1.start();t2.start();}
}
- Condition接口
Condition接口的常见方法：
| 方法 | 描述 |
|–|–|
| void await() | 相当于Object类的wait方法 |
| boolean await(long time, TimeUnit unit) | 相当于Object类的wait(long timeout)方法 |
| signal() | 相当于Object类的notify方法 |
| signalAll() | 相当于Object类的notifyAll方法 |
eg：
public class Lock01 implements Runnable{private int count = 100;private final ReentrantLock lock = new ReentrantLock();private final Condition condition = lock.newCondition();@Overridepublic void run() {while (true) {try {lock.lock();//开启锁condition.signal();//主动唤醒线程if (count > 0) {System.out.println(Thread.currentThread().getName() + ",--" + count--);condition.await();//主动释放锁 同时当前线程变为阻塞状态}else{break;}} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();//关闭锁，一般都将unlock写入到finally块中}}}public static void main(String[] args) {Lock01 lock01 = new Lock01();Thread t1 = new Thread(lock01,"a");Thread t2 = new Thread(lock01,"b");t1.start();t2.start();}
}