背景

最近复习一下多线程，上面说到synchronized是将被阻塞的现场放到一个虚拟队列（Lock-Free无锁机制）中，而Lock是通过AQS队列存放阻塞的线程。那synchronized里的线程默认是怎么竞争锁的，Lock又是如何？

之前记录的结论：

思路

开启一个死循环，然后让多个线程竞争通一把锁，被阻塞的线程孜然就会被放到对应的阻塞队列里，执行时打印线程的名字，然后根据打印的结果判断顺序

先验证synchronized的情况，创建一个runnable实现类，然后共享成员变量map

public class MyThread implements Runnable{Map<String,String> map;public Map<String, String> getMap() {return map;}public void setMap(Map<String, String> map) {this.map = map;}@Overridepublic void run() {while (true){try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}synchronized (map){System.out.println(Thread.currentThread().getName()+"拿到了锁");try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"结束了");}}}
}

在主方法中执行

public static void main(String[] args) {Map<String, String> map = new HashMap<>();for (int i = 0; i < 10; i++) {MyThread myThread = new MyThread();myThread.setMap(map);Thread thread = new Thread(myThread);System.out.println(thread.getName()+"开始启动了");thread.start();}System.out.println("主线程结束了");}

结果：线程竞争结果无顺序，可以认为当一个线程释放锁资源时，队列中的其他线程都在竞争？

Thread-0开始启动了
Thread-1开始启动了
Thread-2开始启动了
Thread-3开始启动了
Thread-4开始启动了
Thread-5开始启动了
Thread-6开始启动了
Thread-7开始启动了
Thread-8开始启动了
Thread-9开始启动了
主线程结束了
Thread-0拿到了锁
Thread-0结束了
Thread-9拿到了锁
Thread-9结束了
Thread-1拿到了锁
Thread-1结束了
Thread-4拿到了锁
Thread-4结束了
Thread-6拿到了锁
Thread-6结束了
Thread-2拿到了锁
Thread-2结束了
Thread-8拿到了锁
Thread-8结束了
Thread-7拿到了锁
Thread-7结束了
Thread-5拿到了锁
Thread-5结束了
Thread-3拿到了锁
Thread-3结束了
Thread-5拿到了锁
Thread-5结束了
Thread-7拿到了锁
Thread-7结束了
Thread-8拿到了锁
Thread-8结束了
Thread-2拿到了锁

验证Lock锁的情况，通过共享一个ReentrantLock对象。

public class MyThread2 implements  Runnable{ReentrantLock reentrantLock ;public ReentrantLock getReentrantLock() {return reentrantLock;}public void setReentrantLock(ReentrantLock reentrantLock) {this.reentrantLock = reentrantLock;}@Overridepublic void run() {while (true){try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}reentrantLock.lock();System.out.println(Thread.currentThread().getName()+"拿到了锁");try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"结束了");reentrantLock.unlock();}}
}

主线程

public static void main(String[] args) {ReentrantLock reentrantLock = new ReentrantLock(false);for (int i = 0; i < 5; i++) {MyThread2 myThread2 = new MyThread2();myThread2.setReentrantLock(reentrantLock);Thread thread = new Thread(myThread2);System.out.println(thread.getName()+"开始启动了");thread.start();}}

结果可见，线程执行是有顺序的，确实是按照顺序不停更换头结点，循环，有序拿到锁的。

Thread-0开始启动了
Thread-1开始启动了
Thread-2开始启动了
Thread-3开始启动了
Thread-4开始启动了
Thread-1拿到了锁
Thread-1结束了
Thread-0拿到了锁
Thread-0结束了
Thread-2拿到了锁
Thread-2结束了
Thread-3拿到了锁
Thread-3结束了
Thread-4拿到了锁
Thread-4结束了
Thread-1拿到了锁
Thread-1结束了
Thread-0拿到了锁
Thread-0结束了
Thread-2拿到了锁
Thread-2结束了
Thread-3拿到了锁
Thread-3结束了
Thread-4拿到了锁
Thread-4结束了
Thread-1拿到了锁
Thread-1结束了
Thread-0拿到了锁
Thread-0结束了
Thread-2拿到了锁
Thread-2结束了
Thread-3拿到了锁
Thread-3结束了
Thread-4拿到了锁

