JUC并发编程（一） --- 多线程回顾，Synchronized和Lock锁，Condition线程通信，八锁问题

最新推荐文章于 2024-04-11 20:11:59 发布
最新推荐文章于 2024-04-11 20:11:59 发布
阅读量382 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JUC Java学习之路 文章标签： java juc 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45380083/article/details/122346285
本文介绍了Java并发编程的基础知识，包括JUC概述、线程与进程的区别、线程状态、synchronized与Lock锁的使用、线程通信以及线程同步的经典问题。详细讲解了synchronized与Lock的区别，如锁的释放、可判断性以及公平性，并通过8个锁问题实例深入理解其应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1、JUC简介

JUC是java.util.concurrent的缩写，即concurrent包下的所有东西，非常重要

image-20220105121316815

在学习JUC前需要对Java多线程进行回忆并补充

2、线程和进程

进程和线程 详见操作系统

  • 进程：就是一个正在运行的程序实例，进程是线程的容器
  • 线程：一个程序中不同的功能可能由不同的线程并行执行，例如：打开QQ，你这边和A聊天，那边和B聊天
    • 对java而言：java默认有2个线程：main线程和gc线程
    • 基类：Thread，Runnable，Callable

对于Java而言，真的能开启线程吗？ 不行

Thread的start()方法底层调用的是native关键字的本地方法start0()，底层是c++，java无法直接操作硬件

并发与并行

  • 并发concurrency： 即多线程操作同一个资源
    • CPU 一核，模拟多条线程，交替访问资源
  • 并行parallellism： 多个人一块行走（线程池）
    • CPU 多核，多条线程在不同核心上同一时刻执行

image-20220105123754559

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

线程的状态

操作系统中的五大状态

  1. 创建状态： 进程由创建产生，首先申请一个空白的PCB控制块，像PCB块中填写相应信息，然后分配所需的资源，最后转为就绪状态插入就绪队列中。
  2. 就绪状态： 已经准备好可以运行的状态，只要获得cpu就可以立即执行，进入运行状态。
  3. 运行状态： 已经获得cpu的进程，处于正在执行的状态
  4. 阻塞状态： 在执行过程中，缺少资源（如I/O请求），无法继续执行，即进入阻塞态，cpu调度将该阻塞的进程移到阻塞队列，再从就绪队列中调一个运行
  5. 终止状态： 进程的任务完成，到达自然结束点，操作系统将其PCB清空，并返还给系统

image-20220105133253691

Java中源码分为六个状态

查看源码枚举类：State

public enum State {
    // 新生
    NEW,
    // 运行
    RUNNABLE,
    // 阻塞
    BLOCKED,
    // 等待，死死地等
    WAITING,
    // 超时等待
    TIMED_WAITING,
    // 终止
    TERMINATED;
}
  1. 新生(NEW)： 新创建了一个线程但是没调用start()方法，即尚未启动的线程
  2. 运行态(RUNNABLE)： Java将线程中**就绪(ready)的运行(running)**中的两种状态笼统地称为运行
  3. 阻塞态(BLOCKED)： 一个线程因为等待临界区的锁被阻塞产生的状态
  4. 等待(WAITING)： 正在等待另一个线程做出一些特定动作：如通知或者中断
  5. 超时等待(TIMED_WAITING)： 在waiting基础上加了超时时间，可以在指定时间到达后自行返回
  6. 终止(TERMINATED)： 表示线程执行结束，退出

image-20220105155516594

wait和sleep的区别

1、来自不同的类

wait：wait是Object类下的

sleep：sleep是线程Thread类独有的

2、锁的释放

wait：会释放锁

sleep：不会释放锁，抱着锁睡觉

3、使用范围不同

wait：只能在同步代码块或同步方法中使用

sleep：在任何地方都能使用

4、是否需要捕获异常

wait：不需要

sleep：必须捕获异常InterpretedException

3、线程锁

3.1 synchronized

真正的开发，线程就是一个单独的资源类，用方法进行资源的使用

public class SynchronizedDemo {
    public static void main(String[] args) {
        //多个线程操作一个资源类：Ticket
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        },"C").start();

    }
}
// 资源类 OOP
class Ticket {
    // 属性、方法
    private int number = 30;
    // 卖票的方式
    // synchronized 本质: 队列，锁
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"买到了第"+(number--)+"张票,剩余："+number);
        }
    }
}

3.2 Lock

Lock使用的三步：

  • new ReentrantLock(); new一个锁
  • lock.lock(); 加锁
  • finally => lock.unlock(); 在finally里解锁

image-20220106111121810

public class LockDemo {
    
    static class Ticket{
        private int number = 30;
        private 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();
            }
        }
    }
    
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        },"C").start();

    }
}

注：

ReentrantLock默认（无参构造）是非公平锁

