Java之线程详解（三）——多线程常用API、七种状态、优先级、Lock锁_多线程下接口调用接口状态描述

一、多线程常用API

1. 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

除了无参的 join 方法以外， Thread 类还提供了有参 join 方法，public final synchronized void join(long millis)。
该方法的参数 long millis 代表的是毫秒时间。
方法作用：等待 millis 毫秒终止线程，假如这段时间内该线程还没执行完，也不会再继续等待。

2. sleep()方法

sleep()可以让当前正在执行的线程进入休眠（暂时停止执行）指定的毫秒数，即当前线程会从“运行状态”进入到“超时等待状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“超时等待状态”变成“就绪状态”，从而等待cpu的调度执行。

在服务器中，死循环while(true)方法会导致服务器死循环一直运行着，如果没有添加sleep()方法那么下面的代码会直接占用100%的cpu，导致别的应用没有执行权。这种情况叫做CPU空转如果加了sleep()，cpu的占用率会明显减低。

eg：

while(true){
 try {
       Thread.sleep(20);
      } catch (InterruptedException e) {
       e.printStackTrace();
   }
}
1
2
3
4
5
6
7

3. 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4. 守护线程与用户线程

（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("主线程执行完毕......");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

守护线程：
当主线程执行完毕后，用户线程不会继续执行。

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5. 如果停止一个线程

（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();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

使用退出标志使线程正常退出：

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

6. 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

四、Lock锁

1. 常用方法

注意：

如果采用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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2. 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33