java_JUC

最新推荐文章于 2022-04-02 13:51:20 发布
最新推荐文章于 2022-04-02 13:51:20 发布
阅读量268 收藏
点赞数
分类专栏： java  基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39436556/article/details/117605677
版权

什么是JUC

在这里插入图片描述
java.util 工具包
包:为了分类

业务：普通的线程 Thread
Runnable 没有返回值，效率相比入Callable 相对较低！，在企业级开发中用的相对较少！
在这里插入图片描述

在这里插入图片描述

2.线程和进程

线程，进程，如果不能使用一句话说出来的技术，不扎实

进程：一个程序，比如QQ.EXE,Music.exe, 程序的集合 .jar
一个进程往往可以包含多个线程，至少包含一个！
java 默认有几个线程? 2 个，main线程，GC 线程
线程：开了一个进程Typora,写字，自动保存（线程负责的）
对于 java 而言：Thread ，Runnable ，Callable
java 可以开启线程吗？
开不了的，调用的是底层的C++，java 无法操作硬件，他是运行在虚拟机上的

  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. CPU一核，莫里出来多条线程，天下武功，为快不破，快速交替
    并行（多个人一起行走）
    2.CPU 多核，多个线程可以同时执行：要获取最好性能那么就要获取线程池。

package com.kuang.thread;
public class Test1 {

    public static void main(String[] args) {
        //获取CPU 的核数
        //CPU 密集型，IO 密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU 的资源
所有的公司都很看重！
企业，挣钱，=>提高效率，裁员，找一个厉害的人，顶替三个不怎么样样的人；

线程有几个状态
6 种状态
//赋值线程状态
Thread.State state = Thread.State.NEW;

 public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
         //新生
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
         //运行
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
         //阻塞
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
         //等待，死死的等
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
         //超时等待
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        //终止
        TERMINATED;
    }

wait/sleep 区别

1. 来自不同的类
wait => Object
sleep =>Thread

2. 关于锁的释放
wait 会释放锁，sleep 睡觉了，抱着锁睡觉，不会释放！

3.使用的方位是不同的
wait wait必须在同步代码块中

sleep 可以再任何地方睡，

4.是否需要捕获异常
wait 需要是捕获异常 中断异常
sleep 必须要捕获异常

3.Lock 锁（重点）

传统 Synchronized

普通的多线程实现方式

package com.kuang;


/**
 * 普通的多线程实现方式
 */
public class SaleTicketDemo02 {
    /**
     * 接口实现
     * @param args
     */
    public static void main(String[] args) {
        new Thread(new B()).start();
    }
}

/**
 * class B 接口实现Runnable 接口
 */
class  B implements Runnable{

    @Override
    public void run() {
        System.out.println("test 类");
    }
}
输出结果:
test 类

正常公司使用的多线程：

package com.kuang;


//基本的卖票例子

/**
 * 真正的多线程开发，公司中的开发,降低耦合性
 * 线程就是一个单独的资源类,没有任何附属的操作！
 * 1.属性,方法
 */
public class SaleTicketDemo01 {


    public static void main(String[] args) {
        //并发:多线程操作同一个资源类，把资源类丢入线程
        Ticket ticket = new Ticket();

        //@FunctionInterface 函数式接口, jdk1.8 lambda 表达式（参数）->{代码}

        //并发: 多线程操作一个资源类,三个线程操作同一资源
        new Thread(()->{
            for (int i = 0; i <60 ; i++) {
                ticket.sale();
            }
        },"A").start();

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

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


    }
}

// 资源类 OOP编程
class Ticket{

   //属性,方法
   private int number =30;

    //卖票的方式
    // synchronized 本质:队列,锁
    //锁是锁对象，和Class 
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+number--+"票,剩余"+number);

        }
    }
    
}

