JUC并发编程--------基础篇

最新推荐文章于 2024-07-13 15:22:03 发布
最新推荐文章于 2024-07-13 15:22:03 发布
阅读量839 收藏 2
点赞数 1
分类专栏： JAVA---并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/promise_j_z/article/details/132571776
版权

一、多线程的相关知识

栈与栈帧

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟 机就会为其分配一块栈内存。 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换

上下文切换可以更详细地描述为内核(即操作系统的核心)对CPU上的进程(包括线程)执行以下活动:

1. 暂停一个进程的处理，并将该进程的CPU状态(即上下文)存储在内存中的某个地方

2. 从内存中获取下一个进程的上下文，并在CPU的寄存器中恢复它

3. 返回到程序计数器指示的位置(即返回到进程被中断的代码行)以恢复进程。

从数据来说，以程序员的角度来看， 是方法调用过程中的各种局部的变量与资源； 以线程的角度来看， 是方法的调用栈中存储的各类信息。

引发上下文切换的原因一般包括：线程、进程切换、系统调用等等。上下文切换通常是计算密集型的，因为涉及一系列数据在各种寄存器、 缓存中的来回拷贝。就CPU时间而言，一次上下文切换大概需要5000~20000个时钟周期，相对一个简单指令几个乃至十几个左右的执行时钟周期，可以看出这个成本的巨大。

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

  • 线程的 cpu 时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch（上下文切换） 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念 就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等 Context Switch 频繁发生会影响性能

并行于并发

  • 并行Parallel：在同一时刻，有多个指令在多个CPU上同时执行。
  • 并发Concurrent：在一段时间内，有多个指令在单个CPU上交替执行。

进程和线程的区别

  • 进程：是正在运行的程序
  1. 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
  2. 动态性：进程的实质程序的一次执行过程，进程是动态产生，动态消亡的
  3. 并发性：任何进程都可以同其他进程一起并发执行
  • 线程：是进程中的单个顺序控制流，是一条执行路径
  1. 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  2. 多线程：一个进程如果有多条执行路径，则称为多线程程序

线程状态介绍

  •  当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程状态被定义在了java.lang.Thread.State枚举类中

State枚举类的源码如下：

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 
​
        /* 可运行状态 */
        RUNNABLE , 
​
        /* 阻塞状态 */
        BLOCKED , 
​
        /* 无限等待状态 */
        WAITING , 
​
        /* 计时等待 */
        TIMED_WAITING , 
​
        /* 终止 */
        TERMINATED;
    
    }
    
    // 获取当前线程的状态
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}

通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下

线程状态具体含义
NEW一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED一个完全运行完成的线程的状态。也称之为终止状态、结束状态

各个状态的转换，如下图所示：

情况 1 NEW --> RUNNABLE

当调用 t.start() 方法时，由 NEW --> RUNNABLE

情况 2 RUNNABLE <--> WAITING

t 线程用 synchronized(obj) 获取了对象锁后 调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING ，调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时 竞争锁成功，t 线程从WAITING -->RUNNABLE ，竞争锁失败，t 线程从WAITING --> BLOCKED

情况 3 RUNNABLE <--> WAITING

当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING ，注意是当前线程在t 线程对象的监视器上等待 t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE

情况 4 RUNNABLE <--> WAITING

当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING 调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING -->

RUNNABLE

情况 5 RUNNABLE <--> TIMED_WAITING

t 线程用 synchronized(obj) 获取了对象锁后 调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING ，t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时 ，竞争锁成功，t 线程从TIMED_WAITING --> RUNNABLE ，竞争锁失败，t 线程从

TIMED_WAITING --> BLOCKED

情况 6 RUNNABLE <--> TIMED_WAITING

当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING

注意是当前线程在t 线程对象的监视器上等待 ，当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 TIMED_WAITING --> RUNNABLE

情况 7 RUNNABLE <--> TIMED_WAITING

当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING

当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

情况 8 RUNNABLE <--> TIMED_WAITING

当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线 程从 RUNNABLE --> TIMED_WAITING ，调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从 TIMED_WAITING--> RUNNABLE

