并发编程简介

最新推荐文章于 2024-08-11 10:00:00 发布
最新推荐文章于 2024-08-11 10:00:00 发布
阅读量3.3k 收藏 8
点赞数 1
分类专栏： 并发编程 文章标签： java 面试 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39360632/article/details/124891075
版权

Java 并发编程

一、 并发编程三要素

  1. 原子性：即一个不可被分割的操作。
    Java 中的原子性指：一个或多个操作要么全部执行成功，要么全部执行失败

  2. 有序性：程序执行的顺序是按照代码的先后顺序执行的。
    cpu 有可能会对指令进行重排序

  3. 可见性：当多个线程访问同一个共享变量时，如果其中一个线程对其进行了修改操作，其它线程能立即获取到最新修改的值。

二、线程的五大状态

对应cpu 的线程状态

  1. 新建状态：通过new 创建一个线程
  2. 就绪状态：调用start 方法，处于就绪状态的线程不一定立马就会执行run 方法，还需要等CPU的调度。
  3. 运行状态：cpu开始调度线程，开始执行run方法
  4. 阻塞状态：线程在执行过程中由于某些原因进入阻塞状态。如：sleep()、获取锁失败、时间片用完等
  5. 死亡状态：run方法执行完，或执行过程中遇到异常。

三、悲观锁与乐观锁

悲观锁：每次操作都会加锁，造成线程阻塞。如：synchronized、reentrantlock
乐观锁：每次操作都不会加锁，而是假定没有冲突而去完成某种操作。如果有冲突就重试，直到成功为止，不会造成线程的阻塞。虽然不会造成线程阻塞，但是频繁的重试会导致cpu的长时间被占用。

四、线程之间的协作

wait、notify、notifyAll等

五、synchronized 关键字

synchronized 是Java中的关键字，是一种同步锁，底层使用的是Monitor监视器。
它修饰的对象有一下几种：

  1. 修饰一个代码块 被修饰的代码块称为同步代码块，其作用范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。
  2. 修饰一个方法 被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象。
  3. 修饰一个静态的方法 其作用范围是整个静态方法，作用的对象是这个类对象
  4. 修饰一个类 其作用的范围是synchronized后面括起来的部分，作用的对象是这个类对象。

对第4点解释：

public void test(){
	// 当前synchronized 作用的范围是 {} 的部分
	// 加锁的对象是 A.class 对象
	synchronized(A.class){

	}
}

六、CAS

CAS：Compare And Swap 比较并交换。

原理：

使用到的是cpu的一个原子操作，操作包含三个操作数，内存值、预期值、更新的值。如果内存值与预期值相同，那么就能将该值修改为更新的值。否则修改失败。

缺点：

  1. ABA 问题 可通过版本号或者时间戳解决
  2. 循环时间长对CPU的开销大 可以增加重试次数，超过重试次数则直接放弃
  3. 只能保证一个共享变量的原子操作。后续可以使用原子引用对象来解决该问题

七、Thread.State 类中定义的六种线程状态

  1. new：Thread对象已经创建，但是还没有执行。
  2. Runnable：Thread对象在java 虚拟机中运行。
  3. Block：Thread对象被阻塞。
  4. Waitting：Thread对象在等待另外一个线程的动作。
  5. Time_Waiting：Thread对象在等待另外一个线程的动作，但是有时间限制。
  6. Terminated：Thread已经完成了执行

八、Thread类的常用方法：

  • 获取和设置Thread对象信息的方法
    • getId()： 返回Thread 对象的标识符。该标识符是在线程创建时分配的一个正整数。在线程的整个生命周期中是唯一且无法改变的。
    • getName()/setName()：获取、设置Thead 对象的名称。这个名称是一个String 类型。也可以在Thread的构造方法中指定。
    • getPriority()/setPriority()：获取或者设置Thread对象的优先级。
    • isDaemon()/setDaemon()：获取或者设置守护线程。
    • getState()：返回Thread对象的状态。
  • interrupt()：中断目标线程。给目标线程打上一个中断标记。
  • interrupted()：判断目标线程是否被中断，但是将清除线程的中断标记。
  • isInterrupted()：判断目标线程是否被中断，不会清除中断标记。
  • sleep(long ms)：暂停当前线程ms时间。
  • join()：暂停线程的执行，直到调用该方法的线程执行结束为止。可以使用该方法等待另外一个线程结束。
  • currentThread()：Thread类的静态方法，返回实际执行该代码的Thread对象。

