Java笔记-JUC基础

已于 2023-03-05 14:57:45 修改
阅读量536 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言 jvm
于 2023-02-09 15:58:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ambition_ZM/article/details/128950792
版权
本文详细介绍了Java并发编程中的JUC工具包，包括线程的五种状态，wait和sleep的区别，以及如何使用synchronized和Lock进行线程间通信。同时，文章还探讨了生产者消费者问题的两种实现方式，并讲解了CountDownLatch、CyclicBarrier和Semaphore等并发辅助类的用途。最后，提到了读写锁的概念和应用。
摘要由CSDN通过智能技术生成

目录

1、什么是JUC

JUC指的是java.util三个并发编程工具包

  • java.util.concurrent
  • java.util.concurrent.atomic
  • java.util.concurrent.locks

2、线程的几种状态

public enum State{
	NEW,//新建
	RUNNABLE,//准备就绪，等待资源
	BLOCKED,//阻塞
	WAITING,//一直等待
	TIMED_WAITING,//超时等待，过时不候
	TERMINATED;//终止，线程已经完成执行
}

1） 新建

当用new关键字创建一个线程时，还没调用start 就是新建状态。

2） 就绪

调用了 start 方法之后，线程就进入了就绪阶段。此时，线程不会立即执行run方法，需要等待获取CPU资源。

3） 运行

当线程获得CPU时间片后，就会进入运行状态，开始执行run方法。

4） 阻塞

当遇到以下几种情况，线程会从运行状态进入到阻塞状态。

调用sleep方法，使线程睡眠。

调用wait方法，使线程进入等待。

当线程去获取同步锁的时候，锁正在被其他线程持有。

调用阻塞式IO方法时会导致线程阻塞。

调用suspend方法，挂起线程，也会造成阻塞。

需要注意的是，阻塞状态只能进入就绪状态，不能直接进入运行状态。因为，从就绪状态到运行状态的切换是不受线程自己控制的，而是由线程调度器所决定。只有当线程获得了CPU时间片之后，才会进入运行状态。

5） 死亡

当run方法正常执行结束时，或者由于某种原因抛出异常都会使线程进入死亡状态。另外，直接调用stop方法也会停止线程。但是，此方法已经被弃用，不推荐使用。
在这里插入图片描述
yield()方法：放弃，屈服，Thread.yield 方法会使当前线程放弃CPU时间片，把执行机会让给相同或更高优先级的线程。但是不释放锁资源
suspend()方法： 会使线程挂起，并且不会自动恢复，只有调用 resume 方法才能使线程进入就绪状态。注意，这两个方法由于有可能导致死锁，已经被废弃
Object.wait()：释放当前对象锁，并进入阻塞队列 Object.notify()：唤醒当前对象阻塞队列里的任一线程（并不保证唤醒哪一个）
Object.notifyAll()：唤醒当前对象阻塞队列里的所有线程

3、wait和sleep的区别

1、来自不同的类
wait来自Object类，任何对象实例都能调用
sleep来自Thread类，是Thread的静态方法
2、锁的释放
wait会释放锁
sleep不需要占用锁，不会释放锁
3、使用范围、捕获异常不同
wait:必须在同步代码块中使用，不需要捕获异常
sleep:可以在任何地方使用，必须捕获异常

4、线程间通信

4.1 生产者和消费者

生产者与消费者是java并发环境下常见的设计模式，一个线程负责生产数据，一个线程负责消费数据，两个线程同时去操作这个变量，但是这是两个相互互斥的操作。
步骤：
(1)创建资源类，在资源类中创建属性和方法
(2）资源类的方法
判断等待-》业务逻辑-》通知唤醒
（3）创建多个线程，调用资源类的方法
（4）防止虚假唤醒
线程操作资源类-》判断干活-》通知，while防止虚假唤醒
虚假唤醒：线程可以被唤醒，而不会被通知，中断或超时
因此等待应该总是出现在循环中，如果条件不满足，则继续等待

实现方式1-synchronized


public class Mythread2 {
    public static void main(String[] args) {
        Resource resource = new Resource();//资源类
        //生产者
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    resource.increment();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

            }
        },"producer").start();
        //消费者
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    resource.decrement();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        },"consumer").start();
    }
}

