Java JUC基础笔记

于 2024-10-05 17:20:49 发布
阅读量550 收藏 11
点赞数 18
文章标签： java 笔记 开发语言 ide
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79083000/article/details/142716573
版权

Java JUC基础

此笔记适合入门(像进一步进阶的话，请移步尚硅谷34h的JUC）

多线程的创建

继承 Thread 类

import java.lang.Thread;

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread输出：" + i);
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        
        t.start(); // main线程 t线程
        
        for (int i= 1; i <= 5; i++) {
            System.out.println("主线程main输出: " + i);
        }
    }
}
优缺点：
  1. 优点：编码简单
  2. 缺点：线程类已经继承 Thread，无法继承其他类，不利于功能的扩展。
注意事项

  1. 启动线程必须是调用 start 方法，不是调用 run 方法。

    • 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
      • 只有调用start方法才是启动一个新的线程执行。

  2. 不要把主线程任务放在启动子线程之前。

    • 这样主线程一直是先跑完的，相当于是一个单线程的效果了。

实现 Runnable 接口

方式一
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程输出 ===> " + i);
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        Runnable target = new MyRunnable();
        
        new Thread(target).start();
        
        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出 ===>" + i);
        }
    }
}
优缺点
  • 任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
方式二
public class ThreadTest2_2 {
    public staic void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
					System.out.println("子线程1输出: " + i);
                }
            }
        };
        
        // 简化形式2
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("子线程3输出： " + i);
            }
        }).start();
        
        new Thread(target).start();
        
        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出: " + i);
        }
    }
}

实现 Callable 接口

image-20241005122727636

public class ThreadTest3 {
    public staic void main(String[] args) throws Exception {
        // 3. 创建一个 Callable 的对象
        Callable <String> call = new MyCallable(100);
        // 4. 把 Callable 的对象封装成一个 FutureTask 对象(任务对象)
        // 未来任务对象的作用
		// 1. 是一个任务对象
		// 2.可以在线程执行完毕之后 用未来任务对象调用 get 方法获取线程执行完毕后
        FutureTask<String> f1 = new FutureTask<>(call);
        
        // 5.把任务对象交给一个 Thread 对象
        new Thread(f1).start();
        
        // 6.取线程执行完毕后返回的结果。
        // 注意：如果执行到这儿，假如上面的线程还没有执行完毕
        // 这里的代码会暂停，等待上面线程执行完毕后才会获取结果
        String rs = f1.get();
        System.out.println(rs);
    }
}
FutureTask的API说明
public FutureTask<>(Callable call)把 Callable 对象封装成 FutureTask对象
public V get() throws Exception获取线程执行 call 方法返回的结果
优缺点
  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。
  • 缺点：编码复杂一点。

Thread 的常用方法

image-20241005125142508

⚠️ Thread类还提供了诸如：yield、interrupt、守护线程、线程优先级等线程 的控制方法，在开发中很少使用，这些方法会后续需要用到的时候再讲解。

线程安全

什么是线程安全问题

多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。

场景：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？

image-20241005132945235

  1. 线程安全问题出现的原因
  • 存在多个线程同时执行
  • 同时访问一个共享资源
  • 存在修改该用户共享资源

线程同步

同步思想概述

  • 让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

方式一：同步代码块

  • 作用：把访问共享资源的核心代码给上锁，以此保证线程安全。
  • 原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。
同步锁的注意事项
  • 对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。
public void drawMoney(double money) {
    // 先搞清楚是谁来取钱
    String name = Thread.currentThread().getName();
    // 1. 判断余额是否充足
    // synchronized ("黑马")(不推荐)
    synchronized ("this") {
        if (this.money >= money) {
            System.out.println(name + "来取钱" + money);
            this.money -= money;
            System.out.println(name + "来取钱后， 余额剩余为" + money);
        } else {
            System.out.println(name + "来取钱: 余额不足");
        }
    }
}

// 静态方法
public static void test() {
    synchronized (Account.class) {
        
    }
}
锁对象随便选择一个唯一的对象好不好呢？
  • 不好，会影响其他无关线程的执行。
锁对象的使用规范
  • 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象
  • 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

方式二：同步方法

  • 作用：把访问共享资源的核心方法给上锁，以此保证线程安全。
  • 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。
同步方法底层原理

  • 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

  • 如果方法是实例方法：同步方法默认用this作为的锁对象.

  • 如果方法是静态方法：同步方法默认用类名**.class**作为的锁对象。

方式三：Lock锁

  • Lock锁 是 JDK5 开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
  • Lock 是接口，不能直接实例化，可以采用它的实现类 ReentrantLock 来构建 Lock 锁对象。

image-20241005150841227