情况 9 RUNNABLE <--> BLOCKED

t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从RUNNABLE --> BLOCKED

持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED的线程重新竞争，如果其中 t 线程竞争 成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

情况 10 RUNNABLE <--> TERMINATED

当前线程所有代码运行完毕，进入 TERMINATED

二、创建线程的几种方式

继承Thread类

方法介绍：

实现步骤：

  1. 定义一个类（MyThread），继承Thread类
  2. 在MyThread类中实现run()重写
  3. 创建MyThread类对象
  4. 启动线程，调用start()放法

代码实现：

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
​
        my1.start();
        my2.start();
    }
}

实现Runnable接口

实现步骤：

  1. 定义一个类（MyRunnable），实现Runnable接口
  2. 在MyRunnable类中重写run()方法
  3. 创建MyRunnable类对象
  4. 创建Thread对象，将创建的MyRunnable类作为Thread对象构造方法的参数传入
  5. 调用Thread对象的start()方法

代码实现：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
​
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");
​
        //启动线程
        t1.start();
        t2.start();
    }
}

实现callable接口

方法介绍：

实现步骤：

  1. 创建一个类(MyCallable)实现Callable接口
  2. 重写Callable中的call()方法
  3. 创建MyCallable对象
  4. 创建Future实现类FutureTask对象，把Mycallable作为构造方法的参数
  5. 创建Thread对象，把FutureTask作为构造方法的参数
  6. 启动Thread线程，调用start()方法
  7. 调用FutureTask的get()方法，获取Mycallable的返回值，get方法会一直等待线程执行完获取结果，必须要放在start后面，否则会一直等待

代码实现：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();
​
        //Thread t1 = new Thread(mc);
​
        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);
​
        //创建线程对象
        Thread t1 = new Thread(ft);
        //开启线程
        t1.start();
​
        String s = ft.get();//该方法会一直等到线程执行完获取返回值，否则会一直等待，所以要放在start方法后面
        System.out.println(s);
    }
}

三种创建方式的区别

实现Runnable、Callable接口的的优点：

  • 好处：扩展性强，实现该接口的同时，还可以继承其他类
  • 缺点：编程相对复杂，不能直接调用Thread类方法

继承Thread类：

  • 好处：编程相对简单，可以直接调用Thread类方法
  • 缺点：可以拓展性较差，不能再继承其他类

Runnable和Callable的区别：

  • Runnable规定的方法是run(),Callable规定的方法
  • Runnable的run()方法不能抛出异常，而Callable的call()方法可以抛出异常
  • Runnable执行完毕后没有返回值，而Callable执行完毕后有返回值
  • Callable可与通过Future的实现类FutureTask的get()方法计算返回值

Thread和Runnable的区别：

Thread才是Java里对线程的唯一抽象，Runnable只是对任务（业务逻辑）的抽象。Thread可以接受任意一个Runnable的实例并执行。

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了FutureTask。FutureTask类实现了RunnableFuture接口，RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。因此我们通过一个线程运行Callable，但是Thread不支持构造方法中传递Callable的实例，所以我们需要通过FutureTask把一个Callable包装成Runnable，然后再通过这个FutureTask拿到Callable运行后的返回值。

新启线程有几种方式？

这个问题的答案其实众说纷纭，有2种，3种，4种等等答案，建议比较好的回答是：

按照Java源码中Thread上的注释：

官方说法是在Java中有两种方式创建一个线程用以执行，一种是派生自Thread类，另一种是实现Runnable接口。

当然本质上Java中实现线程只有一种方式，都是通过new Thread()创建线程对象，调用Thread#start启动线程。

至于基于callable接口的方式，因为最终是要把实现了callable接口的对象通过FutureTask包装成Runnable，再交给Thread去执行，所以这个其实可以和实现Runnable接口看成同一类。

而线程池的方式，本质上是池化技术，是资源的复用，和新启线程没什么关系。

所以，比较赞同官方的说法，有两种方式创建一个线程用以执行。

三、多线程的常见方法