这里有个疑问就是公平锁的问题，公平锁反应的应该是新来的线程是否应该排队吧，已经在CLH队列里的线程就是按照顺序执行，跟是否公平无关吧？

这里证明一下，先让5个线程都打印完，得以判断出最初的队列顺序，然后再突然让5个新的线程去竞争，看看这5个线程是否会排到后面。

public static void main(String[] args) {ReentrantLock reentrantLock = new ReentrantLock(false);for (int i = 0; i < 5; i++) {MyThread2 myThread2 = new MyThread2();myThread2.setReentrantLock(reentrantLock);Thread thread = new Thread(myThread2);System.out.println(thread.getName()+"开始启动了");thread.start();}try {Thread.sleep(3500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("开始加入额外线程");for (int i = 0; i < 10; i++) {MyThread2 myThread2 = new MyThread2();myThread2.setReentrantLock(reentrantLock);Thread thread = new Thread(myThread2);try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}thread.start();}System.out.println("主线程结束了");}

设置的Lock锁为false，为不公平锁

最初顺序为3,2,4,1,0，最后结果成了3,10,5,11,2,12,6,13,4,14,7,1,8等等

根据结果可以发现确实有插队情况出现了，确实符合理论。

Thread-0开始启动了
Thread-1开始启动了
Thread-2开始启动了
Thread-3开始启动了
Thread-4开始启动了
Thread-3拿到了锁
Thread-3结束了
Thread-2拿到了锁
Thread-2结束了
Thread-4拿到了锁
Thread-4结束了
Thread-1拿到了锁
Thread-1结束了
Thread-0拿到了锁
Thread-0结束了
Thread-3拿到了锁
开始加入额外线程
Thread-3结束了
Thread-2拿到了锁
Thread-2结束了
Thread-4拿到了锁
Thread-4结束了
Thread-1拿到了锁
Thread-1结束了
Thread-0拿到了锁
Thread-0结束了
Thread-3拿到了锁
Thread-3结束了
Thread-5拿到了锁
Thread-5结束了
Thread-2拿到了锁
Thread-2结束了
Thread-6拿到了锁
Thread-6结束了
Thread-4拿到了锁
Thread-4结束了
Thread-7拿到了锁
主线程结束了
Thread-7结束了
Thread-1拿到了锁
Thread-1结束了
Thread-8拿到了锁
Thread-8结束了
Thread-0拿到了锁
Thread-0结束了
Thread-9拿到了锁
Thread-9结束了
Thread-3拿到了锁
Thread-3结束了
Thread-10拿到了锁
Thread-10结束了
Thread-5拿到了锁
Thread-5结束了
Thread-11拿到了锁
Thread-11结束了
Thread-2拿到了锁
Thread-2结束了
Thread-12拿到了锁
Thread-12结束了
Thread-6拿到了锁
Thread-6结束了
Thread-13拿到了锁
Thread-13结束了
Thread-4拿到了锁
Thread-4结束了
Thread-14拿到了锁
Thread-14结束了
Thread-7拿到了锁
Thread-7结束了
Thread-1拿到了锁
Thread-1结束了
Thread-8拿到了锁

现在改成ture，也就是公平锁，看看结果如何

结果显示不符合预期效果，想了一下，因为CLH他是一个带头结点的双向链表，也就是说他的链表是一直在变化的，所以顺序肯定不会是固定的，头结点释放以后，多个线程同时竞争尾部，然后再依次往前排，顺序势必会打乱。

Thread-0开始启动了
Thread-1开始启动了
Thread-2开始启动了
Thread-3开始启动了
Thread-4开始启动了
Thread-3拿到了锁
Thread-3结束了
Thread-2拿到了锁
Thread-2结束了
Thread-4拿到了锁
Thread-4结束了
Thread-1拿到了锁
Thread-1结束了
Thread-0拿到了锁
Thread-0结束了
Thread-3拿到了锁
开始加入额外线程
Thread-3结束了
Thread-2拿到了锁
Thread-2结束了
Thread-4拿到了锁
Thread-4结束了
Thread-1拿到了锁
Thread-1结束了
Thread-0拿到了锁
Thread-0结束了
Thread-3拿到了锁
Thread-3结束了
Thread-5拿到了锁
Thread-5结束了
Thread-2拿到了锁
Thread-2结束了
Thread-6拿到了锁
Thread-6结束了
Thread-4拿到了锁
Thread-4结束了
Thread-7拿到了锁
主线程结束了
Thread-7结束了
Thread-1拿到了锁
Thread-1结束了
Thread-8拿到了锁
Thread-8结束了
Thread-0拿到了锁
Thread-0结束了
Thread-9拿到了锁
Thread-9结束了
Thread-3拿到了锁
Thread-3结束了
Thread-10拿到了锁
Thread-10结束了
Thread-5拿到了锁
Thread-5结束了
Thread-11拿到了锁
Thread-11结束了
Thread-2拿到了锁
Thread-2结束了
Thread-12拿到了锁
Thread-12结束了
Thread-6拿到了锁
Thread-6结束了
Thread-13拿到了锁
Thread-13结束了
Thread-4拿到了锁
Thread-4结束了
Thread-14拿到了锁
Thread-14结束了
Thread-7拿到了锁
Thread-7结束了
Thread-1拿到了锁
Thread-1结束了
Thread-8拿到了锁

进一步改造一下ReentrantLock ，打印出他的队列内的元素。

public class ReentrantLockMine extends ReentrantLock {public ReentrantLockMine(boolean fair) {super(fair);}@Overrideprotected Collection<Thread> getQueuedThreads() {   //获取同步队列中的线程List<Thread> arrayList = new ArrayList<Thread>(super.getQueuedThreads());Collections.reverse(arrayList);return arrayList;}}

这边也是改一下内部的成员变量

public class MyThread2 implements  Runnable{ReentrantLockMine reentrantLock ;public ReentrantLock getReentrantLock() {return reentrantLock;}public void setReentrantLock(ReentrantLockMine reentrantLock) {this.reentrantLock = reentrantLock;}@Overridepublic void run() {while (true){reentrantLock.lock();System.out.println(Thread.currentThread().getName()+"拿到了锁,當前隊列："+((ReentrantLockMine)reentrantLock).getQueuedThreads());try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"结束了");reentrantLock.unlock();}}
}

测试方法

public static void main(String[] args) {ReentrantLockMine reentrantLock = new ReentrantLockMine(false);for (int i = 0; i < 5; i++) {MyThread2 myThread2 = new MyThread2();myThread2.setReentrantLock(reentrantLock);Thread thread = new Thread(myThread2);System.out.println(thread.getName()+"开始启动了");thread.start();}try {Thread.sleep(1500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("开始加入额外线程");for (int i = 0; i < 10; i++) {MyThread2 myThread2 = new MyThread2();myThread2.setReentrantLock(reentrantLock);Thread thread = new Thread(myThread2);thread.start();}System.out.println("主线程结束了");}

非公平结果：

可以发现，之后加入的线程全部按照顺序排在了后面，0号线程拿到线程后又插队获取到锁，继续执行，其他线程拿不到锁。

Thread-0开始启动了
Thread-1开始启动了
Thread-2开始启动了
Thread-3开始启动了
Thread-4开始启动了
Thread-0拿到了锁,當前隊列：[]
Thread-0结束了
Thread-0拿到了锁,當前隊列：[Thread[Thread-1,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main]]
Thread-0结束了
Thread-0拿到了锁,當前隊列：[Thread[Thread-1,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main]]
开始加入额外线程
主线程结束了
Thread-0结束了
Thread-0拿到了锁,當前隊列：[Thread[Thread-1,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-12,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-9,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main]]
Thread-0结束了
Thread-0拿到了锁,當前隊列：[Thread[Thread-1,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-12,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-9,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main]]
Thread-0结束了
Thread-0拿到了锁,當前隊列：[Thread[Thread-1,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-12,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-9,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main]]

公平锁结果：

可以发现全部按照队列顺序去执行了，不存在某个线程一直获取资源，符合预期效果。

Thread-0开始启动了
Thread-1开始启动了
Thread-2开始启动了
Thread-3开始启动了
Thread-4开始启动了
Thread-0拿到了锁,當前隊列：[]
Thread-0结束了
Thread-1拿到了锁,當前隊列：[Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main]]
Thread-1结束了
Thread-4拿到了锁,當前隊列：[Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main]]
开始加入额外线程
主线程结束了
Thread-4结束了
Thread-2拿到了锁,當前隊列：[Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main]]
Thread-2结束了
Thread-3拿到了锁,當前隊列：[Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main]]
Thread-3结束了
Thread-0拿到了锁,當前隊列：[Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main]]
Thread-0结束了
Thread-1拿到了锁,當前隊列：[Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main]]
Thread-1结束了
Thread-5拿到了锁,當前隊列：[Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main]]
Thread-5结束了
Thread-7拿到了锁,當前隊列：[Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main]]
Thread-7结束了
Thread-6拿到了锁,當前隊列：[Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main]]
Thread-6结束了
Thread-8拿到了锁,當前隊列：[Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main]]
Thread-8结束了
Thread-9拿到了锁,當前隊列：[Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main]]
Thread-9结束了
Thread-10拿到了锁,當前隊列：[Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main]]
Thread-10结束了
Thread-11拿到了锁,當前隊列：[Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main]]
Thread-11结束了
Thread-12拿到了锁,當前隊列：[Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main]]
Thread-12结束了
Thread-13拿到了锁,當前隊列：[Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main]]
Thread-13结束了
Thread-14拿到了锁,當前隊列：[Thread[Thread-4,5,main], Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main]]
Thread-14结束了
Thread-4拿到了锁,當前隊列：[Thread[Thread-2,5,main], Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main]]
Thread-4结束了
Thread-2拿到了锁,當前隊列：[Thread[Thread-3,5,main], Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main]]
Thread-2结束了
Thread-3拿到了锁,當前隊列：[Thread[Thread-0,5,main], Thread[Thread-1,5,main], Thread[Thread-5,5,main], Thread[Thread-7,5,main], Thread[Thread-6,5,main], Thread[Thread-8,5,main], Thread[Thread-9,5,main], Thread[Thread-10,5,main], Thread[Thread-11,5,main], Thread[Thread-12,5,main], Thread[Thread-13,5,main], Thread[Thread-14,5,main], Thread[Thread-4,5,main], Thread[Thread-2,5,main]]

