JUC第四课——LockSupport、三道面试题、源码阅读原则

最新推荐文章于 2024-05-30 14:51:59 发布
最新推荐文章于 2024-05-30 14:51:59 发布
阅读量79 收藏
点赞数
分类专栏： JUC 文章标签： 面试 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/upset_poor/article/details/120775587
版权

LockSupport

用于创建锁和其他同步类的基本线程阻塞（不释放锁）原语。

基本操作

package character04;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * @author laimouren
 */
public class LockSupport01 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if(i == 5){
                    //意思是阻塞线程
                    LockSupport.park();
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        try {
            TimeUnit.SECONDS.sleep(8);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("after 8 seconds");
        //unpark()可以在park()之前调用，使park()方法失效
        //相比wait()notify()更灵活
        LockSupport.unpark(t);
    }
}

小知识：object.notify()不释放锁,wait()方法被唤醒了之后仍需要锁
即当一个线程调用object.notify()的时候，另一个线程并不会马上执行，因为object对象的锁还是当前线程所持有，需要当前线程执行完或wait()

面试题

1. 实现一个容器，提供两个方法，add，size

写两个线程，线程1添加10个元素到容器中，线程2 监控元素个数，当个数到5个的时候，线程2给出提示并结束
可以使用两个notify()+wait()或者两个countdownLatch
下面提供使用两次LockSupport.unpark()+park();

public class Test2 {
	
	//实现一个容器 提供两个方法  add和size
	//写两个线程，线程1添加10个元素到容器中，线程2实现监控容器中元素的个数，当个数到5个时，线程2给出提示并且结束
	
	//实现原理 LockSupport park（阻塞线程）和unpark(Tread)（唤醒某个线程）
	//List list = new ArrayList<>(); //定义一个容器 （非线程安全）
	volatile List list =Collections.synchronizedList(new LinkedList<>());//定义一个线程安全的list
	public void add(Object o){ this.list.add(o); } //容器中添加对象
	public int size(){return this.list.size(); } //获取容器大小
	
	static Thread t2 =null;
	static Thread t1 = null;
	public static void main(String[] args) {
		Test2 test = new Test2();
		
		//线程1 负责监控容器长度是否等于5
		t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("t2 启动");
				LockSupport.park(); //阻塞t2线程
				if(test.size() == 5){
					System.out.println("t2 结束");
				}
				LockSupport.unpark(t1);//唤醒线程t1  t2线程结束
			}
		},"t2");

	
		t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
					
					System.out.println("t1 启动");
					for (int i = 0; i < 10; i++) {
						test.add(i);
						System.out.println("add "+i);
						if(test.size() == 5){
							//LockSupport.park(); //阻塞线程
							LockSupport.unpark(t2);//唤醒线程t2
							LockSupport.park(); //阻塞t1线程
						}
						
					}
				}
				
		},"t1");
		
		t2.start();//启动线程
		t1.start();//启动线程
		
	}
}

2. 写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用

synchronized方法：

package character04;


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

public class MyContatiner1<T> {
    final private LinkedList<T> list = new LinkedList<>();
    final private int MAX = 10;//最多10个元素
    private int count = 0;

