多线程(进阶三:JUC)

这篇具有很好参考价值的文章主要介绍了多线程(进阶三:JUC)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、Callable接口

1、创建线程的操作

2、编写多线程代码

(1)实现Runnable接口(使用匿名内部类)

(2)实现Callable接口(使用匿名内部类)

二、ReentrantLock

1、ReentrantLock和synchronized的区别

2、如何选择使用哪个锁?

三、原子类

四、线程池

五、信号量 Semaphore

代码示例

六、CountDownLatch

代码示例

七、相关面试题

1、线程同步的方式有哪些?

2、为什么有了synchronized还需要juc下的lock?

3、AtomicInteger的实现原理是什么?

4、信号量听说过么?之前都用在过哪些场景下?

5、解释⼀下ThreadPoolExecutor构造方法的参数的含义


JUC即java.utill.concurrent,里面放了一些多线程编程时有用的类,下面是里面的一些类。

一、Callable接口

1、创建线程的操作

        多线程编程时,创建线程有以下五种操作:

1、继承Thread类(包含了匿名内部类的方式)

2、实现Runnable接口(包含了匿名内部类的方式)

3、基于lambda表达式

4、基于Callable接口

5、基于线程池

        为什么有那么多方式可以创建线程,前面三个创建线程很方便,也经常用,为啥还要学Callable接口创建线程的方式呢?答案是因为有它独特的优势和特性。

以下是Callable和Runnable的区别:

                Runnable关注的是这个的过程,也就是重新run方法里面的内容,它的返回值是void。

                Callable即关注过程,也关注结果,Callable提供call方法,返回值就是执行任务得到的结果。

2、编写多线程代码

创建一个线程,这个线程完成1+2+3+...+1000的任务,并打印出结果。

(1)实现Runnable接口(使用匿名内部类)

代码如下:

public class ThreadDemo1 {
    private static int sum = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            int result = 0;
            @Override
            public void run() {
                for (int i = 1; i <= 1000; i++) {
                    result += i;
                }
                sum = result;
            }
        });
        t.start();
        t.join();
        System.out.println("sum = " + sum);
    }
}

执行结果:

多线程(进阶三:JUC),java,开发语言,java-ee

可以看到,用实现Runnable接口的代码可以完成任务,但并不优雅,因为要创建一个全局的静态变量,如果其他场景下使用Runnable接口,需要创建很多这样的变量,就容易混淆、记错这些变量的代指。

(2)实现Callable接口(使用匿名内部类)

代码如下:

public class ThreadDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        int result = futureTask.get();
        System.out.println("result = " + result);
    }
}

执行结果如下:

多线程(进阶三:JUC),java,开发语言,java-ee

和预期值一样。

实现Callable接口,没有创建变量也可以完成任务,通过call方法的返回值,输出我们想要的值。

注意:

1、这里的FutureTask,因为Thread里面的构造方法的参数没有Callable接口,但有FutureTask类,所以成为了Thread和Callable的粘合剂

2、FutureTask直接翻译的意思是:未来的任务那么未来的任务肯定没有执行完,最终取结果的时候就需要一个凭据,而futureTask就是凭据;就像我们吃麻辣烫的时候,付完款拿到的小牌子,当前工作人员没做完麻辣烫,需要做完后叫到我们的号才能取餐。

3、FutureTask的get方法有阻塞功能,如果线程没有执行完,get就会阻塞,等线程执行完了,return了结果,才会执行get方法返回值。

Callable是一个“锦上添花”的东西,Callable能干的事,Runnable也能干,但对于这种带返回值的任务,使用Callable会更好,代码更直观、简单,但需要理解这里FutureTask起到的作用。


二、ReentrantLock

        ReentrantLock是可重入互斥锁,跟synchronized定位类似,都是实现互斥的效果,保证线程安全。在java的远古时期,sychronized锁的功能没有那么强大,没有各种优化,ReentrantLock就是可以用来使用可重入锁的(历史遗留)。

        传统的锁的风格,锁对象提供两个方法:lock和unlock,这个写法就容易忘记解锁unlock,或者在unlock之前,提前return了,可能引起unlock没执行到,所以正确使用ReentrantLock锁,unlock操作要放进finally。