结论

synchronized的队列似乎并不有序，根据Lock-Free的解释，它属于一个虚拟的队列，队列里的各个数据都在竞争锁。

Lock严格按照队列顺序执行，若非公平锁状态则可能被非队列中的现场插队执行，公平锁状态下按照队列顺序，只有头结点才回去尝试获取锁，和synchronized都在竞争锁情况相比可能更节省资源？但是同一时刻多线程入队的顺序是不确定的（雾）。

synchronized锁和lock锁 队列中线程执行顺序对比相关推荐

  1. 萌新必入！手把手教你玩转Synchronized锁和Lock锁！

    文章目录 声明 前言 Synchronized锁 Lock锁 Synchronized与Lock区别 生产者与消费者问题 Synchronized Lock 8锁现象 后记 声明 1)该文章部分内容整 ...

  2. 日志打印、main函数中代码执行顺序

    文章目录 1.设置时区 2.日志打印 3.main函数中代码执行顺序 1.设置时区 我们要设置成 CST 时区,以保证正确地显示日期.时间. 我们常看到的时区有如下几个: PST:美国太平洋标准时间, ...

  3. Unity脚本在层级面板中的执行顺序测试3

    断断续续的写了3篇,以后有时间可以做成一个系列了 前面2篇测试了GameObject的顺序,以及Awake和OnEnable的时机: Unity脚本在层级面板中的执行顺序测试1 http://www. ...

  4. 【总结篇】继承中的执行顺序

    作者:✿✿ xxxflower. ✿✿ <总结篇> 这个专题就记录一些自己在练习中所学习到的. 包括一些不熟悉的芝士点和一些小的细节. 今天我们来总结一下继承中的执行顺序. 首先执行静态的 ...

  5. Java 对synchronized的补充Lock锁

    Java并发编程:Lock 从Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock. 也许有朋友会问,既然都可以通过synchr ...

  6. mysql读写分离主从原理、事务隔离级别及使用、锁表和锁行场景、乐观锁和悲观锁、lock锁和sychronized区别及使用自己学习之后总结和参考一些博客感觉系统了解了

    synchronized与Lock的区别 两者区别: 1.首先synchronized是java内置关键字,在jvm层面,Lock是个java类: 2.synchronized无法判断是否获取锁的状态 ...

  7. 【分析】浅谈C#中Control的Invoke与BeginInvoke在主副线程中的执行顺序和区别（SamWang）

    今天无意中看到有关Invoke和BeginInvoke的一些资料,不太清楚它们之间的区别.所以花了点时间研究了下. 据msdn中介绍,它们最大的区别就是BeginInvoke属于异步执行的. Cont ...

  8. java中线程执行顺序控制

    一:join()方法. thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程.比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行 ...

  9. jmeter 线程执行顺序_面试官让我说出8种线程顺序执行的方法！我懵了

    https://www.cnblogs.com/wenjunwei/p/10573289.html 一.前言 本文使用了8种方法实现在多线程中让线程按顺序运行的方法,涉及到多线程中许多常用的方法,不止 ...

  10. 关于线程执行顺序的问题

    R君今天曾问我:假设现在有三个线程T1.T2.T3.那么他希望T1.T2.T3这三个线程按照顺序去执行,该怎么去完成.我本能的反应是这个好办,使用thread.jon()方法完全可以实现.接着他又问, ...

