JUC 并发编程学习（1）

于 2020-12-01 18:38:06 发布
阅读量150 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44694641/article/details/110437173
版权

1. 什么是JUC

java.util 工具包、包、分类

业务：普通线程代码 Thread

Runnable 没有返回值、效率相比于Callable相对较低！

2. 线程和进程

线程、进程，如果不能使用一句话说出来的的基数，不扎实！

进程：一个程序，QQ.exe Music.exe 程序的集合 ；

一个进程往往可以包含多个线程，至少包含一个！

Java默认有两个线程：main线程 和 GC线程。

线程： 开了一个进程 Typora，写字，自动保存（线程负责）

对于Java而言：Thread、Runnable、Callable

Java真的可以开启线程嘛？ 不可以，只能通过本地方法（native），通过底层c++调用。

并发、并行

并发编程：并发（多线程操作同一个资源）、并行（多个人一起行走）。

  • CPU 一核，模拟出来多条线程。
  • CPU 多核，多个线程可以同时执行。线程池
	public static void main(String[] args) {
        // 获取CPU的核数
        // CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }

并发编程的本质：充分利用CPU的资源

2.1 线程有几个状态

六个状态：

 public enum State {
		// 新手
        NEW,
		// 运行
        RUNNABLE,
		// 阻塞
        BLOCKED,
		// 等待，死死的等待
        WAITING,
		// 超时等待
        TIMED_WAITING,
		// 终止
        TERMINATED;
    }

2.2 wait和sleep的区别

1、来自不同的类。

wait =》Object。
sleep =》Thread。

2、关于锁的释放

sleep 不会释放锁。
wait 会释放锁。

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

wait 必须在同步代码块中使用。
sleep 可以在任何地方睡。

3. Lock锁（重点）

Synchronized 本质就是排队，锁

真正的多线程开发，公司中的开发
线程就是一个单独的资源类，没有任何附属的操作！

  1. 属性
  2. 方法
package com.mango.demo01;

// 买票


public class Test01 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类
        final Ticket ticket = new Ticket();
        new Thread(()->{
            for(int i = 1; i<60;i++){
                ticket.sale();
            }
        },"a").start();
        new Thread(()->{
            for(int i = 1; i<60;i++){
                ticket.sale();
            }
        },"b").start();
        new Thread(()->{
            for(int i = 1; i<60;i++){
                ticket.sale();
            }
        },"c").start();

    }
}

// 资源类
class Ticket {
    // 属性、方法
    private int number = 50;
    // 卖票的方式
    public synchronized void sale(){
        if(number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第"+(number--)+"票，剩余"+number);
        }
    }
}

Lock

在这里插入图片描述

在这里插入图片描述
公平锁：十分公平：可以先来后到
非公平锁：十分不公平：可以插队（默认非公平）

Lock三部曲
  1. new ReentrantLock()
  2. lock.lock() 加锁
  3. lock.unlock() 解锁
package com.mango.demo01;

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

public class Test02 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类
        Ticket2 ticket = new Ticket2();
        new Thread(()->{for(int i = 1; i<60;i++)ticket.sale();},"a").start();
        new Thread(()->{for(int i = 1; i<60;i++)ticket.sale();},"b").start();
        new Thread(()->{for(int i = 1; i<60;i++)ticket.sale();},"c").start();


    }
}
// Lock
class Ticket2 {
    // 属性、方法
    private int number = 50;

    Lock lock = new ReentrantLock();

    // 卖票的方式
    public void sale(){

        lock.lock(); // 加锁
        try{
            if(number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第"+(number--)+"票，剩余"+number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

区别

  1. Synchornized 内置的java关键字，Lock 是一个Java类
  2. Synchornized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
  3. Synchornized 会自动释放锁，Lock 必须要手动解锁。如果不释放锁，死锁
  4. Synchronized 线程1（获得锁、阻塞）、线程2（等待，一直等待）；Lock锁不一定会一直等待下去。
  5. Synchronized 可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，可设置公平性。
  6. Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码。

锁是什么，如何判断锁的是谁！

生产者喝消费者问题
（1）Synchronized 版
package com.mango.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num + 1
 * B num - 1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) 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();
        }
        // 通知其他线程，我+1完毕了
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);

        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        if(number == 0){
           this.wait();
        }
        // 通知其他线程，我-1完毕了
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);

        this.notifyAll();
    }
}

问题：现在只有两个线程，如果有四个线程或者四个以上怎么办？
在这里插入图片描述
if 改为 while，防止虚假唤醒。