输出结果：
A卖出了第30票,剩余29
B卖出了第29票,剩余28
B卖出了第28票,剩余27
B卖出了第27票,剩余26
B卖出了第26票,剩余25
B卖出了第25票,剩余24
B卖出了第24票,剩余23
B卖出了第23票,剩余22
B卖出了第22票,剩余21
B卖出了第21票,剩余20
B卖出了第20票,剩余19
B卖出了第19票,剩余18
B卖出了第18票,剩余17
B卖出了第17票,剩余16
B卖出了第16票,剩余15
B卖出了第15票,剩余14
B卖出了第14票,剩余13
B卖出了第13票,剩余12
B卖出了第12票,剩余11
B卖出了第11票,剩余10
B卖出了第10票,剩余9
B卖出了第9票,剩余8
B卖出了第8票,剩余7
B卖出了第7票,剩余6
B卖出了第6票,剩余5
B卖出了第5票,剩余4
B卖出了第4票,剩余3
B卖出了第3票,剩余2
B卖出了第2票,剩余1
B卖出了第1票,剩余0

如学生打饭排队，一对一服务，需要排队一个一个来，不然一起上前很混乱，如图：
在这里插入图片描述

LOCK 加锁跟解锁

在这里插入图片描述

在这里插入图片描述
公平锁：十分公平: 可以先来后到
非公平锁:十分不公平：可以插队(默认) 假如一个进程3s ,一个进程3h ，那可肯定先执行3s 的。

synchronized 全自动的，Ticket 手动的

下面是Lock 上锁

package com.kuang;


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

public class SaleTicketDemo03 {


    public static void main(String[] args) {
        //并发:多线程操作同一个资源类，把资源类丢入线程
        Ticket ticket = new Ticket();

        //@FunctionInterface 函数式接口, jdk1.8 lambda 表达式（参数）->{代码}

        //并发: 多线程操作一个资源类,三个线程操作同一资源
        new Thread(()->{ for (int i = 0; i <60 ; i++) ticket.sale();},"A").start();
        new Thread(()->{ for (int i = 0; i <60 ; i++) ticket.sale();},"B").start();
        new Thread(()->{ for (int i = 0; i <60 ; i++) ticket.sale();},"C").start();


    }
}

// Lock 锁 三部曲
//1.new ReentrantLock();
//2.lock.lock()加锁
//3.finally=>lock.unlock();解锁
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(); //解锁
        }
    }
}

Lock 锁与Sycronized 有什么区别了。

  1. Synchronized 是内置的java 关键字，Lock 是一个类
  2. Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到锁
  3. Synchronized 会自动释放锁（a线程执行完会释放锁， b线程即使抛出异常也会释放锁 ），Lock 必须要手动会释放！，如果不释放锁，会死锁
  4. Synchronized 线程1（获得锁，阻塞），线程2（等待，傻傻的等）;Lock 锁就不一定会等下下去了（ lock.tryLock();//尝试获取锁）
  5. Synchronized 可重入锁，不可能中断的，非公平；Lock 可重入锁，可以中断锁（lock.unlock();），默认非公平（可以自己设置）
  6. Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的代码同步！

锁是什么，如何判断锁的是谁！
//Synchronized 锁的对象是方法的调用者
现在sleep 都这么调用：
TimeUnit.SECONDS.sleep(1);

生产者和消费者问题

面试：单例模式，排序算法，生产者和消费者，死锁
Synchronized wait notify 老版
juc lock 新版的

生产者和消费者问题Synchronized 版

package com;