1、ReentrantLock和synchronized的区别

        那么有了synchronized,为啥还要有ReentrantLock呢?有以下三点(也是synchronized与ReentrantLock的区别):

        1、ReentrantLock提供了tryLock操作。synchronized锁直接进行加锁,加锁不成功就会阻塞;ReentrantLock锁进行加锁时,进行加锁时,如果加锁不成功,不会阻塞,直接返回false,这里的tryLock的操作空间更大。

        2、ReentrantLock锁是公平锁。synchronized锁是非公平锁。

        3,、ReentrantLock和synchronized搭配的等待机制不同。synchronized锁搭配的是wait、notify,而ReentrantLock锁搭配的是Condition类,功能比wait、notify略强一点。

2、如何选择使用哪个锁?

        (1)当锁竞争不激烈时,使用synchronized锁,效率更高,自动释放更方便。

        (2)锁竞争激烈时,使用ReentrantLock,搭配tryLock更加灵活控制加锁行为,而不是死等

        (3)如果要使用公平锁,就使用ReentrantLock。


三、原子类

原⼦类内部⽤的是CAS实现,所以性能要比加锁实现i++高很多。原⼦类有以下几个
• AtomicBoolean
• AtomicInteger
• AtomicIntegerArray
• AtomicLong
• AtomicReference
• AtomicStampedReference

以AtomicInteger举例,常见方法有
addAndGet(int delta);        i += delta
decrementAndGet();          --i
getAndDecrement();          i--
incrementAndGet();          ++i
getAndIncrement();           i++

CAS的详细介绍地址:多线程(进阶二:CAS)-CSDN博客


四、线程池

详细介绍地址:多线程(初阶九:线程池)-CSDN博客


五、信号量 Semaphore

        信号量,用来表示“可用资源的个数”,本质还是一个计数器。而信号量可以理解成停车场的展示牌:当前有100个停车位,相当于有100个可用资源。

        1、当有车开进去的时候,就相当于申请一个可用资源,可用车位就-1(这个称为信号量的P操作)。

        2、当有车开出去的时候,就相当于释放一个可用资源,可用车位就+1(这个称为信号量的V操作)。

        3、当停车场停满车的时候,也就是计数器值为0了,如果还尝试申请资源,就会阻塞等待,知道有其他线程释放资源。

注意:所谓的锁,本质也是信号量,这个信号量比较特殊,可以理解成计数器值为1的信号量。

        锁处于释放状态,计数器值就是1;锁处于加锁状态,计数器值就是0。对于这种非0即1的信号量,称为 “二元信号量”

代码示例

        用两个线程一起完成count自增10000次操作。

public class ThreadDemo1 {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(1);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                count++;
                semaphore.release();;
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                count++;
                semaphore.release();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count = " + count);
    }
}

执行结果:

多线程(进阶三:JUC),java,开发语言,java-ee

注意:信号量也可以保证线程安全。保证线程安全有以下几种方式:

        1、使用synchronized锁

        2、使用ReentrantLock锁

        3、CAS原子类操作

        4、使用信号量Semaphore


六、CountDownLatch

        CountDownLatch是针对特定场景的小工具。例如:多线程执行任务,把一个大的任务拆分成一个个的小任务,由每个线程执行这些小任务,等执行完全部的小任务,再进行一个汇总,从而完成这样的大任务。那么我们是怎么知道啥时候所有的小任务都完成了呢?如果使用join是无法感知到的,这时候就可以使用CountDownLatch这样的小工具了,它能感知到所有的小任务都完成。

        有这样的多线程下载软件,像idm,基本可以下载任何网站的电影,如果使用浏览器默认的下载方式没有那么快,但idm不一样,因为是多线程下载,可以下载的很快,最终完成后把所有的内容都拼接在一起,就是使用CountDownLatch这样的小工具,可以感知到啥时候这些小任务都下载完了。

