【算法】手写单例模式 LRU 死锁快排

和瑚

已于 2023-04-10 13:18:00 修改

阅读量140

点赞数

分类专栏： # 算法文章标签：算法 java 开发语言

于 2023-01-31 14:54:51 首次发布

本文链接：https://blog.youkuaiyun.com/kazuhura/article/details/124661372

版权

算法专栏收录该内容

5 篇文章

订阅专栏

本文介绍四种经典算法及设计模式的手写实现：单例模式的双重检查锁定实现，确保线程安全；LRU缓存策略使用LinkedHashMap实现高效缓存管理；通过两个线程竞争资源模拟死锁现象；快速排序算法的递归实现。

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

1、手写单例模式

双重检查锁(DCL)

属性是static volatile的，主要是为了防止指令重排
构造函数私有化防止外部实例化对象
getInstance函数中，双重检查中间加个类锁
可用在并发环境下

public class Singleton{
	public static volatile Singleton singleton;
	
	//构造函数私有化，防止外部实例化对象
	private Singleton() {};
	//双重检查锁
	public static Singleton getInstance(){
		if (singleton == null){
			synchronized (Singleton.class){
				if (singleton == null){
					singleton = new Singleton();
				}
			}
		}
		return singleton;
	}
}

2、手写LRU

使用LinkedHashMap

class LRUCache {
    int cap;
    LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();
    public LRUCache(int capacity) { 
        this.cap = capacity;
    }
    
    public int get(int key) {
        if (!cache.containsKey(key)) {
            return -1;
        }
        // 将 key 变为最近使用
        makeRecently(key);
        return cache.get(key);
    }
    
    public void put(int key, int val) {
        if (cache.containsKey(key)) {
            // 修改 key 的值
            cache.put(key, val);
            // 将 key 变为最近使用
            makeRecently(key);
            return;
        }
        
        if (cache.size() >= this.cap) {
            // 链表头部就是最久未使用的 key
            int oldestKey = cache.keySet().iterator().next();
            cache.remove(oldestKey);
        }
        // 将新的 key 添加链表尾部
        cache.put(key, val);
    }
    
    private void makeRecently(int key) {
        int val = cache.get(key);
        // 删除 key，重新插入到队尾
        cache.remove(key);
        cache.put(key, val);
    }
}

3、手写死锁

public class DeadLockDemo {
    private static Object resource1 = new Object();//资源 1
    private static Object resource2 = new Object();//资源 2

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (resource1) {
                System.out.println(Thread.currentThread() + "get resource1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource2");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread() + "get resource2");
                }
            }
        }, "线程 1").start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + "get resource2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + "get resource1");
                }
            }
        }, "线程 2").start();
    }
}

4、手写快排

public static int partition(int[] array, int low, int high) {
    int pivot = array[high];
    int pointer = low;
    for (int i = low; i < high; i++) {
        if (array[i] <= pivot) {
            int temp = array[i];
            array[i] = array[pointer];
            array[pointer] = temp;
            pointer++;
        }
        System.out.println(Arrays.toString(array));
    }
    int temp = array[pointer];
    array[pointer] = array[high];
    array[high] = temp;
    return pointer;
}
public static void quickSort(int[] array, int low, int high) {
    if (low < high) {
        int position = partition(array, low, high);
        quickSort(array, low, position - 1);
        quickSort(array, position + 1, high);
    }
}