九、Callable

  • 接口。有简单类型参数，与call() 方法的返回类型相对应
  • 声明了call()。执行器运行任务时，该方法会被执行器执行。必须返回声明中指定类型的对象。
  • call() 方法可以抛出任何一种校验异常。可以实现自己的执行器并重载afterExecute() 方法来处理这些异常`
package com.yj.juc;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(500);
        return "call 的返回值";
    }
}


package com.yj.juc;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Main1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        // 启动线程执行任务
        new Thread(futureTask).start();
        // 需要同步阻塞获取到任务的结果
        System.out.println(futureTask.get());
        System.out.println("main1 方法执行结束");
    }
}

package com.yj.juc;

import java.util.concurrent.*;

public class Main2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                5,
                5,
                1000,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10)
        ){
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
//                super.afterExecute(r, t);
                System.out.println("call 执行结束"+t);
            }
        };

        Future<String> future = threadPoolExecutor.submit(new MyCallable());
        String result = future.get();
        System.out.println(result);
        threadPoolExecutor.shutdown();
    }
}

// Main2 的打印结果：
call 的返回值
call 执行结束null

十、生产者与消费者模型

生产者、消费者是一个常见的多线程模型。
在这里插入图片描述
解释：

多个生产者线程往内存队列中存放数据；多个消费者线程从内存队列中取数据。

前提条件：

  1. 加锁，内存队列本身要加锁，才能实现队列的安全。
  2. 阻塞，当内存队列满了，生产者放不进去数据，就会阻塞。当队列为空时，消费者取不到数据，就会被阻塞。
  3. 唤醒通知，消费者消费之后，要通知生产者生产新的数据。反之生产者生产消息之后，要通知消费者消费

如何阻塞？
办法1：线程自己阻塞自己，也就是生产者、消费者线程各自调用wait和notify
办法2：用一个阻塞队列，当娶不到或者放不进去数据的时候，入队、出队操作阻塞、

如何唤醒、通知？
办法1：使用wait和notify。必须在Synchronized中使用
办法2：Condition机制。Lock 锁

案例：

任务队列：

package com.yj.juc.demo01;

/**
 * 任务队列
 */
public class MyQueue {
    // 存放任务的队列
    private String [] queue;
    // 添加时元素的下标
    private Integer putIndex = 0;
    // 获取时元素的下标
    private Integer getIndex = 0;
    // 元素的个数
    private Integer size = 0;

    // 锁对象
    private static final Object lock = new Object();


    public MyQueue(Integer size){
        this.queue = new String[size];
    }

    /**
     * 当前方法存在的问题：
     * 1、在单线程的情况下没有问题
     * 2、多线程的情况可能会出现多个线程同时阻塞，然后同时被唤醒。那么添加的元素就有可能超过队列的长度。
     * 解决方案：
     * 1、唤醒之后重新获取锁，获取成功则添加元素
     * @param element
     */
    public synchronized void put(String element){
        // 如果队列中的元素已经存满，则阻塞
        if (size == queue.length){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        queue[putIndex++] = element;
        ++size;
        putIndex = putIndex % queue.length;
        notify();
    }

    public synchronized String get(){
        if (size == 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String result = queue[getIndex++];
        --size;
        getIndex = getIndex % queue.length;
        notify();
        return result;
    }
}

消费者：

package com.yj.juc.demo01;

import java.util.Random;

public class MyConsumer implements Runnable {

    private MyQueue myQueue;

    public MyConsumer(MyQueue myQueue){
        this.myQueue = myQueue;
    }


    @Override
    public void run() {
        while (true){
            try {
                String result = myQueue.get();
                System.out.println("消费者消费消息：" + result);
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生产者：

package com.yj.juc.demo01;

import java.util.Random;

public class MyProvider implements Runnable {

    private MyQueue myQueue;

    public MyProvider(MyQueue myQueue){
        this.myQueue = myQueue;
    }


    @Override
    public void run() {
        int index = 0;
        while (true){
            try {
                String temp = "生产者生产消息"+index++;
                myQueue.put(temp);
                System.out.println(temp);
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

当前存在的问题：在多线程情况下有可能会通知多个线程。
解决方案：
在通知唤醒之后，尝试获取锁，获取成功才能执行对应的操作。

package com.yj.juc.demo01;

public class MyQueue2 extends MyQueue {

    // 存放任务的队列
    private String [] queue;
    // 添加时元素的下标
    private Integer putIndex = 0;
    // 获取时元素的下标
    private Integer getIndex = 0;
    // 元素的个数
    private Integer size = 0;

    // 锁对象
    private static final Object lock = new Object();


    public MyQueue2(Integer size){
        super(size);
    }

    /**
     * 当前方法存在的问题：
     * 1、在单线程的情况下没有问题
     * 2、多线程的情况可能会出现多个线程同时阻塞，然后同时被唤醒。那么添加的元素就有可能超过队列的长度。
     * 解决方案：
     * 1、唤醒之后重新获取锁，获取成功则添加元素
     * @param element
     */
    public synchronized void put(String element){
        // 如果队列中的元素已经存满，则阻塞
        if (size == queue.length){
            try {
                wait();
                put(element);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            put1(element);
            notify();
        }

    }

    private void put1(String element) {
        queue[putIndex++] = element;
        ++size;
        putIndex = putIndex % queue.length;
    }

    public synchronized String get(){
        if (size == 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return get();
        }else{
            String result = get1();
            notify();
            return result;
        }
    }

    private String get1() {
        String result = queue[getIndex++];
        --size;
        getIndex = getIndex % queue.length;
        return result;
    }
}

当前代码还存在的问题：
notify()通知唤醒是随机唤醒的。

十一、interrupt() 和 interruptedException()

interrupt()：用来打断正在睡眠的线程，如wait()、sleep()
interruptedException()：只有在方法上声明了interruptException 异常，被打断的话就会抛出异常。

十二、轻量级阻塞和重量级阻塞

轻量级阻塞：能够被中断的阻塞称为轻量级阻塞。对应的线程状态为WAITING；
重量级阻塞：synchronized 不能被中断的阻塞称为重量级阻塞，对应的状态为Block；

在这里插入图片描述

十三、线程的interrupt、interrupted 、isInterrupted 区别？

总结：
1、interrupt：置线程的中断状态
2、isInterrupt：线程是否中断
3、interrupted：返回线程的上次的中断状态，并清除中断状态

十四、线程如何优雅关闭

14.1、stop、destory方法

这两个方法会强制杀死线程，比如线程运行到了一半被强制杀死？
问题：
这些方法不建议使用，因为强制杀死线程，则线程中所使用的资源，例如文件资源、网络连接等都无法关闭。
因此，一个线程一旦运行中，则应该尽量让他运行完，合理的释放资源，不要强行关闭。
如果是一个不断循环运行的线程，就需要用到线程通信机制，让主线程通知其退出。

14.2、使用守护线程

因为当用户线程执行完之后，守护线程也会结束。

14.3、设置关闭的标志位

通过标志位的方式，停止正在循环运行的线程

public class MyThread extends Thread{

private boolean flag = true;

@Override
public void run(){
	while(flag){
		// do ...
	}
}

public void stop(){
	this.flag = false;
}

}

但是当前代码存在一个问题：
如果Mythread 在while 循环里被阻塞了，例如里面调用了Object.wait()，则永远都无法执行到while(false)，也就会一直无法退出。此时就可以用到interrupt()或interruptException()。

从程序到猿
关注
专栏目录
Introduction-to-Concurrent-Programming:并发编程简介
07-01
并发编程简介 课程文件夹 包含教授课程的所有组件。 在家工作 作业文件夹包含所有作业。 家庭作业包括可以在短时间内完成的更简单的编程作业。 讲座 一个有用的相关信息和资源库。 项目 更复杂的问题建立在家庭作业...
Java高并发编程，构建并发编程知识体系，提升面试成功率
09-23
Java高并发编程，构建并发编程知识体系，提升面试成功率，完整版17章视频教程下载。 本课程将结合大量图示及代码演示，带你掌握多线程并发编程（线程安全，线程调度，线程封闭，同步容器等）与高并发处理思路与手段...
Java并发编程：CountDownLatch、CyclicBarrier和Semaphore
weixin_30548917的博客
09-03 943
Java并发编程：CountDownLatch、CyclicBarrier和Semaphore 　　在java 1.5中，提供了一些非常有用的辅助类来帮助我们进行并发编程，比如CountDownLatch，CyclicBarrier和Semaphore，今天我们就来学习一下这三个辅助类的用法。 　　以下是本文目录大纲： 　　一.CountDownLatch用法 　　二.Cycl...
java并发编程
GEFEICHEN的博客
08-13 347
并发编程简介 java是一个支持多线程的开发语言。多线程可以在包含多个CPU核心的机器上同时处理多个不同的任务，优化资源的使用率，提升程序的效率。在一些对性能要求比较高场合，多线程是java程序调优的重要方面。 Java并发编程主要涉及以下几个部分: 并发编程三要素 原子性:即一个不可再被分割的颗粒。在Java中原子性指的是一个或多个操作要么全部执行成 功要么全部执行失败。 有序性:程序执行的顺序按照代码的先后顺序执行。(处理器可能会对指令进行重排序) 可见性:当多个线程访问同一个变量时，如果其中一个线
超详细Python教程——并发编程
最新发布
月流霜的专栏
08-11 1140
可以通过消息队列来实现应用程序的解耦合，消息队列相当于是多线程同步队列的扩展版本，不同机器上的应用程序相当于就是线程，而共享的分布式消息队列就是原来程序中的Queue。消息队列（面向消息的中间件）的最流行和最标准化的实现是AMQP（高级消息队列协议），AMQP源于金融行业，提供了排队、路由、可靠传输、安全等功能，最著名的实现包括：Apache的ActiveMQ、RabbitMQ等。下面的代码异步的从5个URL中获取页面并通过正则表达式的命名捕获组提取了网站的标题。对象来获取任务执行的结果。
并发编程
枫
01-15 3978
目录 1.为什么要引入并发编程？ 2.区分并发与并行 3.并发编程的两种模型 4.Java并发编程 4.1 Java常用的锁 4.2 基于CAS的机制实现的支持并发的操作 4.3 并发编程常用的工具类 4.4 Java并行计算框架Fork/Join 5. Golang并发编程 5.1 Golang相关的锁机制 5.2 Golang的CAS机制 5.3 Golang的并发工具 5.4 Golang实现CS调用 6.其他并发编程 7.总结 8.参考文章 1.为什么要引入并发编程
Java并发编程基本知识介绍
qq_37996327的博客
05-29 1889
1、什么是并发？ 用户通常认为计算机在同一时刻可以做多个事情是理所当然的事情。 例1：例如你可以一边听音乐，一边玩游戏，同时还通过聊天工具和别人聊天。假设你使用的qq音乐播放器在听音乐，玩的是qq斗地主游戏，使用qq和别聊天，那么这实际上是三个不同的软件在同时运行，完成三个不同的事情。 例2：当然我们也不能否认，在一个软件内，同时可以完成以上三个事情：聊天、游戏和音乐。例如你在玩qq斗地主，...
并发编程介绍
fengruxue的专栏
10-12 179
并发编程
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
java并发编程实践pdf笔记
12-15
Java并发编程实践是Java开发中不可或缺的一个领域，它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点，旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
Java 并发编程实战.pdf
05-28
《Java并发编程实战》这本书是关于Java语言中并发编程技术的经典著作。它详细介绍了如何在Java环境中有效地实现多线程程序和并发控制机制。在Java平台上，由于其本身提供了强大的并发编程支持，因此，掌握并发编程...
【并发编程】并发编程
StrongHelper的博客
01-19 263
rodo
一文详解并发编程
weixin_40709965的博客
12-03 1441
并发编程知识总结
了解并发编程
yzl1293346757的博客
02-10 691
了解并发编程的相关知识，理解并发问题的核心
Python并发式编程
qq_41700104的博客
03-24 164
Python并发式编程 进程 进程就是一个程序在一个数据集上的一次动态执行过程，一般由程序、数据集和进程控制块三部分组成； 程序用来描述进程要完成哪些功能以及如何完成； 数据集则是程序在执行过程中所需要使用的资源； 进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系 统感知进程存在的唯一标志. 在一个程序的运行过程中，因为一个CPU在一个时间点只能运行...
什么是并发编程
siyuao的博客
06-16 1306
什么是并发编程 最初的计算机诞生时使用的一直都是单进程跑程序，一台计算机只跑一个程序，的确，这样做速度非常快，而且现在一台机器跑一个程序肯定比一台机器跑多个程序要快，但是这样会造成相应的资源浪费，直到有操作系统的出现，计算机的资源才开始了进一步的利用，直到一台机器可以由多个进程，一个进程有多个线程出现。 那什么是并发编程呢？ ​ 就是让计算机在一定时间内同时跑多个程序所进行的程序 ​ <!–小弟年轻，文笔简陋，如有错误，欢迎指出，多谢多谢—> 那这样就可以解决一个问题，为什么
并发编程三要素？
qq_58003121的博客
02-14 381
1、原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操 作打断，要么就全部都不执行。 2、可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他 线程可以立即看到修改的结果。 3、有序性 有序性，即程序的执行顺序按照代码的先后顺序来执行。 ...
并发编程三要素：可见性、原子性、有序性
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
04-18 3505
一文讲透并发编程三要素：可见性、原子性、有序性
并发 编程
m0_51683428的博客
08-31 272
并发编程 并行与并发 **并发（concurrent）：**是同一时间应对多件事情的能力（串行）。 **并行（parallel）：**是同一时间动手做多件事情的能力。 程序,进程,线程 **程序 (program)????*是为了完成特定的任务,用某种语言编写的一组指令的集合. 即指一段静态事物代码. **进程 (process)????*就是正在执行的程序,从Windows角度讲，进程是含有内存和资源并安置线程的地方（操作系统分配资源的单元，运行中的程序） **线程 (thread)????*进程可进一步
Java并发编程深度解析
"Java并发编程-方腾飞魏鹏程晓明著" Java并发编程是Java开发中的重要主题，尤其对于大型企业级应用和分布式系统来说，理解并熟练掌握并发编程技术至关重要。阿里技术专家团队编写的《Java并发编程的艺术》详细探讨...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值