class Resource{
    int number=1;
    public synchronized void  increment() throws InterruptedException{
        while(number!=0){//判断
            this.wait();
        }
        number++;//干活
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException{
        while (number==0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
}

实现方式2-JUC-lock

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread3 {
}

class Resource1{
    private int number=0;
    Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();
    public void increment()throws InterruptedException{
        lock.lock();
        try{
            while (number!=0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException{
        lock.lock();
        try{
            while(number==0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=》"+number);
            condition.signalAll();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

lock方式与synchronized的区别

与synchronized的区别：
lock中的condition可以实现精准定位
如下示例，实现了线程顺序按照A-B-C的顺序执行

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread3 {
    public static void main(String[] args) {
        Resource1 resource1=new Resource1();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    for (int i=0;i<10;i++){
                        resource1.printA();
                    }
                }catch(InterruptedException e){
                    e.printStackTrace();
                }

            }
        },"A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    for (int i=0;i<10;i++){
                        resource1.printB();
                    }
                }catch(InterruptedException e){
                    e.printStackTrace();
                }

            }
        },"B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    for (int i=0;i<10;i++){
                        resource1.printC();
                    }

                }catch(InterruptedException e){
                    e.printStackTrace();
                }

            }
        },"C").start();
    }


}

class Resource1{
    private int number=1;
    Lock lock=new ReentrantLock();
    Condition condition1=lock.newCondition();
    Condition condition2=lock.newCondition();
    Condition condition3=lock.newCondition();
    public void printA()throws InterruptedException{
//        System.out.println(Thread.currentThread().getName()+"=>"+number);
        lock.lock();
        try{
            while (number!=1){
                condition1.await();
            }
            number=2;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition2.signalAll();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB()throws InterruptedException{
//        System.out.println(Thread.currentThread().getName()+"=>"+number);
        lock.lock();
        try{
            while (number!=2){
                condition2.await();
            }
            number=3;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition3.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC()throws InterruptedException{
//        System.out.println(Thread.currentThread().getName()+"=>"+number);
        lock.lock();
        try{
            while (number!=3){
                condition2.await();
            }
            number=1;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition1.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

5、常用的辅助类

（1）CountDownLatch-减法计数器

用给定的数字进行初始化，等待所有线程执行完（await），才进行下一步。使用countDown方法使当前计数器到0，之后所有等待线程被释放。一次性操作，无法重置计数，如果需要重置计数，可以使用CyclicBarrier。

import java.util.concurrent.CountDownLatch;

public class CountDownLanch1 {
    public static void main(String[] args) throws InterruptedException{
  //  倒计时 起始为6 必须要执行任务的时候，再使用!
        CountDownLatch countDownLatch=new CountDownLatch(6);
        for (int i=0;i<6;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"->线程");
                    countDownLatch.countDown();//计数器-1
                }
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//待计数器归零在向下执行
        System.out.println("线程全部执行完毕");
    }

}

在这里插入图片描述

2、CyclicBarrier(加法计数器)

线程加法，只有等到一定数量的线程都开启后，才进行下一步（执行run方法）
比如：集齐7颗龙珠，才能召唤神龙

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier=new CyclicBarrier(7,new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("集齐龙珠，召唤神龙");
            }
        }) );

        for(int i=1;i<=7;i++){
            final int temp=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "第" + temp + "颗龙珠");
                    try{
                        barrier.await();//等待
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            },String.valueOf(i)).start();
        }

    }
}

在这里插入图片描述

3、Semaphore(信号量)

计数信号量，允许优先的多线程去访问公共资源，如：6个车抢3个停车位
原理：
semaphore.acquire(); //获得，如果已经满了，等待，等待被释放为止！

