多线程&JUC

已于 2023-07-23 13:10:56 修改
阅读量37 收藏
点赞数
文章标签： java
于 2023-05-16 09:57:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SatanDYG/article/details/130687386
版权

文章目录

进程与线程

进程：是程序的基本执行实体
线程：是操作系统能够进行运算调度的最小的单位，它被包含在进程之中，是进程中的实际运作单位。

多线程的两个概念

并发：在同一时刻，有多个指令在单个CPU上交替执行
并行：在同一时刻，有多个指令在多个CPU上同时执行

多线程的实现方式

1. 继承Thread类的方式进行实现

2. 实现Runnable接口的方式进行实现

3. 利用Callable接口和Future接口方式实现

在这里插入图片描述

Thread常见的成员方法

在这里插入图片描述

线程优先级最小是1，最大是10，默认是5；优先级越大，抢占到CPU的概率越大。
当其他非守护线程执行完毕后，守护线程会陆续结束(当非守护线程结束了，守护线程也就没有存在的必要了，不会等到执行完守护线程才结束)。

线程的生命周期

在这里插入图片描述

线程安全的问题

练习：

需求：
某电影院目前正在上映国产大片，共有100张票，而它有三个窗口卖票，请设计一个程序模拟该电影院卖票。

代码实现：

public class MyThread extends Thread {
    // 加static表示这个类的所有对象，都共享ticket数据
    static int ticket = 0;//0~99