start和run

  • run：是多线程的方法体，调用多线程时执行的代码块，如果直接调用run那么就像直接调用方法一样，不会启动多线程（正确方法时通过调用start方法启动多线程执行run方法）
  • start：使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码，底层会调用native方法，通过操作系统进行操作

Thread类是Java里对线程概念的抽象，可以这样理解：我们通过new Thread()其实只是new出一个Thread的实例，还没有操作系统中真正的线程挂起钩来。只有执行了start()方法后，才实现了真正意义上的启动线程。

从Thread的源码可以看到，Thread的start方法中调用了start0()方法，而start0()是个native方法，这就说明Thread#start一定和操作系统是密切相关的。

start()方法让一个线程进入就绪队列等待分配cpu，分到cpu后才调用实现的run()方法，start()方法不能重复调用，如果重复调用会抛出异常（注意，此处可能有面试题：多次调用一个线程的start方法会怎么样？）。

而run方法是业务逻辑实现的地方，本质上和任意一个类的任意一个成员方法并没有任何区别，可以重复执行，也可以被单独调用。

优先级Priority

线程调度两种调度方式：

  • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

Java使用的是抢占式调度模型

  • 随机性：假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法

代码演示：

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();
​
        FutureTask<String> ft = new FutureTask<>(mc);
​
        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();
​
        MyCallable mc2 = new MyCallable();
​
        FutureTask<String> ft2 = new FutureTask<>(mc2);
​
        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

守护线程Daemon

相关方法：

代码演示：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
​
        t1.setName("女神");
        t2.setName("备胎");
​
        //把第二个线程设置为守护线程
        //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
        t2.setDaemon(true);
​
        t1.start();
        t2.start();
    }
}

sleep

特点：

  • 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
  •  其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
  • 睡眠结束后的线程未必会立刻得到执行
  • 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

