一、多线程常用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();
}
}