JavaSE之JUC基础

最新推荐文章于 2023-04-17 16:24:31 发布
最新推荐文章于 2023-04-17 16:24:31 发布
阅读量191 收藏
点赞数
分类专栏： JavaSE 文章标签： 多线程 并发编程 多进程 java juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46036165/article/details/106456661
版权

Juc并发编程

1、什么是JUC

JUC：Java原生的并发包，和一些常用的工具类！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ndmlujtt-1590912119920)(Juc并发编程课堂笔记.assets/image-20200301212335672.png)]

2、线程基础知识回顾

什么是进程和线程？

进程：idea.exe

线程：打字、自动保存…

一个进程可以包含多个线程，一个进程至少有一个线程！ Java程序至少有两个线程： GC、Main

并发、并行

并发：多个线程操作同一个资源，交替执行的过程！

并行：多个线程同时执行！只有在多核CPU下才能完成！

所以我们使用多线程或者并发编程的目的：提高效率，让CPU一直工作，达到最高处理性能！

线程有几种状态

线程有 6 种状态，面向源码学习！

public enum State {
    // java能够创建线程吗？ 不能！只能通过native调用本地方法实现
 	// 新建
    NEW,

    // 运行
    RUNNABLE,

    // 阻塞
    BLOCKED,

    // 等待
    WAITING,

    // 延时等待
    TIMED_WAITING,

    // 终止！
    TERMINATED;
}

wait/Sleep区别

1、类不同！

wait ： Obejct 类     Sleep Thread

在juc编程中，线程休眠怎么实现！Thread.Sleep
     // 时间单位
     TimeUnit.SECONDS.sleep(3);

2、会不会释放资源！

  • sleep：抱着锁睡得，不会释放锁！

  • wait ：会释放锁！

3、使用的范围是不同的；

wait 和 notify 是一组，一般在线程通信的时候使用！

sleep 就是一个单独的方法，在哪里都可以用！

4、关于异常;

sleep 需要捕获异常！

3、Lock锁

synchronized 传统的方式！

代码：

package com.coding.demo01;

// 传统的 Synchronized
// Synchronized 方法 和 Synchronized 块

/*
 * 1、架构：高内聚，低耦合
 * 2、套路：线程操作资源类，资源类是单独的
 */
public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        // 1、新建资源类
        Ticket ticket = new Ticket();

        // 2、线程操纵资源类
        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();


        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();

    }
}

// 单独的资源类，属性和方法！
// 这样才能实现复用！
class Ticket{

    private int number = 30;

    // 同步锁，厕所 =>close=>
    // synchronized 这是一个关键字
    public synchronized void saleTicket(){
        if (number>0){
            System.out.println(Thread.currentThread().getName() + "卖出第"+(number--)+"票，还剩:"+number);
        }
    }

}

问题：

Lock 锁

代码：

package com.coding.demo01;

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

/*
 * JUC之后的操作
 * Lock锁 + lambda表达式！
 */
public class Demo02 {
    public static void main(String[] args) {
        // 1、新建资源类
        Ticket2 ticket = new Ticket2();
        // 2、线程操作资源类 , 所有的函数式接口都可以用 lambda表达式简化！
        // lambda表达式 (参数)->{具体的代码}
        new Thread(()->{for (int i = 1; i <= 40 ; i++) ticket.saleTicket();},"A").start();
        new Thread(()->{for (int i = 1; i <= 40 ; i++) ticket.saleTicket();},"B").start();
        new Thread(()->{for (int i = 1; i <= 40 ; i++) ticket.saleTicket();},"C").start();

    }
}


// 依旧是一个资源类
class Ticket2{
    // 使用Lock，它是一个对象
    // ReentrantLock 可重入锁：回家：大门 (卧室门，厕所门...)
    // ReentrantLock 默认是非公平锁！
    // 非公平锁: 不公平 （插队，后面的线程可以插队）
    // 公平锁: 公平（只能排队，后面的线程无法插队）
    private Lock lock = new ReentrantLock();

    private int number = 30;

    public void saleTicket(){
        lock.lock(); // 加锁
        try {
            // 业务代码
            if (number>0){
                System.out.println(Thread.currentThread().getName() + "卖出第"+(number--)+"票，还剩:"+number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 解锁
        }

    }

}

Synchronized 和 Lock 区别

1、Synchronized 是一个关键字、Lock 是一个对象

2、Synchronized 无法尝试获取锁，Lock 可以尝试获取锁，判断；

3、Synchronized 会自动释放锁（a线程执行完毕，b如果异常了，也会释放锁），lock锁是手动释放锁！如果你不释放就会死锁。

4、Synchronized （线程A（获得锁，如果阻塞），线程B（等待，一直等待）；）lock，可以尝试获取锁，失败了之后就放弃

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dp5DJE2d-1590912119924)(Juc并发编程课堂笔记.assets/image-20200301220037357.png)]

5、Synchronized 一定是非公平的，但是 Lock 锁可以是公平的，通过参数设置；