代码演示：

  public static void main(String[] args) {
        
        
        new Thread(()->{
            try {
                //方式一
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
          
            try {
                //方式二
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

yield

特点：

  • 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
  • 具体的实现依赖于操作系统的任务调度器
  • 有可能会出现让出时间片不成功的现象，因为当让出时间片后就进入就绪状态，很可能会重新再次获得时间片

代码演示：

 public static void main(String[] args) {


       Thread thread = new Thread();
       thread.yield();//进入就绪状态，让出时间片

    }

join

特点：

  • 当线程调用join方法之后，就会让主线程进入阻塞状态，直到所有被标记为join方法的线程执行完成后才能开始执行主线程

join的两种调用方式：

  • join（）   ：不添加时间参数，即等待线程完成后主线程才开始运行
  • join（i）   ：添加时间参数，主线程最多等待i毫秒，超过i毫秒后如果还没完成，主线程也开始执行，如果参数是0，就无限等待，相当于无参调用

代码演示：

  public static void main(String[] args) throws InterruptedException {


        MyThread myThread1 = new MyThread("线程一");

        myThread1.start();

        myThread1.join();
        
        System.out.println("我主线程先完成了");

    }

park，unpark

  • 通过LockSupport.park可以暂停某个线程。通过LockSupport.unpark可以恢复某个线程运行
  • 与 Object 的 wait & notify 相比 wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必
  • LockSupport.unpark(t1);park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll 是唤醒所有等待线程，就不那么【精确】
  • park & unpark 可以先 unpark，而 wait & notify 不能先 notify

原理：

每个线程都有自己的一个 Parker 对象，由三部分组成 _counter ， _cond 和 _mutex 打个比喻

线程就像一个旅人，Parker 就像他随身携带的背包，条件变量就好比背包中的帐篷。_counter 就好比背包中的备用干粮（0 为耗尽，1 为充足） 调用 park 就是要看需不需要停下来歇息 ，如果备用干粮耗尽，那么钻进帐篷歇息 ，如果备用干粮充足，那么不需停留，继续前进 ，调用 unpark，就好比令干粮充足 ，如果这时线程还在帐篷，就唤醒让他继续前进，如果这时线程还在运行，那么下次他调用 park 时，仅是消耗掉备用干粮，不需停留继续前进，因为背包空间有限，多次调用 unpark 仅会补充一份备用干粮

1. 当前线程调用 Unsafe.park() 方法

2. 检查 _counter ，本情况为 0，这时，获得 _mutex 互斥锁

3. 线程进入 _cond 条件变量阻塞

4. 设置 _counter = 0

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1

2. 唤醒 _cond 条件变量中的 Thread_0

3. Thread_0 恢复运行

4. 设置 _counter 为 0

 

1. 调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1

2. 当前线程调用 Unsafe.park() 方法

3. 检查 _counter ，本情况为 1，这时线程无需阻塞，继续运行

4. 设置 _counter 为 0

interrupt

方法介绍：

interrupt中断sleep，wait，join的线程：

会打断当前的等待状态，如果需要锁的则会等待获取锁，如果不需要所得会进入就绪状态，等待获取时间片

interrupt的作用：是中断线程，如果线程不是处于wait、timewait、block状态的话，实际上并不会直接中断线程，而是给线程一个打断状态，我们需要在代码中判断打断状态是否为true（默认值为false），如果为true表示按照逻辑是希望线程终止的，这时候我们可以写一些善后代码，体面终止线程

如果线程是处于wait、timewait、block状态，使线程开始运行，并且会清空打断状态，打断状态还是fasle

  •  
    方法说明
    interrupt()打断线程
    isinterrupted()判断是否被打断，不会清空打断标记
    interrupted()判断是否被打断，会清空打断标记

interrupt打断正常运行的线程：

  • 表面上并不会出现任何情况，但是会将打断状态设置成true，用户可以根据实际情况进行处理

interrupt打断park线程：

代码演示：

private static void test4() {
 Thread t1 = new Thread(() -> {
 for (int i = 0; i < 5; i++) {
 log.debug("park...");
 LockSupport.park();
 log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
 }
 });
 t1.start();
 sleep(1);
 t1.interrupt();
}

  • park线程只会使打断状态为false的线程进入阻塞，第一次park能够成功，但是当通过interrupt打断了之后，再次park就会失效，除非将打断状态设置成false

对于线程的中断，除了interrupt还有其他两种方式，但是都不推荐使用：

暂停、恢复和停止操作对应在线程Thread的API就是suspend()、resume()和stop()。但是这些API是过期的，也就是不建议使用的。不建议使用的原因主要有：以suspend()方法为例，在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。同样，stop()方法在终结一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，因此会导致程序可能工作在不确定状态下。正因为suspend()、resume()和stop()方法带来的副作用，这些方法才被标注为不建议使用的过期方法。

wait、notify

原理：

  • Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
  • BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
  • BLOCKED 线程会在 Owner 线程释放锁时唤醒
  • WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入 EntryList 重新竞争
  • wait和notify都是object的方法，必须要获取对象的锁之后才能使用wait和notify进行等待和唤醒

 方法介绍

方法介绍
wait（）无限期等待，直到被唤醒
wait（long i）等待i毫秒，如果没被唤醒则停止等待
notify（）随机唤醒一个
notifyAll（）唤醒所有wait线程

wait和sleep的区别

sleep是thread方法，而wait是object方法

sleep不需要强制和synchronized配合使用，wait需要和synchronized配合使用

sleep在睡眠的同时不会释放锁，wait在睡眠的时候会释放锁

Promise_J_Z
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高并发02-JUC编程
12-07
java.util.current的简称。 ​ 管程的概念： ​ 一种同步机制，保证同一时间只有一个线程访问被保护数据或者代码。 ​ 用户线程：平时用到的多是用户线程 ​ 守护线程：比如主线程Main
java并发编程-AQS和JUC实战
04-29
java并发包详解，condition重入锁；Semaphore信号量；ReadWriteLock读写锁；CountDownLatch计时器；CyclicBarrier循环栅栏； 重⼊锁可以完全替代synchronized关键字。在JDK5.0的早期版本中，重⼊锁的性能远远好于 ...
JUC 之 队列基础篇讲解
wpml_java 技术博客
07-24 163
Queue 接口继承自 Collection 接口，说明队列也是一个集合容器，用来存储数据的。通常队列的实现方式为FIFO（先进先出）或 LIFO（后进先出），总是从一头插入一头取数据。下面我们来看看 Queue 额外提供了什么功能。
java并发编程 JUC-基础篇 快速入门
制定持续可量化的目标，不断坚持。
07-05 1055
程序有指令与数据组成，指令要运行，数据要读写，就必须指令加载到CPU。数据加载到内容，指令运行需要用到磁盘。当一个程序被运行时，从磁盘加载这个程序的代码至内存，这时开启了一个进程。
JUC并发编程-基础篇
qq_38645103的博客
06-07 126
JUC基础篇
Juc并发编程学习笔记---狂神说（全）
ProGram_Java521的博客
10-31 1441
Juc并发编程学习笔记---狂神说（全）
JUC并发编程 - ReentrantReadWriteLock源码分析
技术架构公社
08-22 303
前言 ReentrantReadWriteLock锁是AQS的另一种实现，它做到了可重入、可中断，分为公平和非公平两类实现，并且实现了读锁和写锁两类同时控制。在使用时，读写锁持有的同一个Lock实例，通过控制锁的行为，及CLH节点状态，来操作读锁和写锁，对于写少读多的场景，能提高效率。 由于我对AQS及ReentrantLock的源码已经做过分析，因此本篇文章对经常出现的代码流程介绍的会较为粗略，初次接触ReentrantReadWriteLock源码的同学，建议先从前面的文章看起，这样反而更能清晰的理
JUC并发编程-8锁现象
凹凸曼的博客
12-18 309
文章目录锁方法的调用者问题一问题二问题三问题四锁class对象问题五问题六同时锁方法的调用者和class对象问题七问题八 首先感谢下B站的狂神，在这里第一次听到“8锁现象”，并弄懂了“锁到底锁的是谁”。 8锁现象，实际对应的就是8个问题。 掌握了这8个问题后：可以清楚判断锁的是谁！知道什么是锁，锁到底锁的是谁！ 锁方法的调用者 问题一 如下代码：标准情况下，下边两个线程先打印 发短信 还是 打电话 ？ public class Test1 { public static void main(Stri
并发编程-11线程池详解
最新发布
落雪
07-13 489
线程池大家或多或少在项目中进行使用，可以帮助我们提高系统的性能，另一方面也可以帮我们我们管理系统的线程资源，那么它的核心参数的作用，线程复用的原理也是值得我们去学习的，本篇我们从源码分析去探索线程池的底层奥秘。
并发编程-10阻塞队列BlockingQueue
落雪
07-13 299
使用线程池的肯定对阻塞队列的肯定不陌生，阻塞队列的的阻塞功能是如何实现的？常见的阻塞队列和他们的使用场景是哪些？在项目中我们应该如何选择合适的阻塞队列呢？本篇将从源码开始分析各个阻塞队列的底层数据结构和原理，这样更容易让我们在系统中选择合适的阻塞队列！
并发编程-04synchronized原理
落雪
06-25 808
本篇文章主要介绍java同步锁synchronized关键字的使用、底层原理、以及jvm对synchronized关键字的相关优化
JUC编程笔记-zfs.pdf
04-11
JUC 编程笔记 - zfs.pdf 本笔记主要讲解了 Java 中的并发...本笔记提供了 Java 中并发编程的基础知识，包括进程和线程的概念、并发和并行的区别、异步和同步的概念等，同时介绍了 Java 中创建和运行线程的多种方法。
JUC-High-Concurrency:java.util.concurrent JUC高并发处理
04-03
本篇将深入探讨JUC中的重要知识点，包括同步、可重入锁、类对象锁、高并发集合以及可调用接口。 首先，我们来看同步机制。在Java中，同步主要用于控制对共享资源的访问，防止数据的不一致性。同步可以通过...
Java并发编程-3.pdf
05-28
Java并发编程中的多线程协作机制 在 Java 并发编程中，多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中，多个线程之间如何协作、同步和通信，以达到共同完成某个任务的目的。Java 提供了多种...
Elsaticsearch java基本操作
qq_62383709的博客
07-13 334
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
配置Java开发环境
Broken_x的博客
07-10 1470
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 373
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 435
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值