代码示例

        创建出5个线程下载一个任务,把这个任务分成5个小任务,5个线程进行下载,都下载往后,打印下载完成。

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //1、此处的构造方法写10,意思是有10个线程/任务
        CountDownLatch latch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            int id = i;
            Thread t = new Thread(() -> {
                Random random = new Random();
                //[0,5)
                int time = (random.nextInt(5) + 1) * 1000;
                System.out.println("线程" + id + "开始下载");
                try {
                    Thread.sleep(time);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程" + id + "结束下载");
                //2、告知CountDownLatch我执行完了
                latch.countDown();
            });
            t.start();
        }
        //3、通过这个await操作来等待所有任务结束,也就是countDown被调用10次了
        latch.await();
        System.out.println("所有任务都下载完成!");
    }
}

执行结果:

多线程(进阶三:JUC),java,开发语言,java-ee

注意:

1、构造CountDownLatch实例,初始化5表⽰有5个任务需要完成.
2、每个任务执行完毕,都调用 latch.countDown() .在CountDownLatch内部的计数器同时自
减.
3、主线程中使用 latch.await(); 阻塞等待所有任务执行完毕.相当于计数器为0了.


七、相关面试题

1、线程同步的方式有哪些?

答:synchronized、ReentrantLock、Semaphore、原子类的一些操作等都可以。

2、为什么有了synchronized还需要juc下的lock?

答:以JUC的ReentrantLock为例。

        (1)ReentrantLock提供了tryLock操作,进行加锁时,如果失败则返回false,不会阻塞,搭配使用tryLock使用更灵活,而不是死等。而synchronized加锁失败会阻塞,可能会死等。

        (2)ReentrantLock和synchronized搭配的wait、notify机制不同,ReentrantLock搭配的是Condition类,功能比wait、notify更强,可以精确的控制唤醒某个线程。

        (3)synchronized是非公平锁,ReentrantLock是公平锁。

3、AtomicInteger的实现原理是什么?

基于CAS机制,伪代码如下:
多线程(进阶三:JUC),java,开发语言,java-ee

详细过程参考地址:多线程(进阶二:CAS)-CSDN博客

4、信号量听说过么?之前都用在过哪些场景下?

答:信号量,用来表示“可用资源的个数”,本质上是个计数器,停车场的展示牌原理就是使用了信号量。使用过的场景:两个线程完成count变量自增10000次;创建Semaphore实例的时候,构造方法的实参传1,表示计数器值为1,当一个线程自增钱就会申请1个资源——P操作,自增完后就会释放1个资源——V操作;两个线程不会同时自增,不会出现线程安全问题,自增前P操作的计数器-1,计数器值为0,另一个线程不会自增,等当前线程自增完后,V操作,计数器值+1,才能进行自增。可以解决线程安全问题。

5、解释⼀下ThreadPoolExecutor构造方法的参数的含义

参考下面地址内容:多线程(初阶九:线程池)-CSDN博客文章来源地址https://www.toymoban.com/news/detail-828345.html


都看到这了,点个赞再走吧,谢谢谢谢!

