这是java高并发系列第14篇文章。

本文主要内容：

  1. 讲解3种让线程等待和唤醒的方法，每种方法配合具体的示例
  2. 介绍LockSupport主要用法
  3. 对比3种方式，了解他们之间的区别

LockSupport位于java.util.concurrent（简称juc）包中，算是juc中一个基础类，juc中很多地方都会使用LockSupport，非常重要，希望大家一定要掌握。

关于线程等待/唤醒的方法，前面的文章中我们已经讲过2种了：

  1. 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
  2. 方式2：使用juc包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

这2种方式，我们先来看一下示例。

使用Object类中的方法实现线程等待和唤醒

示例1：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo1 {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            synchronized (lock) {

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

                try {

                    lock.wait();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

            }

        });

        t1.setName("t1");

        t1.start();

        //休眠5秒

        TimeUnit.SECONDS.sleep(5);

        synchronized (lock) {

            lock.notify();

        }

    }

}

输出：

1563592938744,t1 start!

1563592943745,t1 被唤醒!

t1线程中调用lock.wait()方法让t1线程等待，主线程中休眠5秒之后，调用lock.notify()方法唤醒了t1线程，输出的结果中，两行结果相差5秒左右，程序正常退出。

示例2

我们把上面代码中main方法内部改一下，删除了synchronized关键字，看看有什么效果：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo2 {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

            try {

                lock.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

        });

        t1.setName("t1");

        t1.start();

        //休眠5秒

        TimeUnit.SECONDS.sleep(5);

        lock.notify();

    }

}

运行结果：

Exception in thread "t1" java.lang.IllegalMonitorStateException

1563593178811,t1 start!

	at java.lang.Object.wait(Native Method)

	at java.lang.Object.wait(Object.java:502)

	at com.itsoku.chat10.Demo2.lambda$main$0(Demo2.java:16)

	at java.lang.Thread.run(Thread.java:745)

Exception in thread "main" java.lang.IllegalMonitorStateException

	at java.lang.Object.notify(Native Method)

	at com.itsoku.chat10.Demo2.main(Demo2.java:26)

上面代码中将synchronized去掉了，发现调用wait()方法和调用notify()方法都抛出了IllegalMonitorStateException异常，原因：Object类中的wait、notify、notifyAll用于线程等待和唤醒的方法，都必须在同步代码中运行（必须用到关键字synchronized）。

示例3

唤醒方法在等待方法之前执行，线程能够被唤醒么？代码如下：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo3 {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            try {

                TimeUnit.SECONDS.sleep(5);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            synchronized (lock) {

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

                try {

                    //休眠3秒

                    lock.wait();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

            }

        });

        t1.setName("t1");

        t1.start();

        //休眠1秒之后唤醒lock对象上等待的线程

        TimeUnit.SECONDS.sleep(1);

        synchronized (lock) {

            lock.notify();

        }

        System.out.println("lock.notify()执行完毕");

    }

}

运行代码，输出结果：

lock.notify()执行完毕

1563593869797,t1 start!

输出了上面2行之后，程序一直无法结束，t1线程调用wait()方法之后无法被唤醒了，从输出中可见，notify()方法在wait()方法之前执行了，等待的线程无法被唤醒了。说明：唤醒方法在等待方法之前执行，线程无法被唤醒。

关于Object类中的用户线程等待和唤醒的方法，总结一下：

  1. wait()/notify()/notifyAll()方法都必须放在同步代码（必须在synchronized内部执行）中执行，需要先获取锁
  2. 线程唤醒的方法（notify、notifyAll）需要在等待的方法（wait）之后执行，等待中的线程才可能会被唤醒，否则无法唤醒

使用Condition实现线程的等待和唤醒

Condition的使用，前面的文章讲过，对这块不熟悉的可以移步JUC中Condition的使用，关于Condition我们准备了3个示例。

示例1

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo4 {

    static ReentrantLock lock = new ReentrantLock();

    static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            lock.lock();

            try {

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

                try {

                    condition.await();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

            } finally {

                lock.unlock();

            }

        });

        t1.setName("t1");

        t1.start();

        //休眠5秒

        TimeUnit.SECONDS.sleep(5);

        lock.lock();

        try {

            condition.signal();

        } finally {

            lock.unlock();

        }

    }

}