package com.mango.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num + 1
 * B num - 1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) 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();
        }
        // 通知其他线程，我+1完毕了
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);

        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        while(number == 0){
           this.wait();
        }
        // 通知其他线程，我-1完毕了
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);

        this.notifyAll();
    }
}
（1）JUC 版

任何一个新的奇数，绝对不是仅仅只是覆盖了原来的技术，肯定会有优势和补充！

Condition 可以精准的通知和唤醒线程
![在这里插入图片描述](https://img-blog.csdnimg.cn/20201201173538353.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY5NDY0MQ==,size_16,color_FFFFFF,t_70
代码实现：

package com.mango.pc;

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

/**
 * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num + 1
 * B num - 1
 */
public class C{
    public static void main(String[] args) {
        Data3 data = new Data3();
        
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) data.printA();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) data.printB();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
            try {
                for(int i = 0;i<10;i++) data.printC();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
    }
}

// 判断等待、业务、通知
class Data3{ // 数字 资源类
    private int number = 1;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void printA(){
        lock.lock();
        try{
            while (number != 1){
                condition.await();
            }
            number = 2;
            System.out.println(Thread.currentThread().getName() + "=>"+"A");
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try{
            while (number != 2){
                condition.await();
            }
            number = 3;
            System.out.println(Thread.currentThread().getName() + "=>"+"B");
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try{
            while (number != 3){
                condition.await();
            }
            number = 1;
            System.out.println(Thread.currentThread().getName() + "=>"+"C");
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    // 生产线：下单->支付->交易完成->物流   
}

4. 8锁状态

八锁，就是关于锁的八个问题：

  • 1、标准情况下，两个线程先打印哪个。 发短信还是打电话 ？ 1.发短信 2.打电话 答：1
  • 2、sendSms延迟4s情况下，两个线程先打印哪个。 发短信还是打电话 ？ 1.发短信 2.打电话 答：1
  • 原因： 锁的存在！被 synchronized 锁的对象是方法的调用者！两个方法用的是同一个锁，谁先拿到谁执行！

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class Phone{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}
  • 3、增加了一个普通方法，两个线程执行完，先发短信还是hello ? hello
  • 原因：hello() 没有锁，所以不受锁的影响。

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.hello();
        },"B").start();
    }
}

class Phone2{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    public void hello(){
        System.out.println("hello");
    }
}
  • 4、两个对象，两个同步方法？先执行什么？
  • 原因：两个对象、两个调用者，两把锁！