最新文章

  1. 神经网络结构设计指导原则——输入层：神经元个数=feature维度 输出层：神经元个数=分类类别数，默认只用一个隐层 如果用多个隐层，则每个隐层的神经元数目都一样...
  2. python画直方图代码-Python使用Plotly绘图工具，绘制直方图
  3. python编程从入门到精通 叶维忠 pdf-最好的Python入门教材是哪本？
  4. Linux如何指向mysql_linux的基本操作（mysql 的基本操作）
  5. .NET Core 3.0之深入源码理解HealthCheck（一）
  6. leetcode1045. 买下所有产品的客户（SQL)
  7. java teechart怎么用_TeeChart使用范例
  8. Dijkstra算法（c++版）
  9. LeetCode 234 Palindrome Linked List
  10. -1在numpy重塑中是什么意思？
  11. MATLAB Simulink仿真应用
  12. 网页与多个服务器建立websoc,同一个页面怎么发起多个websocket
  13. javascript 图像二值化处理
  14. Java实习日记（7)
  15. 51单片机串口中断控制灯
  16. js去除url中的localtion.search部分
  17. 使用python自动上传apk到蒲公英
  18. mac 命令行 解压7z文件_命令行压缩解压缩一 7z
  19. 获取一个新的日期，它的值为指定日期当年的最后一天
  20. 「108套商业案例」烧烤店1元吃小龙虾，15天收款70万并自动裂变

热门文章

  1. Python性能加速
  2. 424.替换后的最长重复字符
  3. numpy.squeeze()的用法
  4. 二叉树的inorder实现：递归、栈、Morris遍历
  5. 2015-11-23 12:50:55
  6. 机器学习-KMeans聚类 K值以及初始类簇中心点的选取
  7. 【面向代码】学习 Deep Learning（三）Convolution Neural Network(CNN)
  8. 【ML小结10】集成学习
  9. pause容器作用_Kubernetes pod里一个特殊的容器：pause-amd64
  10. 网络安全基础——破解系统密码