输出：

1563594349632,t1 start!

1563594354634,t1 被唤醒!

t1线程启动之后调用condition.await()方法将线程处于等待中，主线程休眠5秒之后调用condition.signal()方法将t1线程唤醒成功，输出结果中2个时间戳相差5秒。

示例2

我们将上面代码中的lock.lock()、lock.unlock()去掉，看看会发生什么。代码：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo5 {

    static ReentrantLock lock = new ReentrantLock();

    static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

            try {

                condition.await();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

        });

        t1.setName("t1");

        t1.start();

        //休眠5秒

        TimeUnit.SECONDS.sleep(5);

        condition.signal();

    }

}

输出：

Exception in thread "t1" java.lang.IllegalMonitorStateException

1563594654865,t1 start!

	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)

	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)

	at java.util.concurrent.locks.AbstractQueuedSynchronizer.fullyRelease(AbstractQueuedSynchronizer.java:1723)

	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2036)

	at com.itsoku.chat10.Demo5.lambda$main$0(Demo5.java:19)

	at java.lang.Thread.run(Thread.java:745)

Exception in thread "main" java.lang.IllegalMonitorStateException

	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1939)

	at com.itsoku.chat10.Demo5.main(Demo5.java:29)

有异常发生，condition.await();和condition.signal();都触发了IllegalMonitorStateException异常。原因：调用condition中线程等待和唤醒的方法的前提是必须要先获取lock的锁。

示例3

唤醒代码在等待之前执行，线程能够被唤醒么？代码如下：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo6 {

    static ReentrantLock lock = new ReentrantLock();

    static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            try {

                TimeUnit.SECONDS.sleep(5);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            lock.lock();

            try {

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

                try {

                    condition.await();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

            } finally {

                lock.unlock();

            }

        });

        t1.setName("t1");

        t1.start();

        //休眠5秒

        TimeUnit.SECONDS.sleep(1);

        lock.lock();

        try {

            condition.signal();

        } finally {

            lock.unlock();

        }

        System.out.println(System.currentTimeMillis() + ",condition.signal();执行完毕");

    }

}

运行结果:

1563594886532,condition.signal();执行完毕

1563594890532,t1 start!

输出上面2行之后，程序无法结束，代码结合输出可以看出signal()方法在await()方法之前执行的，最终t1线程无法被唤醒，导致程序无法结束。

关于Condition中方法使用总结：

  1. 使用Condtion中的线程等待和唤醒方法之前，需要先获取锁。否者会报IllegalMonitorStateException异常
  2. signal()方法先于await()方法之前调用，线程无法被唤醒

Object和Condition的局限性

关于Object和Condtion中线程等待和唤醒的局限性，有以下几点：

  1. 2中方式中的让线程等待和唤醒的方法能够执行的先决条件是：线程需要先获取锁
  2. 唤醒方法需要在等待方法之后调用，线程才能够被唤醒

关于这2点，LockSupport都不需要，就能实现线程的等待和唤醒。下面我们来说一下LockSupport类。

LockSupport类介绍

LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作的。

每个线程都有一个许可(permit)，permit只有两个值1和0，默认是0。

  1. 当调用unpark(thread)方法，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)。
  2. 当调用park()方法，如果当前线程的permit是1，那么将permit设置为0，并立即返回。如果当前线程的permit是0，那么当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会将permit再次设置为0，并返回。

注意：因为permit默认是0，所以一开始调用park()方法，线程必定会被阻塞。调用unpark(thread)方法后，会自动唤醒thread线程，即park方法立即返回。

LockSupport中常用的方法

阻塞线程

  • void park()：阻塞当前线程，如果调用unpark方法或者当前线程被中断，从能从park()方法中返回

  • void park(Object blocker)：功能同方法1，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查

  • void parkNanos(long nanos)：阻塞当前线程，最长不超过nanos纳秒，增加了超时返回的特性

  • void parkNanos(Object blocker, long nanos)：功能同方法3，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查

  • void parkUntil(long deadline)：阻塞当前线程，直到deadline，deadline是一个绝对时间，表示某个时间的毫秒格式

  • void parkUntil(Object blocker, long deadline)：功能同方法5，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查；