到了这里,关于多线程(进阶三:JUC)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Java EE初阶八】多线程案例(计时器模型)

            计时器类似闹钟,有定时的功能,其主要是到时间就会执行某一操作,即可以指定时间,去执行某一逻辑(某一代码)。         在java标准库中,提供了Timer类,Timer类的核心方法是schedule( 里面包含两个参数,一个是要执行的任务代码,一个是设置多久之后

    2024年01月21日
    浏览(46)
  • 【JUC进阶】03. Java对象头和内存布局

    为了后面更好的学习锁优化以及运作过程,需要我们对HotSpot虚拟机的Java对象内存布局有一定的了解,也作为技术储备。 在HotSpot虚拟机中,对象在堆内存中存储的布局可以划分为三个部分:对象头(Header)、实例数据(Instance Data)、对齐填充(Padding)。 而数组对象和普通对

    2024年02月10日
    浏览(40)
  • Java多线程(3)---锁策略、CAS和JUC

    目录 前言 一.锁策略 1.1乐观锁和悲观锁 ⭐ 两者的概念 ⭐实现方法 1.2读写锁  ⭐概念 ⭐实现方法 1.3重量级锁和轻量级锁 1.4自旋锁和挂起等待锁 ⭐概念 ⭐代码实现 1.5公平锁和非公平锁 1.6可重入锁和不可重入锁 二.CAS 2.1为什么需要CAS 2.2CAS是什么 ⭐CAS的介绍 ⭐CAS工作原理

    2024年02月13日
    浏览(63)
  • 【Java多线程】面试常考 —— JUC(java.util.concurrent) 的常见类

    目录 1、JUC(java.util.concurrent) 1.1、Callable 接口 1.2、ReentrantLock 可重入锁 1.3、Semaphore 信号量 1.4、CountDownLatch 这是java中的一个包,存放着 多线程编程 中常见的一些类。 【Java多线程】Thread类的基本用法-CSDN博客 https://blog.csdn.net/zzzzzhxxx/article/details/136121421?spm=1001.2014.3001.5501 往

    2024年04月10日
    浏览(83)
  • Java - JUC(java.util.concurrent)包详解,其下的锁、安全集合类、线程池相关、线程创建相关和线程辅助类、阻塞队列

    JUC是java.util.concurrent包的简称,在Java5.0添加,目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题 java.lang.Thread.State tools(工具类):又叫信号量三组工具类,包含有 CountDownLatch(闭锁) 是一个同步辅助类,在完成一组正在其他线程中

    2024年02月05日
    浏览(34)
  • 【Java|多线程与高并发】JUC中常用的类和接口

    JUC是Java并发编程中的一个重要模块,全称为 Java Util Concurrent (Java并发工具包),它提供了一组用于多线程编程的工具类和框架,帮助开发者更方便地编写线程安全的并发代码。 本文主要介绍 Java Util Concurrent 下的一些常用接口和类 Callable接口类似于Runnable. 有一点区别就是

    2024年02月12日
    浏览(32)
  • 【JavaEE】JUC(java.util.concurrent)的常见类以及线程安全的集合类

    目录 1、JUC(java.util.concurrent)的常见类 1.1、Callable接口的用法(创建线程的一种写法)  1.2、ReentrantLock可重入互斥锁 1.2.1、ReentrantLock和synchronized的区别  1.2.2、如何选择使用哪个锁 1.3、Semaphore信号量 1.4、CountDownLatch  2、线程安全的集合类 2.1、多线程环境使用ArrayList  2.2、

    2024年02月07日
    浏览(46)
  • Java/Python/Go不同开发语言在进程、线程和协程的设计差异

    在多线程项目开发时,最常用、最常遇到的问题是 1,线程、协程安全 2,线程、协程间的通信和控制 本文主要探讨不同开发语言go、java、python在进程、线程和协程上的设计和开发方式的异同。 进程 进程是 操作系统进行资源分配的基本单位,每个进程都有自己的独立内存空

    2024年01月23日
    浏览(47)
  • Java开发 - 不知道算不算详细的JUC详解

    大概有快两周没有发文了,这段时间不断的充实自己,算算时间,也到了该收获的时候,今天带来一篇JUC详解,但说实话,我也不敢自信它详不详细。JUC说白了就是多线程,学Java不久的人知道多线程,恐怕还不知道JUC是什么。在这篇博客中,博主将对JUC做一个自认为比较全面

    2024年02月06日
    浏览(44)
  • Java EE 企业级应用开发教程题库(第二版)

      Java EE这是一门偏向于实践的课,奈何考试理论居多。一学期想搞懂三个框架,嘿嘿,难哦!如果你是大一大二的同学,认认真真学习,真的有用。如果你是大三的同学,像就业并且走这个方向的同学,也认真学习。如果你大三考研的同学,自己安排时间。这里是我平时的

    2024年02月09日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包