    public synchronized void put(T t){
        while (list.size() == MAX){
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

        list.add(t);
        count++;
        //通知消费者进行消费
        this.notifyAll();
    }

    public synchronized T get(){
        T t = null;
        while (list.size() == 0){
            try {
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        t = list.removeFirst();
        count--;
        //通知生产者进行生产
        this.notifyAll();
        return t;
    }

    public static void main(String[] args) {
        MyContatiner1<String> container = new MyContatiner1<>();
        //启动消费者线程
        for (int i = 0;i < 10;i++){
            new Thread(()->{
                for(int j = 0;j < 5; j++){
                    System.out.println(container.get());
                }
            },"consumer"+i).start();
        }

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

        //启动生产者线程
        for (int i = 0;i < 2;i++){
            new Thread(()->{
                for (int j = 0;j < 25;j++){
                    container.put(Thread.currentThread().getName()+"->"+j);
                }
            },"producer"+i).start();
        }
    }
}

缺陷就是消费者线程可能错误的唤醒消费者线程，生产者线程可能错误的唤醒生产者线程，导致争抢严重

condition方法：

package com.example.demo.test;
 
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class MyContainer<T> {
	final private LinkedList<T> list = new LinkedList<>();
	final private int MAX = 10;//最多10个元素
 
	private Lock lock = new ReentrantLock();
	//Condition意思是一个等待队列，新建了两个等待队列
	private Condition producer = lock.newCondition();//生产者条件
	private Condition consumer = lock.newCondition();//消费者条件
 
	public void put(T t){
		try {
			lock.lock();
			while (list.size() == MAX){
				producer.await();//在这个条件下，生产者线程全部等待
			}
			list.add(t);
			consumer.signalAll();//通知消费者线程可以进行消费
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
 
	public T get(){
		T t = null;
		try {
			lock.lock();
			while (list.size() == 0){
				consumer.await();//在这个条件下，消费者线程全部等待
			}
			t = list.removeFirst();
			producer.signalAll();//通知生产者可以进行生产
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
		return t;
	}
 
	public static void main(String[] args) {
		MyContainer<String> container = new MyContainer<>();
		//启动消费者线程
		for (int i = 0;i < 10;i++){
			new Thread(()->{
				for(int j = 0;j < 5; j++){
					System.out.println(container.get());
				}
			},"consumer"+i).start();
		}
 
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
 
		//启动生产者线程
		for (int i = 0;i < 2;i++){
			new Thread(()->{
				for (int j = 0;j < 25;j++){
					container.put(Thread.currentThread().getName()+"->"+j);
				}
			},"producer"+i).start();
		}
	}
}

3. 用两个线程顺序打印A1B2C3D4…Z26

源码阅读原则

读源码必须理解别人的思路；所以需要数据结构基础和设计模式
读源码，先读骨架

  1. 跑不起来不读（不要静态的点方法进去看实现，而是通过debug一步步得到具体的实现是哪个）
  2. 解决问题就好——目的性
  3. 一条线索到底
  4. 无关细节略过
  5. 一般不读静态
  6. 一般动态读法

ReentrantLock源码分析

模板方法设计模式
在这里插入图片描述
通过debug来看具体实现

AQS（CLH）初了解

为什么核心是CAS+volatile
因为核心变量state是用volatile修饰的，由子类指定含义
使用双向链表，节点装的是线程thread
以ReentrantLock为例，获得锁的过程是，先看state是否为0，如果是0，说明当前没有线程使用锁，当前线程就使用CAS的方式获得锁，并返回true
在这里插入图片描述

学而知不足~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 高频面试题：聊一聊 JUC 下的 CopyOnWriteArrayList
01-20
ArrayList 是我们常用的工具类之一，但是在多线程的情况下，ArrayList 作为共享变量时，并不是线程安全的。主要有以下两个原因： 1、ArrayList 自身的 ...用 JUC 下的 CopyOnWriteArrayList ； 先来看看 Synchron
尚硅谷大厂面试题第三季周阳主讲
06-24
同博文pdf版，方便有需求的同学下载查看，主要整理了 B站 尚硅谷 大厂面试题第三季 全部内容，整合笔记，包含【JUC】【Redis】【Spring】等保证收获满满
JUC源码阅读(一)-AQS
Java部落格
03-14 194
一、AQS简介 AbstractQueuedSynchronizer，简称AQS，JUC并发包中常用的ReentrantLock, CountDownLatch等都依赖AQS。子类通过继承AQS并实现它的抽象方法来管理同步状态，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作，但是通过AQS实现的功能却是不同的。 二、AQS数据结构 下图就是AQS的数据模型： 接下来再来看看AbstractQueuedSynchronizer的成员变量 // CLH队列头结点 private t
bilibili尚硅谷周阳老师JUC并发编程与源码分析课程笔记第四章——LockSupport与线程中断
qq_46601365的博客
03-11 942
指java.util.concurrent.locks.LockSupport类，功能非常强大！首先一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运，所以Thread.stop,Thread.suspend,Thread.resume都已经被废弃了其次在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的协商机制——中断，也即中断标识协商机制。
【JUC】2、LockSupport 解析与面试题（一）
真正的大师永远怀着一颗学徒的心
08-22 612
LockSupport 解析1、带着面试题学习2、介绍2.1、LockSupport类简介2.2、LockSupport使用场景2.3、LockSupport使用示例3、源码解析3.1 类属性3.2 类方法3.2.1 方法总览3.3 重点方法代码展开3.3.1 park3.3.2 unpark4、扩展4.1 UNSAFE.PARK 和 UNSAFE.UNPARK4.2 Thread.sleep、Object.wait、LockSupport.park 区别4.2.1 使用wait阻塞线程4.2.2 使用pa
JUC在深入面试题——三种方式实现线程等待和唤醒（wait/notify，await/signal，LockSupport的park/unpark）
小王博客基地
02-22 683
文章目录一、前言二、wait/notify的使用1. 代码演示2. 执行结果3. 测试不在代码块执行（`把上面代码注释1给删除`）4. 修改代码5. 总结三、await/signal的使用1. 代码演示2. 执行结果3. 测试不在代码块执行（`把上面代码注释1给删除`）4. 修改代码5. 总结四、LockSupport的park/unpark的使用1. LockSupport介绍2. park源码查看3. unpark源码查看4. 代码演示5. 结果展示6. 修改代码7. 与前两者比的优点8.总结9.白话文
JUC并发编程面试题
weixin_45081813的博客
04-06 2167
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
多线程与高并发（四）：LockSupport，高频面试题，AQS源码，以及源码阅读方法论
热门推荐
寒泉
06-24 6万+
补充几道面试题 锁升级过程：无锁、偏向锁、轻量级锁、重量级锁 StampedLock 自己看一下 面试题：syn和Reentrantlock的区别？ LockSupport LockSupport.park()当前线程停止 t.start() LockSupport.unpark(t);让线程继续运行 原来想要停止一个线程，需要把线程加在某个锁上 之前想要叫醒一个线程，需要notify 现在unpark可以先于park调用并且有效，而之前wait不能先于notify调用 LockSupport的par
Java开发常见面试题详解（LockSupport，AQS）
zb_3Dmax的博客
09-06 145
传统的synchronized和Lock实现等待唤醒通知的约束线程先要获得并持有锁，必须在锁块(synchronized或lock)中必须要先等待后唤醒，线程才能够被唤醒类中的park等待和unpark唤醒是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（permit），permit只有两个值1和零，默认是零。
并发编程面试题——AQS源码解读
weixin_45150104的博客
07-11 495
讲解java并发编程AQS源码
JUC第一讲：Java并发知识体系详解 + 面试题汇总(P6熟练 P7精通)
Jet_qi的博客
09-17 417
面试时常常被面试官问到这个问题，Java并发包含实际业务开发中的方方面面。本篇文章是JUC第1讲，作为开篇，讲解Java 并发相关知识体系，包含理论基础，线程基础，synchronized，volatile，final关键字，JUC框架等内容。
JUC并发编程与源码分析视频课.zip
12-16
网盘文件永久链接
2019互联网面试题第2季.mmap
09-18
尚硅谷周阳互联网大厂面试题(第2季) 脑图。包括JUC多线程并发、JVM和GC等目前大厂笔试中会考、面试中会问、工作中会用的高频难点知识。上半场，从多线程并发入手，分层递进讲解，逐步让大家掌握volatile、原子类和...
java8源码-interview:常见的面试题整理
06-04
源码引言 本文针对一些面试经常出现的问题进行总结，会不定期更新 本文仅仅起到一个目录的作用，同时本文的很多内容来源于互联网，在这里做一个声明。 java篇 java基础 java集合 java多线程 JVM SDN篇 网络篇 数据库...
Transformer 动画讲解：数据处理的四大关键步骤
机器学习社区
05-30 1096
节前，我们组织了一场算法岗技术&面试讨论会，邀请了一些互联网大厂朋友、今年参加社招和校招面试的同学。针对大模型技术趋势、大模型落地项目经验分享、新手如何入门算法岗、该如何准备面试攻略、面试常考点等热门话题进行了深入的讨论。Transformer 大模型，一种基于自注意力机制的神经网络架构，已被广泛应用于各种自然语言处理任务，比如：机器翻译、文本摘要、生成问答等。从端到端的角度来看，Transformer 大模型中数据的处理流程主要包括四个阶段：首先是（Embedding），随后是。
Java进阶指南：高级面试问题与精辟解答（一）
Xs_layla的博客
05-29 837
Java内存模型（JMM）是一个抽象的内存模型，它定义了Java程序中变量的访问规则，以及在并发环境下如何保证内存操作的原子性、可见性和有序性。JMM确保了在多线程环境下，不同线程间对共享变量的读写操作能够按照一定的顺序进行，从而避免数据竞争和不一致的问题。在并发编程中，JMM扮演着至关重要的角色。它通过定义happens-before原则来确保操作的有序性，通过使用volatile关键字来保证变量的可见性，以及通过synchronized和锁机制来保证原子性。
图解 transformer——逐层介绍
最新发布
机器学习社区
05-30 1155
节前，我们组织了一场算法岗技术&面试讨论会，邀请了一些互联网大厂朋友、今年参加社招和校招面试的同学。针对大模型技术趋势、大模型落地项目经验分享、新手如何入门算法岗、该如何准备面试攻略、面试常考点等热门话题进行了深入的讨论。词嵌入层位置编码层多头注意层前馈层两个多头注意层前馈层线性层Softmax层。为了深入理解每个组件的作用，在翻译任务中 step-by-step 地训练 Transformer。
面试二十六、c++语言级别的多线程编程
leimeili的博客
05-28 270
这里的c++语言级别的多线程和linux的有一定的区别，c++语言级别提供的多线程比较严格，如果主线程结束了，但是子线程没有结束，进程就会异常终止，而linux不会，会继续执行。unique_lock允许右值引用的拷贝构造和赋值，
java juc面试
10-06
Java JUC（Java Util Concurrent）是Java并发编程中的一个重要模块，提供了一系列的工具类和API，用于实现高效的并发编程。 Java JUC包括了以下几个核心组件： 1. 锁：Java提供了多种锁机制来实现并发编程，例如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值