唤醒线程

  • void unpark(Thread thread):唤醒处于阻塞状态的指定线程

示例1

主线程线程等待5秒之后，唤醒t1线程，代码如下：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.LockSupport;

import java.util.concurrent.locks.ReentrantLock;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo7 {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

            LockSupport.park();

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

        });

        t1.setName("t1");

        t1.start();

        //休眠5秒

        TimeUnit.SECONDS.sleep(5);

        LockSupport.unpark(t1);

        System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();执行完毕");

    }

}

输出：

1563597664321,t1 start!

1563597669323,LockSupport.unpark();执行完毕

1563597669323,t1 被唤醒!

t1中调用LockSupport.park();让当前线程t1等待，主线程休眠了5秒之后，调用LockSupport.unpark(t1);将t1线程唤醒，输出结果中1、3行结果相差5秒左右，说明t1线程等待5秒之后，被唤醒了。

LockSupport.park();无参数，内部直接会让当前线程处于等待中；unpark方法传递了一个线程对象作为参数，表示将对应的线程唤醒。

示例2

唤醒方法放在等待方法之前执行，看一下线程是否能够被唤醒呢？代码如下：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.LockSupport;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo8 {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            try {

                TimeUnit.SECONDS.sleep(5);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

            LockSupport.park();

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

        });

        t1.setName("t1");

        t1.start();

        //休眠1秒

        TimeUnit.SECONDS.sleep(1);

        LockSupport.unpark(t1);

        System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();执行完毕");

    }

}

输出：

1563597994295,LockSupport.unpark();执行完毕

1563597998296,t1 start!

1563597998296,t1 被唤醒!

代码中启动t1线程，t1线程内部休眠了5秒，然后主线程休眠1秒之后，调用了LockSupport.unpark(t1);唤醒线程t1，此时LockSupport.park();方法还未执行，说明唤醒方法在等待方法之前执行的；输出结果中2、3行结果时间一样，表示LockSupport.park();没有阻塞了，是立即返回的。

说明：唤醒方法在等待方法之前执行，线程也能够被唤醒，这点是另外2中方法无法做到的。Object和Condition中的唤醒必须在等待之后调用，线程才能被唤醒。而LockSupport中，唤醒的方法不管是在等待之前还是在等待之后调用，线程都能够被唤醒。

示例3

park()让线程等待之后，是否能够响应线程中断？代码如下：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.LockSupport;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo9 {

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");

            System.out.println(Thread.currentThread().getName() + ",park()之前中断标志：" + Thread.currentThread().isInterrupted());

            LockSupport.park();

            System.out.println(Thread.currentThread().getName() + ",park()之后中断标志：" + Thread.currentThread().isInterrupted());

            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");

        });

        t1.setName("t1");

        t1.start();

        //休眠5秒

        TimeUnit.SECONDS.sleep(5);

        t1.interrupt();

    }

}

输出：

1563598536736,t1 start!

t1,park()之前中断标志：false

t1,park()之后中断标志：true

1563598541736,t1 被唤醒!

t1线程中调用了park()方法让线程等待，主线程休眠了5秒之后，调用t1.interrupt();给线程t1发送中断信号，然后线程t1从等待中被唤醒了，输出结果中的1、4行结果相差5秒左右，刚好是主线程休眠了5秒之后将t1唤醒了。结论：park方法可以相应线程中断。

LockSupport.park方法让线程等待之后，唤醒方式有2种：

  1. 调用LockSupport.unpark方法
  2. 调用等待线程的interrupt()方法，给等待的线程发送中断信号，可以唤醒线程

示例4

LockSupport有几个阻塞放有一个blocker参数，这个参数什么意思，上一个实例代码，大家一看就懂了：

package com.itsoku.chat10;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.LockSupport;

/**

 * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

 */

public class Demo10 {

    static class BlockerDemo {

    }

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            LockSupport.park();

        });

        t1.setName("t1");

        t1.start();

        Thread t2 = new Thread(() -> {

            LockSupport.park(new BlockerDemo());

        });

        t2.setName("t2");

        t2.start();

    }

}

