JUC学习笔记

最新推荐文章于 2024-04-18 14:31:12 发布
最新推荐文章于 2024-04-18 14:31:12 发布
阅读量339 收藏 1
点赞数 2
分类专栏： IDEA 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43709379/article/details/118658834
版权

JUC学习笔记

1.线程和进程

1.1进程：一个程序的集合

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

java默认2个线程 GC main

1.2 线程：

Thread Runnable Callable

**java不能开启线程,调用底层C++ **

    public synchronized void start() {
   
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
   
            start0();
            started = true;
        } finally {
   
            try {
   
                if (!started) {
   
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
   
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

1.3 并发

多线程操作同一个资源。

  • CPU 只有一核，模拟出来多条线程，天下武功，唯快不破。那么我们就可以使用CPU快速交替，来模拟多线程。
  • 并发编程的本质：充分利用CPU的资源！

1.4并行

并行： 多个人一起行走

  • CPU多核，多个线程可以同时执行。 我们可以使用线程池！

获取cpu的核数

public class Test01 {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

image-20210703115425667

1.5 线程的状态

源码

    public enum State {
     //新生
        NEW,

      // 运行
        RUNNABLE,

      // 阻塞
        BLOCKED,

  	// 等待 死死地等	
        WAITING,

   // 超时等待
        TIMED_WAITING,

      //终止
        TERMINATED;
    }

1.6 wait/sleep

1、来自不同的类

wait => Object

sleep => Thread

一般情况企业中使用休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

2、关于锁的释放

wait 会释放锁；

s

3、使用的范围是不同的

wait 必须在同步代码块中；

sleep 可以在任何地方睡；

4、是否需要捕获异常

wait是不需要捕获异常；

sleep必须要捕获异常；

2 Lock

2.1 不加synchronized

public class SaleTicketDemo01 {
   
    public static void main(String[] args) {
   
//        把资源类丢入线程
        Ticket ticket=new Ticket();

        /*
        * jdk1.7以前 匿名内部类
        *   new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();
        *
        * 1.8以后 lambda表达式 ()->{}
        * new Thread((参数)->{代码}).start();
        * */

//        new Thread(ticket::sale,"A").start();
//        new Thread(ticket::sale,"B").start();
//        new Thread(ticket::sale,"C").start();

        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"C").start();

    }
}
class Ticket{
   
    private int number=30;
    public  void sale(){
   
        if(number>0){
   
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number);

        }
    }
}

image-20210703133541937

2.2 解决多线程并发问题

2.2.1 加synchronized 关键字

synchronized 排队

public class SaleTicketDemo01 {
   
    public static void main(String[] args) {
   
//        把资源类丢入线程
        Ticket ticket=new Ticket();

        /*
        * jdk1.7以前 匿名内部类
        *   new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();
        *
        * 1.8以后 lambda表达式 ()->{}
        * new Thread((参数)->{代码}).start();
        * */

//        new Thread(ticket::sale,"A").start();
//        new Thread(ticket::sale,"B").start();
//        new Thread(ticket::sale,"C").start();

        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"C").start();

    }
}
class Ticket{
   
    private int number=30;
    public synchronized void sale(){
   
        if(number>0){
   
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number);

        }
    }
}

image-20210703133852915

2.2.2 Lock

公平锁： 十分公平，必须先来后到~；

非公平锁： 十分不公平，可以插队；(默认为非公平锁)

image-20210703143124198

package com.hu;

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

/**
 * @author HSL
 * QQ 1365343049
 * @CreateTime 2021/7/3 13:06
 **/
/*
* 线程是一个单独的资源类，没有任何附属的属性
* */
public class SaleTicketDemo02{
   
    public static void main(String[] args) {
   
//        把资源类丢入线程
        Ticket2 ticket=new Ticket2();

        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
   
            for (int i = 0; i < 40; i++) {
   
                ticket.sale();
            }
        },"C").start();

    }
}

class Ticket2{
   
    private int number=30;
    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();
        }
        if(number>0){
   
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张票，剩余"+number);

        }
    }
}

image-20210703143545211

2.2.3 Synchronized 与Lock 的区别

1、Synchronized 内置的Java关键字，Lock是一个Java类

2、Synchronized 无法判断获取锁的状态，Lock可以判断

3、Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁

4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。

5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；

6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；

锁是什么 如何判断锁得是谁

3 . 生产者和消费者的关系

package com.hu.productconsume;

/**
 * @author HSL
 * QQ 1365343049
 * @CreateTime 2021/7/3 14:52
 **/