public class Test2 {
    public static void main(String[] args) {
        // 两个对象
        Phone2 phone = new Phone2();
        Phone2 phone1 = new Phone2();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
  • 5、增加两个静态的同步方法，只有一个对象，发短信、还是打电话？发短信
  • 6、两个对象！增加两个静态的同步方法，发短信还是打电话？ 发短信
  • 原因：static静态方法，Class类一加载就有了，所以他锁的是Class对象，即便是不同的对象，但是他锁的是Class。

public class Test3 {
    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        Phone3 phone1 = new Phone3();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}
class Phone3{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}
  • 7、一个静态同步方法、一个普通同步方法，先执行哪个？打电话
  • 8、一个静态同步方法、一个普通同步方法，两个对象先执行哪个？打电话
  • 原因：静态同步方法锁的是Class类，普通同步方法，锁的是对象，两个锁的不一样，看谁先执行完。
public class Test4 {
    public static void main(String[] args) {
        Phone4 phone = new Phone4();
        Phone4 phone1 = new Phone4();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}

class Phone4{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}
-Kk
关注
专栏目录
博客
前端知识点（面试可看） —— JS
01-04 1363
马上就要毕业啦，没有参加2023年的秋招，准备在最近开始找全职或者实习工作，然后也马上过年了，总结和理一下自己的知识要点，参加2024年的春招。
博客
前端知识点（面试可看）—— CSS篇
01-03 1020
马上就要毕业啦，没有参加2023年的秋招，准备在最近开始找全职或者实习工作，然后也马上过年了，总结和理一下自己的知识要点，参加2024年的春招。
博客
前端知识点（面试可看） —— HTML
01-03 1545
马上就要毕业啦，没有参加2023年的秋招，准备在最近开始找全职或者实习工作，然后也马上过年了，总结和理一下自己的知识要点，参加2024年的春招。
博客
把Canvas捡起来吧！
01-03 441
canvas是HTML5新增的一种新特性，一种使用JavaScript绘制图形的HTML元素。
博客
Docker 入门 ------容器互通以及Dockerfile
12-30 1692
本章节主要介绍了Docker容器如何进行互通，以及容器互通时需要注意的事项以及细节，然后详细的介绍了Dockerfile各个关键字的含义，以及如何使用，到这里Docker入门的章节就结束了，后面会有一个Docker实战篇。
博客
Docker 入门 ------ 基本命令
12-29 2540
本章主要描述了Docker的基本命令，包括镜像：创建、删除、标签等，并且如何从远程仓库拉取下来，容器的运行如何进入容器等。
博客
Docker入门 ------ 概念和安装
12-28 1352
本章主要讲解了Docker的背景、使用Docker的优势、和虚拟机的差别、核心概念是什么和如何在Centos中如何安装Docker。在下一章中我们将主要学习Docker中的命令。
博客
MEIS —— 前端部分基本配置
09-29 1573
这篇文章我们随着上一篇文章继续往下叙述，主要是将element和windicss等开发配置进项目中，以及基本的一些页面和组件给他完成。
博客
记录一个教学的交互式系统的开发 —— 环境搭建
09-28 1679
最近临近毕业，也到了毕业设计和找工作的时间了，所以就想着做一个开源项目，之前上课也不是很满意学校的教学系统，也就是，想着做一个可以记录学生学习记录和教师教学记录的平台，支持网页、桌面应用和小程序的项目。这个项目呢打算使用的技术栈：前端：vue3.0 + typescript + element plus + electron后端：golang + gin + gorm 项目名：Mango Education Interactive Service —— MEIS技术栈会有出入后面也会持续更新的。
博客
uni-app v-for循环 click无法传参解决方案
04-22 1万+
场景：循环后端数据数据控制子级是否显示<view :class="['inspect-item-wrap', !item.show ? 'collapse': '']" v-for="item in list_arr.attribute_values" :key="item.id"> <view class="item-show-wrap" @click="collapse(item)"> <text class="item-title">{{item.name}
博客
JUC 并发编程学习（4）
12-08 1414
1. JMM请你谈谈对Volatile的理解Volatile是Java虚拟机提供轻量级的同步机制。保证可见性不保证原子性禁止指令重排什么是JMMJVM：Java内存模型，不存在的东西，他是一个概念、约定。关于JMM的一些同步的约定：线程解锁前，必须把共享变量立刻刷回主存。线程枷锁前，必须读取主存中的最新值到工作内存中！加锁和解锁是同一把锁。线程：工作内存、主内存八种操作：内存交互操作　　　内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分
博客
JUC 并发编程学习（3）
12-04 226
1. 四大函数式接口（必须掌握）新时代程序员：lambda表达式、函数式接口、链式编程、Stream流式计算1.1 函数式接口@FunctionalInterfacepublic interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the threa
博客
JUC 并发编程学习（2）
12-03 168
1. ArrayList 多线程不安全在多条线程下，对同一个ArrayList执行add方法时，可能会报java.util.ConcurrentModificationException，即为并发修改时错误。解决方法有3种：List list = new Vector<>();List list = Collections.synchronizedList(new ArrayList<>());List list = new CopyOnWriteArrayList&lt
博客
Java 注解和反射
11-20 135
1. 注解（Annotation）一、作用可以被其他程序(比如：编译器等)读写不是程序本身，可以对程序做出解释。（这一点和注释没有区别）二、格式注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value="unchecked).三、例子public class Demo01 extends Object{ // @Override 重写的注解 @Override public String toString(
博客
Java 多线程学习（线程池和总结）
11-19 109
1. 线程池1.1 背景经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。1.2 思路提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的交通工具。1.3 好处提高响应速度（减少了创建新线程的时间）降低资源消耗（重复利用线程池中线程，不需要每次都创建）便于线程管理corePoolSize：核心池的大小maximumPoolSize：最大线程数keepAliveTime：线程没有任务时最多保持多长
博客
Java 多线程学习（线程通信——消费者和生产者）
11-19 236
线程通信假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止。如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止。这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件在生产者消费者问题中，仅有synchronized是不够的synchronized 可阻止并发更新同一个共享资
博客
Java 多线程学习（Lock锁）
11-19 132
Lock锁从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。ReentrantLock类实现了Lock，他拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是Reentran
博客
Java 多线程（死锁）
11-19 113
死锁多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有两个以上对象的锁时，就可能会发生“死锁”的问题。死锁可能发生的情况：package com.mango.deadlock;// 死锁：多个线程互相抱着对方需要的资源，然后形成僵持。public class DealLock { public static void main(String[] args) { Make
博客
Java 三种不安全线程及解决方案
11-19 244
1. 三种不安全线程1.1 List 集合package com.mango.syn;import java.util.ArrayList;import java.util.List;// 线程不安全的集合public class UnsafeList { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (
博客
Java 线程同步
11-18 107
Java 线程同步处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入synchronized 锁机制，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值