运行上面代码，然后用jstack查看一下线程的堆栈信息：

"t2" #13 prio=5 os_prio=0 tid=0x00000000293ea800 nid=0x91e0 waiting on condition [0x0000000029c3f000]

   java.lang.Thread.State: WAITING (parking)

        at sun.misc.Unsafe.park(Native Method)

        - parking to wait for  <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)

        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)

        at com.itsoku.chat10.Demo10.lambda$main$1(Demo10.java:22)

        at com.itsoku.chat10.Demo10$$Lambda$2/824909230.run(Unknown Source)

        at java.lang.Thread.run(Thread.java:745)

"t1" #12 prio=5 os_prio=0 tid=0x00000000293ea000 nid=0x9d4 waiting on condition [0x0000000029b3f000]

   java.lang.Thread.State: WAITING (parking)

        at sun.misc.Unsafe.park(Native Method)

        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)

        at com.itsoku.chat10.Demo10.lambda$main$0(Demo10.java:16)

        at com.itsoku.chat10.Demo10$$Lambda$1/1389133897.run(Unknown Source)

        at java.lang.Thread.run(Thread.java:745)

代码中，线程t1和t2的不同点是，t2中调用park方法传入了一个BlockerDemo对象，从上面的线程堆栈信息中，发现t2线程的堆栈信息中多了一行 - parking to wait for <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)，刚好是传入的BlockerDemo对象，park传入的这个参数可以让我们在线程堆栈信息中方便排查问题，其他暂无他用。

LockSupport的其他等待方法，包含有超时时间了，过了超时时间，等待方法会自动返回，让线程继续运行，这些方法在此就不提供示例了，有兴趣的朋友可以自己动动手，练一练。

线程等待和唤醒的3种方式做个对比

到目前为止，已经说了3种让线程等待和唤醒的方法了

  1. 方式1：Object中的wait、notify、notifyAll方法
  2. 方式2：juc中Condition接口提供的await、signal、signalAll方法
  3. 方式3：juc中的LockSupport提供的park、unpark方法

3种方式对比：

Object Condtion LockSupport
前置条件 需要在synchronized中运行 需要先获取Lock的锁 无
无限等待 支持 支持 支持
超时等待 支持 支持 支持
等待到将来某个时间返回 不支持 支持 支持
等待状态中释放锁 会释放 会释放 不会释放
唤醒方法先于等待方法执行，能否唤醒线程 否 否 可以
是否能响应线程中断 是 是 是
线程中断是否会清除中断标志 是 是 否
是否支持等待状态中不响应中断 不支持 支持 不支持

java高并发系列

java高并发系列连载中，总计估计会有四五十篇文章，可以关注公众号：javacode2018，获取最新文章。