semaphore.release(); // 释放，会将当前的信号量释放+1，然后唤醒等待的线程！

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

import java.sql.Time;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        //指定允许的线程数量：车位
        Semaphore semaphore = new Semaphore(3);
        for(int i=1;i<=6;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + "抢到车位");
                        TimeUnit.SECONDS.sleep(3);
                        System.out.println(Thread.currentThread().getName()+"离开车位");
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }finally {
                        semaphore.release();
                    }
                }
            },String.valueOf(i)).start();
        }
    }
}

在这里插入图片描述

4.读写锁

写锁：独占锁
读锁：共享锁
读写锁：一个资源可以被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程，读写互斥，读读是共享的

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache=new MyCache();
        //写线程
        for (int i=0;i<5;i++){
            final int temp=i;
            //写入
            new Thread(new Runnable() {
                @Override
                public void run() {
                    myCache.put(temp+"",""+temp);
                }
            },String.valueOf(i)).start();
        }
        //读线程
        for(int i=0;i<5;i++){
            final int temp=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("获取"+temp+"缓存数据=="+myCache.get(temp+""));
                }
            },String.valueOf(i)).start();
        }
    }
}

class MyCache{
    private volatile Map<String,Object> map=new HashMap<>();
    private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
    //写存
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();//写锁
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        try{
            TimeUnit.MILLISECONDS.sleep(200);
            map.put(key,value);
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();//写完释放锁
        }
        System.out.println(Thread.currentThread().getName() + "写入OK");
    }

    //读取
    public Object get(String key){
        readWriteLock.readLock().lock();//加读锁
        Object object=null;
        try{
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            object=map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取OK");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.readLock().unlock();//释放读锁
        }
        return object;
    }
}

在这里插入图片描述

参考文章：

线程的5个状态
JUC基础