6、代码量特别大的时候，我们一般使用Lock实现精准控制，Synchronized 适合代码量比较小的同步问题；

4、生产者消费者问题

面试手写题：单例模式、排序算法、死锁、生产者消费者

线程和线程之间本来是不能通信的，但是有时候我们需要线程之间可以协调操作：

Synchronized 普通版

package com.coding.demo01;

// Synchronized 版
/*
目的： 有两个线程：A  B ，还有一个值初始为0，
       实现两个线程交替执行，对该变量 + 1，-1；交替10次
 */
public class Demo03 {
    public static void main(String[] args) {
        Data data = new Data();

        // +1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        // -1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();


    }
}

// 资源类
// 线程之间的通信： 判断  执行  通知
class Data{

    private int number = 0;

    // +1
    public synchronized void increment() throws InterruptedException {
        if (number!=0){ // 判断是否需要等待
            this.wait();
        }
        number++; // 执行
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll(); //唤醒所有线程
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        if (number==0){ // 判断是否需要等待
            this.wait();
        }
        number--; // 执行
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll(); //唤醒所有线程
    }

}

四条线程可以实现交替吗？不能，会产生虚假唤醒问题！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fDRcxwrH-1590912119925)(Juc并发编程课堂笔记.assets/image-20200301221345082.png)]

注意if 和 while的区别：

package com.coding.demo01;

// Synchronized 版
/*
目的： 有两个线程：A  B ，还有一个值初始为0，
       实现两个线程交替执行，对该变量 + 1，-1；交替10次
       
传统的 wait 和 notify方法不能实现精准唤醒通知！
 */
public class Demo03 {
    public static void main(String[] args) {
        Data data = new Data();

        // +1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        // -1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();


    }
}

// 资源类
// 线程之间的通信： 判断  执行  通知
class Data{

    private int number = 0;

    // +1
    public synchronized void increment() throws InterruptedException {
        while (number!=0){ // 判断是否需要等待
            this.wait();
        }
        number++; // 执行
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll(); //唤醒所有线程
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        while (number==0){ // 判断是否需要等待
            this.wait();
        }
        number--; // 执行
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll(); //唤醒所有线程
    }

}

新版的写法 JUC 挂钩！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5EnyBF0s-1590912119929)(Juc并发编程课堂笔记.assets/image-20200301221901605.png)]
在这里插入图片描述

package JUC;

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

/*
实现线程交替执行！
主要的实现目标：精准的唤醒线程！
    三个线程：A B C
    三个方法：A p5  B p10   C p15 依次循环
 */
public class ConditionLearn {
    public static void main(String[] args){
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.print5();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Thread01").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.print10();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Thread02").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.print15();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Thread03").start();
    }
}

class Data{
    private int number = 1;

    private Lock lock = new ReentrantLock();