public void drawMoney(double money) {
    // 先搞清楚是谁来取钱
	String name = Thread.currentThread().getName();
    try {
        lk.lock(); //创建
        // 1.判断余额是否足够
        if (this.money >= money) {
            System.out.println(name + "来取钱" + money + "成功!");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余" + this.money);
        } else {
            System.out.println(name + "来取钱: 余额不足");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解题
        }
    }
}

线程通信

多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。

线程通信的常见模型（生产者与消费者模型）
  • 生产者线程负责生产数据
  • 消费者线程负责消费生产者生产的数据。

注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产。

方法名称说明
void wait()让当前线程等待并释放所占锁，直到另一个线程调用 notify（）方法或 notifyAll（）方法
void notify()唤醒正在等待的单个线程
void notifyAll()唤醒正在等待的所有线程

⚠️上述方法应该使用当前同步锁对象进行调用。

public class Desk {
    private List<String> list = new ArrayList<>();
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            if (list.size() == 0) {
				list.add(name + "做的肉包子");
                System.out.println(name + "做了一个肉包子");
                Thread.sleep(2000);
                
                this.notifyAll();
                this.wait();
            } else {
                this.notifyAll();
                this.wait();
            } 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            if (list.size() == 1) {
				System.out.println(name + "吃了: " + list.get(0) + "做的包子");
                list.clear();
                Thread.sleep(1000);
                
                this.notifyAll();
                this.wait();
            } else {
                this.notifyAll();
                this.wait();
            } 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}

public class Threadtest {
    public static void main(String[] args) {
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师1").start();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师2").start();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师3").start();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "吃货1").get();
        
        Desk desk = new Desk();
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

线程池

认识线程池

可以复用线程的技术

不使用线程池的问题
  • 用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，**而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，**这样会严重影响系统的性能。

image-20241005153732434

如何创建线程池？

  • JDK 5.0 起提供了代表线程池的接口：ExecutorService。
方式一：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象。

image-20241005154136468

image-20241005154451174

注意事项
  • 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
  • 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。
方式二：使用 Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

线程池处理 Runnable 任务

ExecutorService 的常用方法
方法名称说明
void execute (Runnable command)执行 Runnable 任务
void shutdown()执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
List shutdownNow()等全部任务执行完毕后，再关闭线程池！
Future submit (Callabl task)**立刻关闭线程池，停止正在执行的任务，**并返回队列中未执行的任务
import java.util.concurrent.*;
public class ThreadPoolTest1 {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(3, 5, TimeUnit.SECONDS, new ArrayBlockingQueue, Executors.defaultThreadFacotry new ThreadPoolExecutor.AbortPolicy());
        
        Runnable target = new MyRunnable();
        pool.execute(target); // 线性池会自动创建一个新线程，自动处理这个任务，自动执行的!
        pool.execute(target); // 线性池会自动创建一个新线程，自动处理这个任务，自动执行的!
        pool.execute(target); // 线性池会自动创建一个新线程，自动处理这个任务，自动执行的!
        pool.execute(target); // 复用前面的核心线程
        pool.execute(target); // 复用前面的核心编程
        
        // pool.shutdown(); // 等着线程池的任务全部执行完毕后，再关闭线程池
        pool.shutdownNow(); // 立即关闭线程池！ 不管任务是否执行完毕
        
    }
}
策略详解
ThreadPoolExecutor.AbortPolicy丢弃任务并抛出 RejectedExecutionException 异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy由主线程负责调用任务的 run() 方法从而绕过线程池直接执行

线程池处理 Callable 任务

image-20241005161152574

Executors 工具类实现线程池

image-20241005161651967

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(17);
        
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

老师: 核心线程数量到底配置多少呢？

计算密集型的任务: 核心线程数量 = CPU 的核数 + 1

IO密集型的任务： 核心线程数量 = CPU 核素 * 2

Executors 使用可能存在的陷阱

image-20241005162931909

其它细节知识：并发、并行

进程

  • 正在运行的程序（软件）就是一个独立的进程。
  • 线程是属于进程的，一个进程中可以同时运行很多个线程。
  • 进程中的多个线程其实是并发和并行执行的。
并发的含义
  • 进程中的线程是 由CPU负责调度 执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会 轮询为系统的每个线程服务，由于 CPU切换 的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

image-20241005163532691

并行的理解
  • 在同一个时刻上，同时有多个线程在被CPU调度执行。

image-20241005163632174

线程到底是怎么在执行的？

并发和并行同时进行的!

其它细节知识：线程的生命周期

image-20241005163930896

线程的6种状态相互转换

image-20241005164233075

public class MyRunnable2 implements Runable {
    // 整数修改乐观锁：原子类是实现的
    private AtomicInteger count = new AtomicInteger();
    
    @Override
    public void run() {
        for (int i = 0;i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "count =====>" + count.incrementAndGet());
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        // 目标：扩展悲观锁，乐观锁原理
        // 乐观锁：一开始不上锁，以为是没有问题的，大家一起跑，等要出现线程安全问题的时才开始控制。线程安全，性能较好。
        
        
        // 需求 1变量：100个线程，每个线程对其加 100 次
        Runnable target = new MyRunnable();
        
        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
        
        
    }
}