MY Daisy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——JUC
12-29
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;包含下载地址
word源码java-ShangGuiGu-ZhouYang-JUC:周阳-juc
06-05
复习java基础知识的笔记 进程和线程: 进程和线程主要区别在于他们是操作系统不同的资源管理方式. 进程是程序的一次执行过程(运行中的程序),是系统运行程序的基本单位. 一个进程至少包含一个线程(main), 可以包含多个...
Java 之 JUC
weixin_34160277的博客
11-11 302
1. JUC 简介 在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中 的 Collection 实现等; 2. volatile 关键字 volatile 关键字: 当多个线程进行操作共享数据时,可以保证...
java并发编程 JUC-基础篇 快速入门
最新发布
制定持续可量化的目标，不断坚持。
07-05 1127
程序有指令与数据组成，指令要运行，数据要读写，就必须指令加载到CPU。数据加载到内容，指令运行需要用到磁盘。当一个程序被运行时，从磁盘加载这个程序的代码至内存，这时开启了一个进程。
JAVA JUC
cpqmdbwpxc的博客
03-03 357
文章目录JAVA JUC一、Volatile 关键字-内存可见性1、java线程的6种状态Thread.state：2、JAVA多线程：判断 干活 改标志位加唤醒通知（详见Thread.start()方法）3.一共两个线程（1）同步锁：synchronized关键字，使两个线程同步（2）Volatile关键字（3）Volatile与Scnchronized比较二、原子变量与CAS算法1、i ++...
java 中的 JUC
会飞的小蜗
06-15 426
文章目录什么是JUC？JUC包中常常用的到的有哪些？volatile 关键字 什么是JUC？ java5.0 提供了 java.util.concurrent,我们通常称他为JUC包，在本包中新增了一些我们并发编程中常用的一些类，用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中的 Collection 实现。 JUC包中常常用的到的有哪些？ volatile 关键字 volatile 关键字: 当多个线程进行操作共享数据时,可以保证内存中的数据是可见
个人学习-JUC-笔记
02-25
本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人学习者深入理解和掌握Java并发编程的核心知识。 1. **并发基础** - **线程与进程**：线程是程序执行的最小单位，进程则是资源分配的基本单位。了解它们的...
常见的Java笔试题-JVM-JUC-Core:JUCJVM核心知识点
06-02
JUC、JMM核心知识点笔记 尚硅谷周阳老师课程——笔记。 / / JUC知识点 JMM volatile关键字 可见性 原子性 有序性 哪些地方用到过volatile？ 单例模式的安全问题 CAS CAS底层原理 CAS缺点 ABA问题 AtomicReference ...
jvm-juc：jvm学习笔记
03-03
Java并发工具包（Java Concurrency Utilities，JUC）是Java提供的用于多线程编程的API，位于`java.util.concurrent`包下，大大简化了并发编程的复杂性。 1. Executor框架：核心接口Executor，用于执行任务。...
【学习笔记】JUC基础基础程序
02-24
本学习笔记将深入探讨JUC的基础知识，帮助你理解和掌握Java并发编程的核心概念。 在Java中，多线程是实现并发的主要方式。一个线程是程序执行的一个流，多线程则意味着一个程序内可以同时执行多个线程。Java提供了...
Java JUC
qq_42076531的博客
10-02 161
Java JUC 1 Java JUC简介 在 Java 5.0 提供了 java.util.concurrent （简称 JUC ）包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。 2 volatile 关键字-内存可见性 2.1 内存可见性 Java 内存模型规定，对于多个线程共享的变量，存储在主内存当中，每个线程都有自己独立的工
Java Juc学习笔记
weixin_30551963的博客
03-02 134
Java JUC 简介 在 Java 5.0 提供了 java.util.concurrent (简称JUC )包,在此包中增加了在并发编程中很常用的实用工具类,用于定义类似于线程的自定义子系统,包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等 volatile 关键字-内存可见性 内存可见性 内存可见性(...
java JUC学习笔记
qq_36541478的博客
11-17 460
主要内容 1.Java JUC 简介 2.volatile 关键字-内存可见性 3.原子变量-CAS算法 4.ConcurrentHashMap 锁分段机制 5.CountDownLatch 闭锁 6.实现 Callable 接口 7.Lock 同步锁 8.Condition 控制线程通信 9.线程按序交替 10.ReadWriteLock 读写锁 11.线程八锁 12.线程池 13.线程调度 1...
Java之JUC
tiankong_12345的博客
04-07 3263
目录 一、Java JUC 简介 二、volatile 关键字-内存可见性 1、概念：内存可见性 2、问题描述： 3、结果： 4、分析： 三、原子变量-CAS算法 1、概念：原子变量 2、问题：i++的原子性问题 3、结果：出现并发问题。 4、分析： 5、模拟CAS算法 四、ConcurrentHashMap 锁分段机制 1.简介 2、ConcurrentHashMa...
Java高并发核心编程(JUC)—线程详细笔记
Cheney的博客
05-22 857
超详细Java线程详情笔记！自己整理，排版简介！
Java高并发核心编程(JUC)—线程池详细笔记
Cheney的博客
05-22 1180
线程池：一个容纳多个线程的容器，容器中的线程可以重复使用，省去了频繁创建和销毁线程对象的操作降低资源消耗，减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务提高响应速度，当任务到达时，如果有线程可以直接用，不会出现系统僵死提高线程的可管理性，如果无限制的创建线程，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控线程复用，同一个线程可以被重复使用，来处理多个任务。
Java-JUC入门
Ymh_Sirius的博客
07-27 220
***一、线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。**二、线程池的体系结构负责线程的使用与调度的根接口*|--**ExecutorService子接口线程池的主要接口*|--ThreadPoolExecutor线程池的实现类*|--ScheduledExecutorService子接口负责线程的调度。...
java 并发包(JUC)(学习笔记)
Daring_X的博客
12-17 410
Java 高并发核心编程（学习笔记）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值