    //实现精准访问
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void print5() throws InterruptedException {
        lock.lock();
        try {
            //判断
            while (number != 1){
                condition1.await();
            }
            //执行
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number = 2;
            condition2.signal();//唤醒
        } finally {
            lock.unlock();
        }
    }
    public void print10() throws InterruptedException {
        lock.lock();
        try {
            //判断
            while (number != 2){
                condition2.await();
            }
            //执行
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number = 3;
            condition3.signal();//唤醒
        } finally {
            lock.unlock();
        }
    }
    public void print15() throws InterruptedException {
        lock.lock();
        try {
            //判断
            while (number != 3){
                condition3.await();
            }
            //执行
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            number = 1;
            condition1.signal();//唤醒
        } finally {
            lock.unlock();
        }
    }
}
Coder-michael
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java string转number_string转换成number
weixin_28917279的博客
02-21 6579
【百度分享】javascript中的数据类型最近对javascript型有些感想，想分3个部分和大家分享一下，先说说数据类型的分析：1. 数据类型javascript中包含6种数据类型：undefined、null、string、number、boolean和object。其中，前5种是原始数据类型，object是对象类型。obj...文章技术小美2017-11-14839浏览量JavaScrip...
Java并发编程JUC实践
wat1r的博客
04-16 120
王者荣耀开始游戏等待 10个玩家，10个线程，模拟加载等待的过程 import java.util.Arrays; import java.util.Random; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @author: Frank Cooper * @date: 202
Java——Java抽象类
weixin_30532759的博客
01-06 151
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。 ...
C++类型推断
m0_52152959的博客
11-06 216
类型推断 auto类型修饰符 在C++11以后，auto关键字能够用于类型推导。当声明语句中有初始化器时，auto能够根据对象的初始化器推断对象的数据类型。 例子： auto a = 123; // int auto b = 123l; // long auto c = 3.14; // double auto d = 3.14f; // float auto e = "Hello"; // const char * auto f = "Hello"s; // std::string auto g
深入理解java的泛型
程序那些事
05-07 9232
文章目录简介泛型和协变泛型在使用中会遇到的问题类型擦除要注意的事项总结 深入理解java的泛型 简介 泛型是JDK 5引入的概念，泛型的引入主要是为了保证java中类型的安全性，有点像C++中的模板。 但是Java为了保证向下兼容性，它的泛型全部都是在编译期间实现的。编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。这种就叫做类型擦除。编译器在编译的过程中执行类型检查来保证类型安全，但是...
细说 Java 泛型及其应用
weixin_33826268的博客
04-01 157
引出泛型 我们通过如下的示例，引出为什么泛型的概念。 public class Test { public static void main(String[] args) { List list = new ArrayList(); list.add("abc"); list.add(2); for (int i = 0;...
JUC实战必备-全是精华
weixin_43206491的博客
11-22 789
????JUC 简介 JAVA 在 1.5版本中引入了 java.util.concurrent工具包，JUC 就是它的简称，用于处理线程的工具包。 ????重温进程与线程 进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。 线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。 线程的状态 NEW：新建 RUNNABLE：准备就绪 BLOCKED：阻塞 WAITING：等待（不见不散） TIMED_WAITIN
python 01列表异或_Python编程思想（3）：数字及其相关运算
weixin_39657575的博客
11-20 175
李宁老师已经在「极客起源」 微信公众号推出《Python编程思想》电子书，囊括了Python的核心技术，以及Python的主要函数库的使用方法。读者可以在「极客起源」 公众号中输入 160442 开始学习，或点击「极客起源」公众号下方的「编程思想」 > 「Python编程思想」 菜单开始学习。----------------正文---------------Python 提供了三种数值类型：...
Java 序列化
weixin_33958366的博客
04-12 86
2019独角兽企业重金招聘Python工程师标准>>> ...
前端String 类型 转为number类型
weixin_43167662的博客
12-06 785
String
JDK中多线程之JUC集合的JDK源码解读配合大神的一起看，秒懂。
MRA__S__的专栏
03-02 2150
一、    “JUC集合”01之框架 1)  概要 之前，在"Java 集合系列目录(Category)"中，讲解了Java集合包中的各个类。接下来，将展开对JUC包中的集合进行学习。在学习之前，先温习一下"Java集合包"。本章内容包括： Java集合包 JUC中的集合类 2)  Java集合包 在“Java 集合系列01之 总体框架”中，介绍java集合的架构。主体内容包括Coll...
Java中，如何将字符串转为数字(StringToNumber)
热门推荐
isea_you's blog
10-01 9万+
很多事，只能回头看，不能回头走，不能留在身边，只能留在记忆里... 如何将一个字符串转换为一个数字？ 前提是这个字符串是数字的类型，如“123”；show you the code: package com.isea.java; public class Test { public static void main(String[] args) { String......
java String类和Number类常用方法
weixin_45437699的博客
07-02 277
java NUMER类和String类 常用方法
String转为Number
linminqin的专栏
09-26 1万+
Number number = NumberFormat.getInstance().parse(str);
Java并发工具合集JUC大爆发！！！
最新发布
BASK2312的博客
04-17 262
如果不足够小，就必须分割成两个子任务，每个子任务在调用invokeAll方法时，又会进入compute方法，看看当前子任务是否需要继续分割成孙任务，如果不需要继续分割，则执行当前子任务并返回结果。优先执行线程 ,用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景,一般用于数据的整理以及汇总，例如excel插入一样，等所有线程都插入完了，到达了屏障后，barrierAction线程开始进行保存操作，完成后，接下来由其他线程开始进行插入，然后到达屏障接着就是保存，不断循环。
Java 并发编程(一)-JUC
杀神lwz的博客
04-02 526
​ 一、概述 JUC就是java.util.concurrent工具包的简称，这是一个处理线程的工具包，JDK1.5开始出现的。 管程：又称Monitor监视器，又是锁：是一种同步的机制，保证同一时间，只有一个线程访问被保护的数据或代码。 用户线程：自定义线程基本都是用户线程。通过Thread.currentThread().isDaemon()来判断是否是用户线程，等于 false是用户线程。等于true 是守护线程。 守护线程：特殊线程，运行在后台，比如：垃圾回收 设置守护线程： 线程.set
JUC
weixin_42061487的博客
08-20 216
如何了解JUC 源码 + 官方文档（面试高频问 java.util 工具包，分类 Runnable 没有返回值，效率相比Callable相对较低 java默认有两个线程； Java本身不能开启线程 public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads creat
【JavaSE】之JUC并发编程（上）
小新要变强的博客
10-12 2287
Java基础之JUC并发编程详解，通俗易懂~
JUC学习笔记
技术宇宙
11-23 399
目录前言一些概念JUC进程与线程并发（concurrent）与并行（parallel）低耦合高内聚Synchronizedthread.start();线程执行start方法的顺序并不代表线程的启动顺序wait和sleep多线程八锁情况一：synchronized情况二：sleep情况三：普通方法情况四：多资源类情况五：static情况六：多资源类与static（对比情况四）情况七：1个普通同步方法，1个静态同步方法情况八：1个普通同步方法，1个静态同步方法，多个资源类总结Interface Locksyn

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值