java高并发系列 - 第14天：JUC中的LockSupport工具类，必备技能的更多相关文章

  1. java高并发系列 - 第13天:JUC中的Condition对象

    本文目标: synchronized中实现线程等待和唤醒 Condition简介及常用方法介绍及相关示例 使用Condition实现生产者消费者 使用Condition实现同步阻塞队列 Object对 ...

  2. 跟着阿里p7一起学java高并发 - 第19天：JUC中的Executor框架详解1，全面掌握java并发核心技术

    这是java高并发系列第19篇文章. 本文主要内容 介绍Executor框架相关内容 介绍Executor 介绍ExecutorService 介绍线程池ThreadPoolExecutor及案例 介 ...

  3. java高并发系列 - 第12天JUC:ReentrantLock重入锁

    java高并发系列 - 第12天JUC:ReentrantLock重入锁 本篇文章开始将juc中常用的一些类,估计会有十来篇. synchronized的局限性 synchronized是java内置 ...

  4. java高并发系列 - 第15天：JUC中的Semaphore，最简单的限流工具类，必备技能

    这是java高并发系列第15篇文章 Semaphore(信号量)为多线程协作提供了更为强大的控制方法,前面的文章中我们学了synchronized和重入锁ReentrantLock,这2种锁一次都只能 ...

  5. java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能

    这是java高并发系列第16篇文章. 本篇内容 介绍CountDownLatch及使用场景 提供几个示例介绍CountDownLatch的使用 手写一个并行处理任务的工具类 假如有这样一个需求,当我们 ...

  6. java高并发系列 - 第17天：JUC中的循环栅栏CyclicBarrier常见的6种使用场景及代码示例

    这是java高并发系列第17篇. 本文主要内容: 介绍CyclicBarrier 6个示例介绍CyclicBarrier的使用 对比CyclicBarrier和CountDownLatch Cycli ...

  7. java高并发系列 - 第20天：JUC中的Executor框架详解2之ExecutorCompletionService

    这是java高并发系列第20篇文章. 本文内容 ExecutorCompletionService出现的背景 介绍CompletionService接口及常用的方法 介绍ExecutorComplet ...

  8. java高并发系列 - 第21天：java中的CAS操作，java并发的基石

    这是java高并发系列第21篇文章. 本文主要内容 从网站计数器实现中一步步引出CAS操作 介绍java中的CAS及CAS可能存在的问题 悲观锁和乐观锁的一些介绍及数据库乐观锁的一个常见示例 使用ja ...

  9. java高并发系列 - 第22天：java中底层工具类Unsafe，高手必须要了解

    这是java高并发系列第22篇文章,文章基于jdk1.8环境. 本文主要内容 基本介绍. 通过反射获取Unsafe实例 Unsafe中的CAS操作 Unsafe中原子操作相关方法介绍 Unsafe中线 ...

随机推荐

  1. 零元学Expression Blend 4 - Chapter 47 超简单!运用StackPanel配合OpacityMask做出倒影效果

    原文:零元学Expression Blend 4 - Chapter 47 超简单!运用StackPanel配合OpacityMask做出倒影效果 有网友问我如何在Blend内制作出倒影效果 我提供了 ...

  2. SignalR的简单使用(二)

    原文:SignalR的简单使用(二) 之前提到SignalR代理在网页,通过生成的Js来完成相关的功能.但我不禁想一个问题, 难到SignalR的服务端就能寄存在web端吗,通过访问网页能方式才能启动 ...

  3. Lucene Index Search

    转发自:  https://my.oschina.net/u/3777556/blog/1647031 什么是Lucene?? Lucene 是 apache 软件基金会发布的一个开放源代码的全文检索 ...

  4. Qt VS版本添加调试器

    Qt的VS版本默认是不带调试器的,可以去百度一个WinDbg,如下图所示. 将其中的cdb.exe添加到Qt Creator构建和运行的Debuggers标签页即可,如下图所示. http://blo ...

  5. sql小计汇总 rollup用法实例分析

    这里介绍sql server2005里面的一个使用实例: ),city ),score int) GO 1. 只有一个汇总 select province as 省,sum(score) as 分数 ...

  6. vue+TS（CLI3）

    1.用CLI3创建项目 查看当前CLI的版本,如果没有安装CLI3的  使用npm install --global vue-cli来安装CLI 安装好CLI 可以创建项目了 使用vue create ...

  7. C语言实现常用排序算法——冒泡排序

    原理:比较临近的两个元素,只要不符合顺序就进行交换:要点:1.不要越界:2.遍历一遍以后最大的元素就会到最后,所以下次遍历就不用遍历整个数组 void bubble_sort(int a[],int ...

  8. Linux上vim的使用

    .........以下是我在使用vim时的操作经验........... (首先要了解vim主要是命令模式,输入模式,可视化模式,主要区别就是在不同模式下可以完成不同的操作,只是个编辑器,没有必要太纠 ...

  9. 向HashMap中添加1000个元素，设置new HashMap()值为多少合适？

    在已知元素容量的情况下,为了尽量减少碰撞增加查询效率,应该尽量选择较大数的同时避免资源浪费. HashMap底层通过hash值来计算索引位置的源码: 1.重新计算hash值 static final ...

  10. 从电子游戏到DevOps

    在一个项目团队中,开发与运维之间的关系像极了知名大型游戏<刺客信条>里的故事:开发就是追求自由的刺客联盟——我喜欢用各种新颖技术手段去满足用户爸爸那些花里胡哨的需求,你别管那技术好不好用, ...