可以通过有参构造改为公平锁

image-20220106112048559

  • 公平锁：先来后到，不允许插队
  • 非公平锁：可以插队

3.3 Synchronized和Lock区别

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

4、线程通信

线程通信经典问题：生产者消费者问题

4.1 Synchronized版

if判断的问题

public class SynchronizedDemo {
    //资源类
    static class Data{
        private int num = 0;

        //加一操作
        public synchronized void increment() throws InterruptedException {
            if (num!=0){//需要改为while，后续会讲
                this.wait();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            //+1操作执行完成提醒其他线程，自己加一操作完毕了
            this.notifyAll();
        }

        //减一操作
        public synchronized void decrement() throws InterruptedException {
            if (num==0){//需要改为while，后续会讲
                this.wait();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            //+1操作执行完成提醒其他线程，自己加一操作完毕了
            this.notifyAll();
        }

    }

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

}

出现问题：虚假唤醒

image-20220106115511509 原因：查看jdk文档

image-20220106120006654

if判断改为while判断

    //加一操作
    public synchronized void increment() throws InterruptedException {
        while(num!=0){//需要改为while，后续会讲
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //+1操作执行完成提醒其他线程，自己加一操作完毕了
        this.notifyAll();
    }

    //减一操作
    public synchronized void decrement() throws InterruptedException {
        while(num==0){//需要改为while，后续会讲
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //+1操作执行完成提醒其他线程，自己加一操作完毕了
        this.notifyAll();
    }

}

4.2 JUC版线程通信

  • Synchronized使用wait和notify
  • Lock使用Condition类下的await和signal

image-20220106120256685

怎么使用：

image-20220106120830460

用Lock类下的newCondition()方法

基本使用

public class LockDemo {
    static class Data{
        private int num = 0;
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
        //加一操作
        public void increment(){
            lock.lock();
            try {
                while (num!=0){
                    condition.await();
                }
                num++;
                System.out.println(Thread.currentThread().getName()+"=>"+num);
                //+1操作执行完成提醒其他线程，自己加一操作完毕了
                condition.signalAll();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }

        //减一操作
        public void decrement(){
            lock.lock();
            try {
                while (num==0){
                    condition.await();
                }
                num--;
                System.out.println(Thread.currentThread().getName()+"=>"+num);
                //-1操作执行完成提醒其他线程，自己减一操作完毕了
                condition.signalAll();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

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

    }
}

同样的：

判断需要用while而不是if

Condition精准通知和唤醒

实现：A唤醒B，B唤醒C，C唤醒A

package com.bandit.JUCConsumerAndProducer;

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

/**
 * @author Bandit
 * @create 2022/1/6 12:16
 */
public class LockDemo02 {
    static class Data{
        private Lock lock = new ReentrantLock();
        private Condition condition1 = lock.newCondition();
        private Condition condition2 = lock.newCondition();
        private Condition condition3 = lock.newCondition();
        private int number = 1; // 1A 2B 3C

        public void printA(){
            lock.lock();
            try {
                // 业务，判断-> 执行-> 通知
                while (number!=1){
                // 等待
                    condition1.await();
                }
                System.out.println(Thread.currentThread().getName()+"=>AAAAAAA");
                // 唤醒，唤醒指定的人，B
                number = 2;
                condition2.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void printB(){
            lock.lock();
            try {
                // 业务，判断-> 执行-> 通知
                while (number!=2){
                    // 等待
                    condition2.await();
                }
                System.out.println(Thread.currentThread().getName()+"=>BBBBBBBB");
                // 唤醒，唤醒指定的人，B
                number = 3;
                condition3.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void printC(){
            lock.lock();
            try {
                // 业务，判断-> 执行-> 通知
                // 业务，判断-> 执行-> 通知
                while (number!=3){
                    condition3.await();
                }
                System.out.println(Thread.currentThread().getName()+"=>CCCCCCCCC");
                // 唤醒，唤醒指定的人，A
                number = 1;
                condition1.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

5、8锁问题

深刻理解锁

例一、二：

1、标准情况下，两个线程先打印 发短信还是 打电话？ 发短信

2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 发短信

/**
 * 1、标准情况下，两个线程先打印 发短信还是 打电话？       发短信
 * 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？     发短信
 */
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();
    }
	
   /**
    *例一 的Phone
    */
    static class Phone{
        public synchronized void sendSms(){
            System.out.println("sendSms");
        }
        public synchronized void call(){
            System.out.println("call");
        }
    }
   /**
    *例二 的Phone
    */
    static class Phone{
        public synchronized void sendSms(){
            try {//在发短信前sleep，看看谁先执行
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendSms");
        }
        public synchronized void call(){
            System.out.println("call");
        }
    }
}

解释： synchronized 锁的对象是方法的调用者。 两个方法用的是同一个锁，谁先拿到谁执行！

此处A先拿到锁，无论A睡多少秒都是A先执行

例三：

3、新增一个普通方法，先执行hello还是发短信？ hello

/**
 * 3、新增一个普通方法，先执行hello还是发短信？            hello
 */
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.hello();
        },"A").start();
    }
   /**
    *例三 的Phone
    */
    static class Phone{
        public synchronized void sendSms(){
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sendSms");
        }
        public synchronized void call(){
            System.out.println("call");
        }
        public void hello(){
            System.out.println("hello");
        }
    }
}

hello是非同步方法，异步执行，发短信要等4秒，hello只要等1秒，所有hello先执行

例四：

4、 两个对象，两个同步方法， 发短信还是 打电话？ 打电话

/**
 * 4、 两个对象，两个同步方法， 发短信还是 打电话？ // 打电话
 */
public class Test2 {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁！
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

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

    static 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("打电话");
        }
        public void hello(){
            System.out.println("hello");
        }
    }
}

解释： synchronized锁的是方法的调用者，两个对象的锁不一样，所以互不影响，先执行打电话再发短信

例五、六：

5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？ 发短信

6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？ 发短信

/**
 * 5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？    发短信
 * 6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？      发短信
 */
public class Test3 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

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

    static class Phone{
        //加上static修饰，类一加载就锁上了，
        //static锁的是  Class 模板，类锁
        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("打电话");
        }
    }
}

解释： 加上static的synchronized 是类锁，类一加载就有了，无论几个对象都是用的一把锁，

所以是先发短信再打电话

例七、八：

7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？ 打电话

8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？ 打电话

/**
 * 7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？
 * 8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？
 */
public class Test4 {

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

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

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

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

    static class Phone{
        //静态同步方法  锁的是Class类模板
        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("打电话");
        }
    }

}

解释： 静态同步方法锁的是Class类模板，普通同步方法锁的是方法的调用者

两个方法对应的是两把锁，不影响，所以先打电话再发短信

Java多线程并发编程系列-03 锁的分类、synchronized、ReentrantLock、ReentrantReadWriteLock
yangwei2048的博客
08-31 317
本文系统梳理了Java中锁的分类及synchronized的实现原理。锁可分为可重入/不可重入锁、乐观/悲观锁、公平/非公平锁、互斥/共享锁等类型。重点分析了synchronized的优化机制，包括锁消除、锁膨胀和锁升级（无锁→偏向锁→轻量级锁→重量级锁）。通过对象头MarkWord详细说明了synchronized的实现原理，并借助JOL工具展示了锁升级过程。最后解析了重量级锁底层ObjectMonitor的核心属性，揭示了synchronized的线程竞争机制。文章全面深入地讲解了Java锁机制的关键技
java线程（一）--进程，多线程，synchronized和lock锁，JUC，JUnit
牛大圣
03-31 1274
Java线程入门 单核CPU和多核CPU的理解 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的） 一个Java应用程序java.exe，其实至少有三个线
Lock中的Condition
m0_53077601的博客
02-08 4949
Lock +Conditon 与synchronized对比 我们经常会将Lock与synchronized作比较，不过大多数人都是针对性能方面的对比，但其实Lock和synchronized的区别远不止性能上的区别，如果你的了解也仅限于此，那么这篇文章对你来说有很有意义，在了解Lock和Condition前强烈建议你先到上一篇了解synchronized的实现原理。 相同的设计模型 不管是Lock 还是synchronized都是基于管程模型设计的，所以它们的实现互斥、同步的思路都一样，管程是解
Lock锁与Condition详解
7me
09-02 6418
目录引子重新认识Lock接口你了解Condition接口吗Condition接口与示例Condition如何实现 引子 三个线程分别打印A、B、C，要求按ABC的顺序循环打印10次。 ReentrantLock和Conditon实现 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; pub
自学并发编程之：Lock与Condition
2401_83384536的博客
04-11 1217
可重入锁”是指当一个线程调用 object.lock()获取到锁，进入临界区后，再次调用object.lock()，仍然可以获取到该锁。显然，通常的锁都要设计成可重入的，否则就会发生死锁。synchronized关键字，就是可重入锁。在一个synchronized方法method1()里面调用另外一个synchronized方法method2()。如果synchronized关键字不可重入，那么在method2()处就会发生阻塞，这显然不可行。
Lock锁中的Condition的用法
小郑要做干饭人的博客
10-17 376
其实Lock的Condition中[await()/signal()]的作用和Synchronized中[wait()/notify()]的作用是一样的,只是使用的方法不一样.
java并发---lock和condition
冰雪的专栏
12-03 5259
一、　java.util.concurrent.locks下面接口介绍        　　java.util.concurrent.locks包为锁和等待条件提供一个框架的接口和类，它不同于内置同步（synchronize）和监视器。该框架允许更灵活地使用lock和condition，但以更难用的语法为代价。 它下面有三个接口:Lock , ReadtrantLock , Conditio
基于Java JUC框架的售票系统与多线程锁通信设计源码
最新发布
09-30
本项目是一个基于Java JUC（Java并发包）框架构建的售票系统源码，它提供了深入学习和实践多线程编程的机会。Java JUC是Java平台上用于实现并发编程的一个重要工具集，它包括了众多用于控制并发访问共享资源的锁实现...
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
Java 多线程与并发是 Java 编程语言中的一部分，用于处理多线程和并发编程。Java 提供了一个名为 JUC（Java Utilities for Concurrency）的框架，用于帮助开发者编写高效、可靠的多线程程序。本文将对 JUC 框架中的...
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
Condition与Lock
SuNew_bee的博客
06-22 989
Condition与Lock的方法   Condition与Lock是两个接口，以上是它们内部定义的方法。Lock中有一个newCondition方法，所以Condition都是从Lock中创建出来的。 Condition实现原理   以读写锁为例来看原理： public class ReentrantLock implements Lock, java.io.Serializable { ... public Condition newCondition() { return sy
Lock的Condition使用
02-24 2352
Lock是java 1.5中引入的线程同步工具，它主要用于多线程下共享资源的控制。 Condition 本质是一个接口，它包含如下方法 // 让线程进入等通知待状态 void await() throws InterruptedException; void awaitUninterruptibly(); //让线程进入等待通知状态，超时结束等待状态，并抛出异常 lon
Java并发编程 Lock Condition & ReentrantLock（一）
weixin_44612246的博客
12-21 170
可重入锁，可重入锁的Condition
浅谈--Lock锁 与 Condition
qq_36647176的博客
12-26 1559
一 Lock锁简介 1.用处： Lock锁与synchronized一样，都是可以用来控制同步访问的。 2.有了synchronized，为什么还要Lock锁呢？ 那就要谈到synchronized的缺点，主要是三个方面。 A 有时候用synchronized修饰的代码，访问它需要很长时间，下一个要访问同一代码块的线程就要等待阻塞很长的时间。如果我想要下一个线程在等待一段时间后，如果还没...
Lock和Condition方法解析，有界缓冲区如何通过Lock,Condition实现
qq_42261668的博客
11-28 547
Lock doc Lock实现提供了比使用synchronized 同步方法和语句块获得的更广泛的锁操作。它们允许更灵活的结构，可能具有完全不同的属性，并且可能支持多个关联的条件（Condition）对象。 锁（Lock）是一种工具，用于控制多个线程对共享资源的访问。通常，Lock提供对共享资源的独占访问：一次只有一个线程可以获取锁，而对共享资源的所有访问都需要先获取锁。但是，有些锁可能允许并发访问共享资源，例如读写锁的读锁(ReadWriteLock)。 synchronized 同步方法和语句块的使用
线程高级篇-Lock锁和Condition条件
banbi9574的博客
02-08 735
浅谈Synchronized: 　　synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程 便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况: 　　1).获取锁的线程执行完该代码块,然后线程释放对锁的占有; 　　2).线程执行发生异常,此...
Lock和Condition原来是这么配对使用的
weixin_42363048的博客
06-06 748
jdk既然提供了monitor对象和synchronized关键字配合wait、notify、notifyAll方法实现等待/通知模式,为什么还要提供Lock和Condition配合await、signal、signalAll来实现等待/通知模式Lock可以显性的获取和释放锁,synchronized是隐性的.Lock支持手动获取锁,释放锁,我们可以自定义我们需要的锁,比如可重入锁,读写锁,具备更强的可拓展性.
并发编程（十）：Lock和Condition
张豫湘的博客
04-27 568
死锁问题中，对于死锁条件之一不可抢占条件（其他线程无法抢占线程已占用的资源），synchronized是无法处理的，因为其申请资源时，如果申请不到就直接进入了阻塞状态，而线程一旦进入阻塞状态，除非该线程主动调用notify方法，不然其他线程啥都干不了。这一条件，如果没有满足则调用wait等待，在满足条件时再去通知，这样，RPC调用的TCP层面中，线程是不会等待响应结果的异步流程变为了需要等待结果的同步流程，这也是我们之前所讲述的。非公平锁：不提供这个公平保证，有可能等待时间短的线程反而先被唤醒。
线程同步(Lock、Condition、synchronized、AtomicInteger、volatile、ThreadLocal)
好记性不如烂笔头
04-15 1016
线程不安全的问题 public class Demo implements Runnable { private long count = 0; @Override public void run() { for(int i=0;i<100000;i++) { count++; } } public static void main(String[] args) { Demo demo = new Demo(); Thread t1 = new Threa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值