首页 > 编程语言 >第二季：5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁【Java面试题】

第二季：5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁【Java面试题】

时间：2022-10-16 22:35:53浏览次数：47  
标签：面试题 Thread 线程 公平 自旋 println new public out


第二季：5值传递和引用传递【Java面试题】

前言

2022 10/4 23:01

路漫漫其修远兮,吾将上下而求索


值传递

说明

本文目录前是相关视频的名字和具体视频中思维导图的名字

题目

​​第一季：4方法的参数传递机制【Java面试题】​​

24 TransferValue醒脑小练习

package transfervalue5;

/**
 * 值传递和引用传递
 */
public class TransferValueDemo {

    public void changeValue1(int age) {
        age = 30;
    }

    public void changeValue2(Person person) {
        person.setPersonName("XXXX");
    }
    public void changeValue3(String str) {
        str = "XXX";
    }

    public static void main(String[] args) {
        TransferValueDemo test = new TransferValueDemo();

        // 定义基本数据类型
        int age = 20;
        test.changeValue1(age);
        System.out.println("age ----" + age);

        // 实例化person类
        Person person = new Person("abc");
        test.changeValue2(person);
        System.out.println("personName-----" + person.getPersonName());

        // String 不可变型
        String str = "abc";
        test.changeValue3(str);
        System.out.println("string-----" + str);

    }
}

结果

age ----20
personName-----XXXX
string-----abc

changeValue1的执行过程
八种基本数据类型，在栈里面分配内存，属于值传递

栈管运行，堆管存储

当们执行 changeValue1的时候，因为int是基本数据类型，所以传递的是int = 20这个值，相当于传递的是一个副本，main方法里面的age并没有改变，因此输出的结果 age还是20，属于值传递

第二季：5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁【Java面试题】_java


changeValue2的执行过程

因为Person是属于对象，传递的是内存地址，当执行changeValue2的时候，会改变内存中的Person的值，属于引用传递，两个指针都是指向同一个地址

第二季：5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁【Java面试题】_java_02

changeValue3的执行过程
String不属于基本数据类型，但是为什么执行完成后，还是abc呢？

这是因为String的特殊性，当我们执行String str = "abc"的时候，它会把 abc 放入常量池中

第二季：5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁【Java面试题】_面试_03


当我们执行changeValue3的时候，会重新新建一个xxx，并没有销毁abc，然后指向xxx，然后最后我们输出的是main中的引用，还是指向的abc，因此最后输出结果还是abc

2022 10/4 23:24

身体抱恙

2022 10/9 16:21

第二季：5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁

说明

本文目录前是相关视频的名字和具体视频中思维导图的名字

题目

5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁

25 java锁之公平和非公平锁

公平和非公平锁

是什么

公平锁
是指多个线程按照申请锁的顺序来获取锁，类似于排队买饭，先来后到，先来先服务，就是公平的，也就是队列

非公平锁
是指多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转，或者饥饿的线程（也就是某个线程一直得不到锁）

两者区别

公平锁/非公平锁

并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁

关于两者区别:
公平锁:Threads acquire a fair lock in the order in which they requested it

公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己

非公平锁: a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.

非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。

题外话

Java ReentrantLock而言，
通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

对于Synchronized而言，也是一种非公平锁

26 java锁之可重入锁和递归锁理论知识

可重入锁(又名递归锁)

是什么

可重入锁（也叫做递归锁）

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取到该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁

也就是说：线程可以进入任何一个它已经拥有的锁所同步的代码块

ReentrantLock / Synchronized 就是一个典型的可重入锁

可重入锁的最大作用就是避免死锁

27 java锁之可重入锁和递归锁代码验证

ReentrantLockDemo

参考1
package lock5;

class Phone{

    public synchronized void sendMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t invoked sendMS()");
        sendEmail();
    }

    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t ####invoked sendEmail()");
    }

    //================================================================
}