// 热观锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class BankAccount {
    private double balance;
    private Lock lock = new ReentrantLock();

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void withdraw(double amount) {
        lock.lock(); // 获取锁
        try {
            if (balance >= amount) {
                balance -= amount;
                System.out.println("Withdrawn: " + amount + ", New balance: " + balance);
            } else {
                System.out.println("Insufficient funds.");
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(100.0);

        Thread t1 = new Thread(() -> account.withdraw(50));
        Thread t2 = new Thread(() -> account.withdraw(70));

        t1.start();
        t2.start();
    }
}
陈逸轩*^_^*
关注
JUC详细笔记
leedoc的博客
11-05 879
此笔记根据黑马JUC课程整理 1.JUC概述 1.1什么是juc 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 线程和进程概念 1.进程和线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其
JAVA JUC学习笔记
GuoShao_的博客
07-22 1084
Java线程学习笔记
Java笔记-JUC基础
虽然但是
02-09 602
JUC
Java JUC 学习笔记
myc13381的博客
07-07 1012
Java JUC 多线程并发工具包学习
【狂神说Java】JUC笔记
2401_84407867的博客
04-20 966
整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
java JUC学习笔记
qq_36541478的博客
11-17 477
主要内容 1.Java JUC 简介 2.volatile 关键字-内存可见性 3.原子变量-CAS算法 4.ConcurrentHashMap 锁分段机制 5.CountDownLatch 闭锁 6.实现 Callable 接口 7.Lock 同步锁 8.Condition 控制线程通信 9.线程按序交替 10.ReadWriteLock 读写锁 11.线程八锁 12.线程池 13.线程调度 1...
JUC基础（周阳老师笔记
Xlaoer的博客
07-06 2195
目录一、JMM1.volatile2.加载代码练习：二、JUC基础1.什么是进程/线程，并发/并行进程/线程并发/并行2.线程的状态3.线程 操作 资源类4.Lambda表达式jdk8以后的interface5.判断/干活/通知6.防止虚假唤醒(while not if)7.标志位lock精准通知condition8.多线程八锁三、JUC集合类1.List2.set四、Callable接口五、强大的辅助类1.countDownLatch2.CyclicBarrier3.Semaphore六、Reentran
JUC基础学习笔记
muyi8888888的博客
01-09 969
JUC基础
Java JUC 笔记（2）
Hantou_crazy的博客
03-11 829
AutomicInteger：原子更新intAtomicLon：原子更新longAtomicBoolean：原子更新boolean//如果想实现i += 2这种操作，可以使用 addAndGet() 自由设置delta 值我们可以将int数值封装到此类中（注意必须调用构造方法，它不像Integer那样有装箱机制），并且通过调用此类提供的方法来获取或是对封装的int值进行自增。如何让传统线程容器安全？显而易见的我们可以使用关键字，但是这样效率太低了。
JUC笔记
wangshiqi666的博客
05-16 386
juc
JUC学习笔记（Java多线程）
07-04
本笔记将深入探讨JUC的相关知识点，帮助开发者理解并掌握Java多线程的核心概念。 首先，我们来了解一下Java线程。线程是程序执行的基本单元，允许多个任务在同一时间运行，从而提高了系统资源的利用率。在Java中，...
个人学习JUC代码笔记总集
07-27
这个压缩包文件“个人学习JUC代码笔记总集”显然是一个个人的学习资源，记录了对JUC组件的理解和应用实例，特别适合已经有一定Java基础，想要深入学习并发编程的开发者。 JUC的主要目标是简化并发编程，提高多线程...
【学习笔记】JUC基础基础程序
02-24
本学习笔记将深入探讨JUC的基础知识，帮助你理解和掌握Java并发编程的核心概念。 在Java中，多线程是实现并发的主要方式。一个线程是程序执行的一个流，多线程则意味着一个程序内可以同时执行多个线程。Java提供了...
JUC基础笔记（尚硅谷周阳JUC的笔记）
dogs的博客
08-02 2129
JUC概述卖票Lambda表达式 概述 juc就是 java.util.concurrent包的首字母 下面又分 并发包、 atomic 和 locks 包 也就是所谓的并发工具类 进程： 是程序的一次执行，拥有独立资源的单位 线程：轻量级线程，共享进程中的内存资源 ，程序调度和分配的基本单位， 更好的使程序并发的执行 并发： 是在程序在宏观上是并行， 实则是交替的执行 并行： 两个程序一起执行，同步执行。 在高内聚低耦合的前端下： 多线程编程的企业级套路 + 模板： * 线程 操作（对外暴露的调用方
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 417
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 526
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1229
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 793
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 322
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值