/*
* 线程之间通信问题： 生产者消费者问题 等待唤醒 通知唤醒
* 线程交替进行 A B
*A num+1
*B num-1
* */
public class A {
   
    public static void main(String[] args) {
   
        Data data = new Data();

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

class Data {
   
    private int num = 0;

    // +1
    public synchronized void increment() throws InterruptedException {
   
        // 判断等待
        if (num != 0) {
   
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "=>" + num);
        // 通知其他线程 +1 执行完毕
        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
   
        // 判断等待
        if (num == 0) {
   
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "=>" + num);
        // 通知其他线程 -1 执行完毕
        this.notifyAll();
    }
}

image-20210703160528500

1）Synchronzied 版本

4. package com.marchsoft.juctest;

    /**

     * Description：
       *
     * @author jiaoqianjin
     * Date: 2020/8/10 22:33
       **/

    public class ConsumeAndProduct {
   
        public static void main(String[] args) {
   
            Data data = new Data();
            new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.increment();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                try {
   
                    data.decrement();
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        }, "B").start();
    }
   }

class Data {
   
    private int num = 0;// +1
public synchronized void increment() throws InterruptedException {
   
    // 判断等待
    if (num != 0) {
   
        this.wait();
    }
    num++;
    System.out.println(Thread.currentThread().getName() + "=>" + num);
    // 通知其他线程 +1 执行完毕
    this.notifyAll();
}

// -1
public synchronized void decrement() throws InterruptedException {
   
    // 判断等待
    if (num == 0) {
   
        this.wait();
    }
    num--;
    System.out.println(Thread.currentThread().getName() + "=>" + num);
    // 通知其他线程 -1 执行完毕
    this.notifyAll();
}

2）存在问题（虚假唤醒）

问题，如果有四个线程，会出现虚假唤醒

解决方式 ，if 改为while即可，防止虚假唤醒

结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。

这也就是为什么用while而不用if的原因了，因为线程被唤醒后，执行开始的地方是wait之后

    package com.marchsoft.juctest;

/**

 * Description：
   *
 * @author jiaoqianjin
 * Date: 2020/8/10 22:33
   **/

public class ConsumeAndProduct {
   