    @Override
    public void run() {
        while (true) {
            if (ticket < 100) {
                ticket++;
                System.out.println(getName() + "正在卖第" + ticket + "张票！");
            } else {
                break;
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        // 开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

上述代码存在安全问题：

  1. 相同的票出现多次
  2. 出现超出范围的票

引发原因：
线程执行时，具有随机性。
解决思路：
把操作共享数据的代码锁起来。
解决方法：

  1. 同步代码块
  2. 同步方法

同步代码块

在这里插入图片描述
注意：synchronized的锁对象可以时任意的，但一定要是唯一的

修改上述线程类代码：

public class MyThread extends Thread {
    // 加static表示这个类的所有对象，都共享ticket数据
    static int ticket = 0;//0~99
    // 锁对象，一定要是唯一的
    static Object object = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (object) {
                if (ticket < 100) {
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票！");
                } else {
                    break;
                }
            }
        }
    }
}

锁对象也可以用MyThread.class对象，因为字节码文件也是唯一的。

同步方法

在这里插入图片描述
这里我们用第二种方式实现多线程

public class MyRunnable implements Runnable {
    int ticket = 0;

    @Override
    public void run() {
        while (true) {
            if (method()) {
                break;
            }
        }
    }

    private synchronized boolean method() {
        if (ticket < 100) {
            ticket++;
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票！");
            return false;
        } else {
            return true;
        }
    }
}


public class ThreadDemo {
    public static void main(String[] args) {
        // 创建线程对象
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        Thread t3 = new Thread(myRunnable);

        // 起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        // 开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

Lock锁

代码实现：

public class MyThread extends Thread {
    // 加static表示这个类的所有对象，都共享ticket数据
    static int ticket = 0;//0~99
    // 注意：采用第一种实现多线程的方式，锁对象要加static关键字
    static Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (ticket < 100) {
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "张票！");
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        // 开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

死锁

锁的嵌套会引发死锁
在这里插入图片描述
死锁的代码实现:

public class MyThread extends Thread {
    static Object objectA = new Object();
    static Object objectB = new Object();

    @Override
    public void run() {
        while (true) {
            if ("线程A".equals(getName())) {
                synchronized (objectA) {
                    System.out.println("线程A拿到了A锁,准备拿B锁");
                    synchronized (objectB) {
                        System.out.println("线程A拿到了B锁,顺利执行完一轮");
                    }
                }
            } else if ("线程B".equals(getName())) {
                synchronized (objectB) {
                    System.out.println("线程B拿到了B锁,准备拿A锁");
                    synchronized (objectA) {
                        System.out.println("线程B拿到了A锁,顺利执行完一轮");
                    }
                }
            }

        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        // 起名字
        t1.setName("线程A");
        t2.setName("线程B");

        // 开启线程
        t1.start();
        t2.start();
    }
}

执行结果：
在这里插入图片描述

生产者和消费者(等待唤醒机制)

生产者消费者模式是一个十分经典的多线程协作模式
在这里插入图片描述

在这里插入图片描述

生产者消费者常见方法

在这里插入图片描述

生产者消费者模式代码实现

用来控制生产者和消费者的执行：

/**
 * @date 2023/7/22
 * @deprecated 用来控制生产者和消费者的执行
 */
public class Desk {
    /**
     * 桌子上是否有食物  0：没有食物 1：有食物
     */
    public static int foodFlag = 0;
    /**
     * 最多能吃10个
     */
    public static int count = 10;

    /**
     * 锁对象   要唯一
     */
    public static Object lock = new Object();

}

消费者代码：

/**
 * @date 2023/7/22
 * @deprecated 消费者
 */
public class ConsumerThread extends Thread {

    @Override
    public void run() {
        /*
         * 1. 循环
         * 2. 同步代码块
         * 3. 判断共享数据是否到了末尾（到了末尾）
         * 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）
         **/

        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    // 判断桌子上是否有食物
                    if (Desk.foodFlag == 0) {
                        // 如果没有，就等待
                        try {
                            Desk.lock.wait(); // 让当前线程跟锁进行绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        // 把吃的总数-1
                        Desk.count--;
                        // 如果有，就开吃
                        System.out.println("消费者正在吃面条，还能再吃" + Desk.count + "碗！！！");
                        // 修改桌子状态
                        Desk.foodFlag = 0;
                        // 吃完之后，唤醒生产者继续生产
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

生产者代码：

/**
 * @date 2023/7/22
 * @deprecated 生产者
 */
public class ProducerThread extends Thread{

    @Override
    public void run() {
        /*
         * 1. 循环
         * 2. 同步代码块
         * 3. 判断共享数据是否到了末尾（到了末尾）
         * 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）
         **/

        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    // 判断桌子上是否有食物
                    if (Desk.foodFlag == 1) {
                        // 如果有，就等待
                        try {
                            Desk.lock.wait(); // 让当前线程跟锁进行绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        // 如果没有，就开始生产
                        System.out.println("生产者生产了一碗面条！！！");
                        // 修改桌子状态
                        Desk.foodFlag = 1;
                        // 生产完之后，唤醒消费者继续吃
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

启动类：

public class ThreadDemo {
    public static void main(String[] args) {
        // 创建线程对象
        ConsumerThread consumer = new ConsumerThread();
        ProducerThread producer = new ProducerThread();

        // 给线程设置名字
        producer.setName("生产者");
        consumer.setName("消费者");

        // 开启线程
        producer.start();
        consumer.start();
    }
}

等待唤醒机制（阻塞队列方式实现）

在这里插入图片描述
在这里插入图片描述
细节：生产者和消费者必须使用同一个阻塞队列； 阻塞队列的put方法和take方法中就有加锁了，所以我们不需要在使用synchronized关键字或者使用Lock锁了。

消费者代码实现：

public class ConsumerThread extends Thread {

    ArrayBlockingQueue<String> queue;

    public ConsumerThread(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true){
            // 不断从阻塞队列中获取面条
            try {
                String take = queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生产者代码实现

public class ProducerThread extends Thread {
    ArrayBlockingQueue<String> queue;

    public ProducerThread(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                queue.put("面条");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

启动类代码实现：

public class ThreadDemo {

    public static void main(String[] args) {

        // 创建容量为1的阻塞队列
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

        // 创建线程对象
        ConsumerThread consumerThread = new ConsumerThread(queue);
        ProducerThread producerThread = new ProducerThread(queue);

        // 开启线程
        consumerThread.start();
        producerThread.start();
    }
}

注意： 上述的生产者和消费者代码中都没有打印语句是因为阻塞队列的put和take方法中实现了加锁，如果我们写的打印语句的话，打印语句是在锁的外面de，就会有重复打印的现象。但是打印语句没有操作共享数据的话是不会有问题的。

线程的状态

在这里插入图片描述

在这里插入图片描述

DYG.Satan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JUC多线程学习个人笔记
07-08
JUC（Java Util Concurrent）是Java中用于并发编程的工具包，提供了一组接口和类，用于处理多线程和并发操作。JUC提供了一些常用的并发编程模式和工具，如线程池、并发集合、原子操作等。 JUC的主要特点包括： ...
多线程~juc
张华的博客
01-09 1199
1.juc相关概念 1.1进程/线程 1)进程:是一个程序运行的最小单位(巧记：先"进"来，然后才能看到线程) 2)线程:是进程里最小的运行单位(例如idea进程,里面有多个微服务在运行,就是线程) 3)线程的6种状态: NEW(新生态),RUNNABLE(运行态),BLOCKED(阻塞态),WAITING(无限等待),TIMED_WAITING(有限等待),TERMINATED(死亡态) 1.2并发/并行 并发: 在相对的一段时间内,其实是很短,对计算机有感,对人无感,多个线程抢占资源来执行自
2023/3/4 多线程&JUC（第二部分）
Viper224的博客
03-04 45
多线程
多线程&JUC：线程的生命周期与安全问题
m0_52380556的博客
02-08 663
多线程&JUC：线程的生命周期与安全问题
多线程&JUC：线程池原理、自定义线程池详细解析
m0_52380556的博客
02-09 815
多线程&JUC：线程池原理、自定义线程池详细解析
多线程&JUC：解决线程安全问题——synchronized同步代码块、Lock锁
m0_52380556的博客
02-08 733
多线程&JUC：解决线程安全问题——synchronized同步代码块、Lock锁
thread.zip--狂神多线程+juc
03-18
B站狂神说Java的多线程基础篇+juc高级篇代码
Java多线程和JUC.pdf
01-22
java多线程的一些知识与问题的总结
多线程以及juc,lock
07-20
多线程以及juc,lock
多线程源码JUC以及多线程和高并发
01-22
多线程源码JUC以及多线程和高并发 https://blog.csdn.net/u011488009 主要是根据 https://blog.csdn.net/u011488009/category_9678616.html 专栏来讲解的源码，都可以作为高并发的学习，练手用，主要是看这个源码...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 956
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 901
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 821
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java解决最长公共前缀
无人罪的博客
04-28 233
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 452
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 905
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
Spring cloud原理详解
qq_33449977的博客
04-28 349
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
最新发布
qq_43209531的博客
04-30 208
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 736
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
juc种线程安全的集合
06-10
Java中提供了很多线程安全的集合类，其中常用的包括： 1. ConcurrentHashMap：线程安全的哈希表，支持高并发的读写操作，内部使用了锁分离技术和CAS算法。 2. CopyOnWriteArrayList：线程安全的动态数组，支持高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值