/**
* 线程之间的通信问题：生产者和消费者问题! 等待唤醒, 通知唤醒
* 线程交替执行 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(() -> {
           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 number = 0;

   //+1
   public synchronized void increment() throws InterruptedException {
       if (number != 0) {
           //等待操作
           this.wait();
       }
       number++;
       System.out.println(Thread.currentThread().getName() + "=>" + number);
       //通知其他线程，我+1 完毕了
       this.notifyAll();//唤醒
   }

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

问题存在，A,B,C,D 线程 ！虚假唤醒
在这里插入图片描述
if 改为 while 判断，如果用if 会有虚假唤醒（if 不会停，就继续往下走），会输出number =2 ,用while 将正确输出结果，所以要用while 防止虚假唤醒。

代码如下:

package com;

/**
 * 线程之间的通信问题：生产者和消费者问题! 等待唤醒, 通知唤醒
 * 线程交替执行 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(() -> {
            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.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }


}

// 判断等待，业务，通知
class Data { //数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            //等待操作  
            System.out.println(Thread.currentThread().getName() + "wait=>" + number);
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，我+1 完毕了
        this.notifyAll();//唤醒
    }

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


}

输出结果:
A=>1
Await=>1
B=>0
Bwait=>0
A=>1
Await=>1
B=>0
Bwait=>0
A=>1
Await=>1
B=>0
Bwait=>0
C=>1
Cwait=>1
B=>0
Bwait=>0
A=>1
Await=>1
B=>0
Bwait=>0
C=>1
Cwait=>1
B=>0
Bwait=>0
D=>1
Dwait=>1
Await=>1
B=>0
Bwait=>0
C=>1
Cwait=>1
B=>0
Bwait=>0
A=>1
Await=>1
Dwait=>1
B=>0
Bwait=>0
C=>1
Cwait=>1
B=>0
D=>1
Dwait=>1
Await=>1
Cwait=>1

偶像java练习生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java_JUC_Study:java.util.concurrent代码示例学习
03-09
Java_JUC_Study:java.util.concurrent代码示例学习
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_源码、课件　·1. 尚硅谷_JUC线程高级_volatile 关键字与内存可见性 ·2. 尚硅谷_JUC线程高级_原子变量与 CAS 算法 ·3. 尚硅谷_JUC线程高级_模拟 CAS 算法 ·4. 尚硅谷_JUC线程高级_同步容器类...
推荐几个硬核 Java 学习网站
程序员cxuan的个人主页
07-05 3861
推荐几个非常不错的 Java 学习网站 LearnJava 在线 这是一个非常不错的学习 Java 的在线网站，纯免费。这是一个个人项目，旨在通过简单有效的在浏览器中进行练习让你快速掌握 Java 编程语言。通过直接从网络浏览器运行实际代码，你无需在本地安装和执行代码就可以尝试编码，这无疑提高了编程效率和上手效率。 你可以根据目录进行练习，有基础部分和高级部分，首先有例子代码，告诉你需要注意的事项以及详细的讲解，旨在把你教会后再让你进行练习。 下面就是练习部分，练习部分没有固定在底部边框，可以自由滑动，能
juc是什么java_JUC简介
weixin_36422050的博客
02-26 1071
JUC是什么JUC是在Java 5.0添加的java.util.concurrent包的简称，目的就是为了更好的支持高并发任务，让开发者利用这个包进行的多线程编程时可以有效的减少竞争条件和死锁线程。JUC的结构1，tools(工具类)：又叫信号量三组工具类，包含有1)CountDownLatch(闭锁)是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待2)...
java_juc_AQS
JESSE_ZHAO_503的专栏
03-28 550
深入浅出 Java Concurrency (7): 锁机制 part 2 AQS 《深入浅出 Java Concurrency》目录 AQS的原理浅析 | 并发编程网 - ifeve.com 完整的设计原理可以参考Doug Lea的论文 The java.util.concurrent Synchronizer Framework ，这里做一些简要的
java juc 包_JUC java并发包
weixin_40007668的博客
02-13 355
1. JUC 简介在 Java 5.0 提供了java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类,用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中的 Collection 实现等;JUC包JUC提供的一些实现：Atomic : AtomicInteger 原子操作类Locks : Lock,...
java_juc_同步工具集
JESSE_ZHAO_503的专栏
03-22 574
http://www.cnblogs.com/whgw/archive/2011/09/29/2195669.html Java之CyclicBarrier使用 CyclicBarrier介绍--统计全国的业务数据--多次集合 Java线程之CyclicBarrier
Java - JUC详解
S mile0804的博客
04-02 5237
一、概述 1.1 什么是JUC？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 1.2 什么是进程？ 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。在指令运行过程中还要用到磁盘、网络等设备。进程就是用来加载指令，管理内存管理IO的。 当一个进程被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为一个实例。
juc是什么java_java juc是什么?javajuc讲解
weixin_39964590的博客
02-26 604
你知道java中的juc是什么意思吗?很多人表示对于java juc不是很了解，那么下面的文章就特地对此做了一下详细的介绍，一起来看看详情。JUC就是java.util.concurrent包，俗称java并发包，是Java开发工程师学习并发的时候需要掌握的内容。主要内容如图所示：在Java 5.0提供了java.util.concurrent (简称JUC)包，在这个包当中，增加了在并发编程中很...
java--JUC快速入门（彻底搞懂JUC）
热门推荐
weixin_43888181的博客
05-08 9万+
java–JUC快速入门（彻底搞懂JUC） 文章目录java--JUC快速入门（彻底搞懂JUC）1、学习多线程之前需要知道的一些概念。2、JUC的结构3、Lock锁(重点)4、集合类不安全5、Callable()6、常用的辅助类7、读写锁8、阻塞队列9、线程池 1、学习多线程之前需要知道的一些概念。 1.1 JUC是什么？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
SpringBoot_JUC工具使用
Myron_007的博客
02-18 608
文章目录前言Semaphore[信号量]示例--控制耗时任务执行的线程数CountDownLatch[倒计时器]示例--并发加载缓存 前言 记录springboot项目环境下JUC工具的使用场景 Semaphore[信号量] 信号量，用来限制能同时访问共享资源的线程上限 示例–控制耗时任务执行的线程数 /** * 控制耗时任务执行的线程数 */ @Api(tags = "Semaphore测试") @RestController @RequestMapping("/semaphore/test")
1_JUC概述
root_zhb的博客
09-15 108
JUC概述1、什么是JUC2、线程和进程概念2.1、进程与线程2.2、JAVA线程的状态2.3、wait和sleep2.4、并发和并行2.5、管程2.6、用户线程和守护线程 1、什么是JUC JUC是java.util .concurrent 工具包的简称，这是一个处理线程的工具包，可以实现多线程高并发的内容 2、线程和进程概念 2.1、进程与线程 进程（Process）：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。 线程（Thread）：系统分配处理器时间资源的基
尚硅谷Java视频_JUC视频教程
02-06
尚硅谷Java视频_JUC 视频教程
08尚硅谷_JUC.docx
07-22
·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse和IDEA这两种企业一线开发环境都使用到了 3.技术讲解更深入、更全面： ·课程共30天，715个知识视频小节，涉及主流Java使用的...
JVM_JUC_Demo:练习案例
03-17
JVM_JUC_Demo
ForkJion
weixin_39436556的博客
06-14 9382
ForkJoin 什么是ForkJoin ForkJion 在JDK1.7,并行执行任务！提高效率。大数据量！ 大数据：Map Reduce(将大任务拆分为小任务) ForkJion 特点：工作窃取 这个里面维护的都是双端队列，A 线程没有执行完，B线程执行完了，B 线程则去 执行A 中的（红框）未执行完任务 ForkJion 代码案例： package com.forkjoin; import java.util.concurrent.ExecutionException; imp
java四大函数式接口（重点，简单）
weixin_39436556的博客
06-14 2341
四大函数式接口 新时代的程序员：lambda 表达式，链式编程，函数式接口，Stream 流式计算 函数式接口： 只有一个方法的接口 @FunctionalInterface public interface Runnable { public abstract void run(); } //超级多FunctionalInterface //简化编程模型，在新版本的框架底层大量应用! //foreach(消费者类型的函数式接口) 代码测试: Function 函数式接口 pack
java_异步回调
weixin_39436556的博客
06-15 2196
异步回调 Future 设计的初衷：对将来的某个时间的结果进行建模 代码示例 package com.future; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; /** * * 异步调用:Ajax *
java_父类
weixin_39436556的博客
05-18 1281
继承 子类构造器中默认调用父类构造器 super(); 重写 需要有继承关系，子类重写父类的方法 方法名必须相同 参数列表必须相同 修饰符，范围可以扩大： public ->Protected>defaule ->private 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大) 重写,子类的方法和父类必要一致；方法体不同！ 为什么需要重写： 1.父类的功能，子类不一定需要，或者不一定满足! 代码如下：
java的juc编程
最新发布
09-29
JUC是指Java并发编程中的java.util.concurrent包，它提供了一系列新的关于并发操作的类，可以极大地方便我们实现并发编程。Java并发编程是基于多线程技术的一种编程技术，旨在解决资源利用率、响应速度和线程安全等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值