/**
 * 可重入锁(也叫做递归锁)
 *
 * 指的是同一线程外层函数获得锁之后﹐内层递归函数仍然能获取该锁的代码，
 * 在同一个线程在外层方泫获取锁的时候，在进入内层方法会自动获取锁
 *
 * 也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。
 *
 * case one
 * Synchronized就是一个典型的可重入锁
 * t1     invoked sendMS()           t1线程外层函数获得锁之后
 * t1     ####invoked sendEmail()    t1在进入内层方法会自动获取锁
 * t2     invoked sendMS()
 * t2     ####invoked sendEmail()
 *
 *
 */
public class ReenterLockDemo {
    public static void main(String[] args) {
        Phone phone=new Phone();
        new Thread(()->{
            try {
                phone.sendMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t1").start();
        new Thread(()->{
            try {
                phone.sendMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}
参考2
package lock5;

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

class Phone implements Runnable{

    public synchronized void sendMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t invoked sendMS()");
        sendEmail();
    }

    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t ####invoked sendEmail()");
    }

    //================================================================================

    Lock lock=new ReentrantLock();
    @Override
    public void run() {
        get();
    }

   public void get(){
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t invoked get()");
            set();
        }finally {
            lock.unlock();//不配对将产生死锁
            lock.unlock();
        }
   }

    public void set(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t #####invoked set()");
        }finally {
            lock.unlock();
        }
    }
}


/**
 * 可重入锁(也叫做递归锁)
 *
 * 指的是同一线程外层函数获得锁之后﹐内层递归函数仍然能获取该锁的代码，
 * 在同一个线程在外层方泫获取锁的时候，在进入内层方法会自动获取锁
 *
 * 也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。
 *
 * case one
 * Synchronized就是一个典型的可重入锁
 * t1   invoked sendMS()           t1线程外层函数获得锁之后
 * t1   ####invoked sendEmail()    t1在进入内层方法会自动获取锁
 * t2   invoked sendMS()
 * t2   ####invoked sendEmail()
 *
 * case two
 * ReentrantLock就是一个典型的可重入锁
 * t3   invoked get()
 * t3   #####invoked set()
 * t4   invoked get()
 * t4   #####invoked set()
 *
 */
public class ReenterLockDemo {
    public static void main(String[] args) {
        Phone phone=new Phone();
        new Thread(()->{
            try {
                phone.sendMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t1").start();
        new Thread(()->{
            try {
                phone.sendMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t2").start();

        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println();

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

        Thread t3 =new Thread(phone,"t3");
        Thread t4 =new Thread(phone,"t4");

        t3.start();
        t4.start();
    }
}

28 java锁之自旋锁理论知识

自旋锁

自旋锁(spinlock)
是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

第二季：5公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁【Java面试题】_java_04

29 java锁之自旋锁代码验证

SpinLockDemo
package lock5;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class SpinLockDemo {
    //原子引用线程
    AtomicReference<Thread> atomicReference=new AtomicReference<>();

    public void myLock(){
        Thread thread=Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"\t come in");
        while(!atomicReference.compareAndSet(null,thread)){
//            System.out.println(Thread.currentThread().getName()+"\t自旋中ing");
        }

    }

    public void myUnlock(){
        Thread thread=Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t invoked myUnLock");
    }

    public static void main(String[] args) {
       SpinLockDemo spinLockDemo=new SpinLockDemo();


       new Thread(()->{
           spinLockDemo.myLock();
           //tsleep
           try{ TimeUnit.SECONDS.sleep(5); }catch (InterruptedException e){ e.printStackTrace(); }
           spinLockDemo.myUnlock();

       },"AA").start();


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

        new Thread(()->{
            spinLockDemo.myLock();
            try{ TimeUnit.SECONDS.sleep(1); }catch (InterruptedException e){ e.printStackTrace(); }
            spinLockDemo.myUnlock();
        },"BB").start();

    }
}

30 java锁之读写锁理论知识

独占锁（写锁） / 共享锁（读锁） / 互斥锁

独占锁：指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁

共享锁：指该锁可以被多个线程锁持有
对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁
读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

ReadWriteLockDemo
Before
package lock5;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

class MyCache{//资源类
    private volatile Map<String,Object> map =new HashMap<>();
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"\t 正在写入："+key);
        //tsleep
        try{ TimeUnit.MILLISECONDS.sleep(300); }catch (InterruptedException e){ e.printStackTrace(); }
        map.put(key, value);
        System.out.println(Thread.currentThread().getName()+"\t 写入完成：");
    }
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"\t 正在读取："+key);
        //tsleep
        try{ TimeUnit.MILLISECONDS.sleep(300); }catch (InterruptedException e){ e.printStackTrace(); }
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName()+"\t 读取完成："+result);
    }

}
/**
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是
 * 如果有一个线程想去写共享资源来，就不应该再有其它线程可以对该资源进行读或写
 * 小总结:
 *      读-读能共存
 *      读-写不能共存
 *      写-写不能共存
 *
 *      写操作：原子+独占,整个过程必须是一个完整的统一体，中间不许被分割，被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache=new MyCache();
        
        //forthread10
        for (int i = 1; i <= 5; i++) {
            final int tempInt=i;
            new Thread(()->{
                 myCache.put(tempInt+"",tempInt+"");
            },String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int tempInt=i;
            new Thread(()->{
                myCache.get(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
}

结果

3   正在写入：3
4   正在写入：4
5   正在写入：5
1   正在写入：1
2   正在写入：2
1   正在读取：1
2   正在读取：2
3   正在读取：3
4   正在读取：4
5   正在读取：5
2   读取完成：null
2   写入完成：
1   写入完成：
3   写入完成：
1   读取完成：null
4   读取完成：null
5   写入完成：
5   读取完成：5
3   读取完成：null
4
After

写锁是为了写写互斥
读锁是为了读写互斥

package lock5;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class MyCache{//资源类
    private volatile Map<String,Object> map =new HashMap<>();
    private ReentrantReadWriteLock rwLock=new ReentrantReadWriteLock();

    public void put(String key,Object value){

        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t 正在写入："+key);
            //tsleep
            try{ TimeUnit.MILLISECONDS.sleep(300); }catch (InterruptedException e){ e.printStackTrace(); }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName()+"\t 写入完成：");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rwLock.writeLock().unlock();
        }


    }
    public void get(String key){
        rwLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t 正在读取："+key);
            //tsleep
            try{ TimeUnit.MILLISECONDS.sleep(300); }catch (InterruptedException e){ e.printStackTrace(); }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName()+"\t 读取完成："+result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void clearMap(){
        map.clear();
    }

}
/**
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是
 * 如果有一个线程想去写共享资源来，就不应该再有其它线程可以对该资源进行读或写
 * 小总结:
 *      读-读能共存
 *      读-写不能共存
 *      写-写不能共存
 *
 *      写操作：原子+独占,整个过程必须是一个完整的统一体，中间不许被分割，被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache=new MyCache();

        //forthread10
        for (int i = 1; i <= 5; i++) {
            final int tempInt=i;
            new Thread(()->{
                 myCache.put(tempInt+"",tempInt+"");
            },String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int tempInt=i;
            new Thread(()->{
                myCache.get(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
}

结果

2   正在写入：2
2   写入完成：
3   正在写入：3
3   写入完成：
1   正在写入：1
1   写入完成：
4   正在写入：4
4   写入完成：
5   正在写入：5
5   写入完成：
1   正在读取：1
2   正在读取：2
3   正在读取：3
4   正在读取：4
5   正在读取：5
4   读取完成：4
3   读取完成：3
2   读取完成：2
1   读取完成：1
5   读取完成：5

最后

2022 10/9 20:25

p24~p31

Markdown 10342 字数 650 行数
HTML 9906 字数 457 段落


标签：面试题,Thread,线程,公平,自旋,println,new,public,out
From： https://blog.51cto.com/u_15719556/5760738

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99