    public static void main(String[] args) {
   
        Data data = new Data();
        new Thread(() -> {
   
        for (int i = 0; i < 10; i++) {
   
            try {
   
                data.increment();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }, "A").start();
    new Thread(() -> {
   
        for (int i = 0; i < 10; i++) {
   
            try {
   
                data.decrement();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }, "B").start();
    new Thread(() -> {
   
        for (int i = 0; i < 10; i++) {
   
            try {
   
                data.increment();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }, "C").start();
    new Thread(() -> {
   
        for (int i = 0; i < 10; i++) {
   
            try {
   
                data.decrement();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }, "D").start();
}
    }

class Data {
   
    private int num = 0;
    // +1
public synchronized void increment() throws InterruptedException {
   
    // 判断等待
    while (num != 0) {
   
        this.wait();
    }
    num++;
    System.out.println(Thread.currentThread().getName() + "=>" + num);
    // 通知其他线程 +1 执行完毕
    this.notifyAll();
}

// -1
public synchronized void decrement() throws InterruptedException {
   
    // 判断等待
    while (num == 0) {
   
        this.wait();
    }
    num--;
    System.out.println(Thread.currentThread().getName() + "=>" + num);
    // 通知其他线程 -1 执行完毕
    this.notifyAll();
}

3）Lock版

   package com.marchsoft.juctest;

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

/**

 * Description：
   *
 * @author jiaoqianjin
 * Date: 2020/8/11 9:48
   **/

public class LockCAP {
   
    public static void main(String[] args) {
   
        Data2 data = new Data2(); new Thread(() -> {
   
        for (int i = 0; i < 10; i++) {
   

            try {
   
                data.increment();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }

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

class Data2 {
   
    private int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    // +1
    public  void increment() throws InterruptedException {
   
        lock.lock();
        try {
   
            // 判断等待
            while (num != 0) {
   
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            // 通知其他线程 +1 执行完毕
            condition.signalAll();
        }finally {
   
            lock.unlock();
        }
        }

// -1
public  void decrement() throws InterruptedException {
   
    lock.lock();
    try {
   
        // 判断等待
        while (num == 0) {
   
            condition.await();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "=>" + num);
        // 通知其他线程 +1 执行完毕
        condition.signalAll();
    }finally {
   
        lock.unlock();
    }

}
 }

4）Condition的优势

精准的通知和唤醒的线程！

如果我们要指定通知的下一个进行顺序怎么办呢？ 我们可以使用Condition来指定通知进程~

package com.marchsoft.juctest;

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

/**

 * Description：
 * A 执行完 调用B
 * B 执行完 调用C
 * C 执行完 调用A
   *
 * @author jiaoqianjin
 * Date: 2020/8/11 9:58
   **/

public class ConditionDemo {
   
    public static void main(String[] args) {
   
        Data3 data3 = new Data3();

        new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                data3.printA();
            }
        },"A").start();
        new Thread(()</
最低0.47元/天 解锁文章
爱上晨间阳光
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
JUC并发编程入门学习笔记（狂神说）
Free的午后
08-06 701
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 2. 线程和进程 进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位 一个进程往往可以包含多个线程，至少包含一个 1）进程 一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线..
狂神说笔记_全.zip
01-11
狂神说Java系列/从Java基础内容到微服务，分布式相关笔记，docker相关笔记
Juc并发编程学习笔记---狂神说（全）
ProGram_Java521的博客
10-31 1427
Juc并发编程学习笔记---狂神说（全）
Juc全网最全学习笔记【遇见狂神说】，华为面试题及答案java
最新发布
2401_84411593的博客
04-18 354
Lock ，可重入锁，可以 判断锁，非公平（可以自己设置）；不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁谁先执行！多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）；两个方法使用的是同一把锁，谁先拿到，谁先执行！来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态方法。| 移除 | remove() | poll() | take() | poll(,) || 添加 | add() | offer() | put() | offer(,) |
JUC多线程学习笔记--狂神说
qq_42760375的博客
07-02 1160
JDK11又把synchronized优化了，然后又让CopyOnWrite用上了synchronized。Vector用的是synchronized来同步，而CopyOnWrite用的lock来同步。5、Vector是1.0版发布的，ArrayList是1.2版本发布的。
个人学习笔记（狂神JUC笔记）
xiaobai_1hao的博客
12-28 566
JUC就是java.util下的工具包、包、分类等。是实现多并发，多线程的基本知识。
JUC学习笔记 .md
01-31
JUC学习笔记 .md
JUC学习笔记~~~~
03-18
JUC学习笔记，学习于狂神说JavaUp主
自学的JUC学习笔记.md
12-01
总结了个人自学的JUC学习笔记，个人主页可以查看的到。
狂神说JUC.pdf
05-02
Bilibili狂神老师的JUC课程笔记，讲的非常的好，希望大家结合视频学习狂神老师的JUC编程，精进自己的技术。
狂神JUC并发笔记大全+Linux等资料
08-07
狂神JUC并发笔记大全+Linux等资料
狂神说全部笔记内容.zip
08-26
笔记自我备份笔记自我备份笔记自我备份笔记自我备份
JUC学习笔记（Java多线程）
07-04
JUC学习笔记（Java多线程）
个人学习JUC代码笔记总集
07-27
个人学习的时候对JUC做的笔记，包括所有代码，学习视频是尚硅谷周阳老师的JUC，需要有一定的基础才能看懂，这是个人笔记，不一定适用于所有人，谢谢！
JUC并发编程狂神说笔记（超详细）
weixin_48412846的博客
06-27 6396
List item List item List item List item
【狂神学习笔记】JUC基础认识
weixin_45500506的博客
08-23 312
文章目录JUC并发编程（基础认识）1、什么是JUC2、线程和进程3、Lock锁（重点）4、生产者消费者5、synchronized锁对象和锁类6、线程不安全的类7、Callable8、常用辅助类8.1、CountDownLatch8.2、CyclicBarrier8.3、Semaphore9、读写锁10、阻塞队列11、线程池（重点）12、四大函数式接口13、Stream流式计算14、ForkJoin15、Volatile16、单例模式17、深入理解CAS18、原子引用Integer类型的坑19、各种锁的理解
狂神说juc笔记
m0_51654746的博客
09-06 1069
JUC就是java.util.concurrent包及其子包java默认有两个线程，一个是main线程，一个是GC线程对于java而言有三中开启线程的方式：Thread，Runnable，Callable，但是实际上并不是java开启的线程，调用的是底层的C++开启线程并发：多个线程操作同一个资源并行：多个线程同时进行,只有多核cpu才能并行java获取CPU核心数量 并发编程的本质：充分利用CPU的资源线程的状态：来自不同类，wait来自Object，sleep来自Thread企业中休眠使用的是TimeU
黑马juc并发编程md笔记
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同一个处理机上运行，而进程是程序加载到内存中运行起来的动态实例，负责加载指令、管理内存、管理IO等任务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱上晨间阳光

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值