Java之线程详解（三）——多线程常用API、七种状态、优先级、Lock锁

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量901 收藏 2
点赞数 1
分类专栏： Java多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36216193/article/details/128139538
版权

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

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

  1. 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. 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. 守护线程与用户线程

（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. 如果停止一个线程

（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;
    }
}
  1. 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锁

  1. 常用方法
方法描述
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();
    }
}
  1. 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
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多线程——线程的几种状态 (Java API版)
gxx_csdn的博客
01-31 1429
以前学习操作系统这门课程的时候，对线程状态的学习是比较粗略的，仅限于表面的了解，在后续学习和使用的过程中， 我发现自己之前的认知与Java api中定义的线程状态是有出入的，在使用过程中也会有很多误解， 所以按照java.lang.Thread.State中的详细定义和说明，进行了如下整理，作为自我总结和学习。 根据Java api，Java中线程一共有如下6种状态，即NEW、RUNNABL
Java常用API（十）——多线程基础
../
01-22 347
多线程：允许"同时"执行多段代码。实际上多线程是并发运行的，每段代码都是走走停停的。CPU会在这些线程间快速切换，保证每段代码都有进度。从而感官上是同时运行。 线程的创建： 第一种创建方式：定义一个线程类并继承线程Thread，然后重写run方法。run方法定义线程执行的任务代码。 package thread; public class ThreadDemo { public static...
详解Java的线程的优先级以及死锁
09-03
主要介绍了详解Java的线程的优先级以及死锁,线程是Java编程学习中的重要知识,需要的朋友可以参考下
JUC-优先级锁
互联网知识分享
04-12 186
假如一个线程1刚刚成功获得一个锁，当它把锁释放了之后，线程2获得该锁，并且线程2在运行的过程中，此时线程1又想来获得该锁了，但线程2还没有释放该锁，所以线程1只能自旋等待，但是虚拟机认为，由于线程1刚刚获得过该锁，那么虚拟机觉得线程1这次自旋也是很有可能能够再次成功获得该锁的，所以会自动延长线程1自旋的次数。在Jdk1.6中，偏向锁的开关是默认开启的。1）所谓自旋，就是指当有另外一个线程来竞争锁时，这个线程会在原地循环等待，而不是把该线程给阻塞，直到那个获得锁的线程释放锁之后，这个线程就可以马上获得锁的。
Java并发编程之线程状态转换
qq_42964601的博客
01-31 185
线程状态转换（从Java角度解释） 假设有线程 Thread t 情况 1 NEW --> RUNNABLE 当调用 t.start() 方法时，由 NEW --> RUNNABLE 情况 2 RUNNABLE <–> WAITING t 线程用 synchronized(obj) 获取了对象锁后 调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING 调用 obj.notify() ， obj.notifyAll() ， t.inte
java之多线程(一)——线程的创建以及常用API
weixin_42902126的博客
07-06 505
概念 什么是程序？ 程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 什么是进程？ 进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在、消亡的过程。——生命周期 1、进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。 2、程序时静态的，进程时动态的。 什么是线程？ 进程可进一步细化为线程，是一个程...
【Java学习笔记】API：线程
wxf1337564298的博客
04-02 391
线程API 获取线程相关信息的方法 package thread; /** * 获取线程相关信息的一组方法 */ public class ThreadInfoDemo { public static void main(String[] args) { Thread main = Thread.currentThread();//获取主线程 String name = main.getName();//获取线程的名字 System.o
基于java 线程的几种状态(详解)
08-29
基于Java线程的几种状态详解 Java线程的状态是一个复杂的概念，它们之间的转换关系也非常重要。下面我们将详细解释Java线程的六种状态：New、Runnable、Blocked、Waiting、Timed waiting和Terminated。 1. 新创建...
java线程优先级原理详解
08-25
Java线程优先级是Java多线程编程中的一个重要概念，它涉及到如何更公平或高效地分配CPU资源。在Java中，线程的优先级被用来影响线程调度，但并不保证绝对的执行顺序，而是增加了高优先级线程被调度的概率。 Java...
java 基础教程之多线程详解及简单实例
08-31
在本文中，我们将深入探讨Java多线程的基础知识，包括线程的创建、状态转换以及线程间通信。 首先，了解线程的基本属性至关重要。线程拥有自己的名称、优先级和所属的线程组。线程组是一个容器，可以包含多个线程，...
Java多线程编程深入详解.docx
10-24
Java的多线程模型基于线程优先级、线程同步和线程通信等机制。 第一个多线程程序 创建一个简单的多线程程序，继承Thread类， 覆写run方法，使用start方法启动线程。需要注意的是，线程的执行顺序是不可预测的，...
JAVA高质量并发详解,多线程并发深入讲解
04-24
### JAVA高质量并发详解知识点概述 #### 一、Java并发编程基础 - **基础知识：** - **线程基本概念：** Java线程是程序执行流的最小单元，一个线程包含一个程序计数器(PC)、虚拟机栈、本地方法栈、线程私有的工作...
Java中Lock锁详解
mercedes_benz
07-08 7106
在Java中，Lock是一个接口，它提供了比关键字更高级的线程同步机制。使用Lock接口可以创建更复杂和灵活的同步结构。Lock接口的常用实现类有ReentrantLock和ReentrantReadWriteLock，它们提供了可重入的互斥锁和读写锁。使用Lock锁的一般步骤如下：1. 创建一个`Lock`对象实例。2. 在需要进行同步的代码块中，通过调用`lock()`方法来获取锁。3. 在同步的代码块执行完之后，通过调用`unlock()`方法释放锁。
Java多线程基本概念和常用API（面试高频）
hongs468的博客
08-17 611
这篇文章主要介绍了Java多线程面试题(面试官常问),本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
多线程--03--线程常用API
na_tion的专栏
04-24 693
一、常用API 方法名 功能说明 注意 start() 启动一个新线程，在新的线程运行 run 方法中的代码 start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的start方法只能调用一次，如果调用了多次，会出现IllegalThreadStateException run() 新线程启动后会调用的方法 　 yield() 提示线程调度器让出当前线程对CPU的使用，让出后可能该线程又继续被调...
Java线程基础知识（创建与常见的方法）
weixin_42383680的博客
10-02 190
Java线程基础知识 创建和运行线程 查看线程 线程 API 线程状态 常见的方法 1 创建和运行线程 方法一，直接使用 Thread // 创建线程对象 Thread t = new Thread() { public void run() { // 要执行的任务 } }; // 启动线程 t.start(); 例...
多线程调用第三方API接口
艺艺小同学的博客
12-03 5901
public void ThreadDemo() { //集合 相当于请求内容 List<String> list = new ArrayList<String>(); list.add("110101198001119833"); list.add("110101198001119876"); list.add("110101198001119892"); ...
java线程锁的等级_详解Java的线程的优先级以及死锁
weixin_28998775的博客
02-17 121
Java线程优先级需要避免的与多任务处理有关的特殊错误类型是死锁(deadlock)。死锁发生在当两个线程对一对同步对象有循环依赖关系时。例如，假定一个线程进入了对象X的管程而另一个线程进入了对象Y的管程。如果X的线程试图调用Y的同步方法，它将像预料的一样被锁定。而Y的线程同样希望调用X的一些同步方法，线程永远等待，因为为到达X，必须释放自己的Y的锁定以使第一个线程可以完成。死锁是很难调试的错误，...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 534
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吟诗作对歌一曲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值