一、多线程常用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() {
@Override
public void run() {
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",线程执行");
}
}, "t2");
Thread t3 = new Thread(new Runnable() {
@Override
public 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);
}
@Override
public 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;
@Override
public 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();
@Override
public 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();
@Override
public 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();
}
}
