这是java高并发系列第14篇文章。
本文主要内容:
- 讲解3种让线程等待和唤醒的方法,每种方法配合具体的示例
- 介绍LockSupport主要用法
- 对比3种方式,了解他们之间的区别
LockSupport位于java.util.concurrent(简称juc)包中,算是juc中一个基础类,juc中很多地方都会使用LockSupport,非常重要,希望大家一定要掌握。
关于线程等待/唤醒的方法,前面的文章中我们已经讲过2种了:
- 方式1:使用Object中的wait()方法让线程等待,使用Object中的notify()方法唤醒线程
- 方式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类中的用户线程等待和唤醒的方法,总结一下:
- wait()/notify()/notifyAll()方法都必须放在同步代码(必须在synchronized内部执行)中执行,需要先获取锁
- 线程唤醒的方法(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中方法使用总结:
- 使用Condtion中的线程等待和唤醒方法之前,需要先获取锁。否者会报
IllegalMonitorStateException
异常 - signal()方法先于await()方法之前调用,线程无法被唤醒
Object和Condition的局限性
关于Object和Condtion中线程等待和唤醒的局限性,有以下几点:
- 2中方式中的让线程等待和唤醒的方法能够执行的先决条件是:线程需要先获取锁
- 唤醒方法需要在等待方法之后调用,线程才能够被唤醒
关于这2点,LockSupport都不需要,就能实现线程的等待和唤醒。下面我们来说一下LockSupport类。
LockSupport类介绍
LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作的。
每个线程都有一个许可(permit),permit只有两个值1和0,默认是0。
- 当调用unpark(thread)方法,就会将thread线程的许可permit设置成1(注意多次调用unpark方法,不会累加,permit值还是1)。
- 当调用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种:
- 调用LockSupport.unpark方法
- 调用等待线程的
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:Object中的wait、notify、notifyAll方法
- 方式2:juc中Condition接口提供的await、signal、signalAll方法
- 方式3:juc中的LockSupport提供的park、unpark方法
3种方式对比:
Object | Condtion | LockSupport | |
---|---|---|---|
前置条件 | 需要在synchronized中运行 | 需要先获取Lock的锁 | 无 |
无限等待 | 支持 | 支持 | 支持 |
超时等待 | 支持 | 支持 | 支持 |
等待到将来某个时间返回 | 不支持 | 支持 | 支持 |
等待状态中释放锁 | 会释放 | 会释放 | 不会释放 |
唤醒方法先于等待方法执行,能否唤醒线程 | 否 | 否 | 可以 |
是否能响应线程中断 | 是 | 是 | 是 |
线程中断是否会清除中断标志 | 是 | 是 | 否 |
是否支持等待状态中不响应中断 | 不支持 | 支持 | 不支持 |
java高并发系列
- java高并发系列 - 第1天:必须知道的几个概念
- java高并发系列 - 第2天:并发级别
- java高并发系列 - 第3天:有关并行的两个重要定律
- java高并发系列 - 第4天:JMM相关的一些概念
- java高并发系列 - 第5天:深入理解进程和线程
- java高并发系列 - 第6天:线程的基本操作
- java高并发系列 - 第7天:volatile与Java内存模型
- java高并发系列 - 第8天:线程组
- java高并发系列 - 第9天:用户线程和守护线程
- java高并发系列 - 第10天:线程安全和synchronized关键字
- java高并发系列 - 第11天:线程中断的几种方式
- java高并发系列 - 第12天JUC:ReentrantLock重入锁
- java高并发系列 - 第13天:JUC中的Condition对象
java高并发系列连载中,总计估计会有四五十篇文章,可以关注公众号:javacode2018,获取最新文章。
java高并发系列 - 第14天:JUC中的LockSupport工具类,必备技能的更多相关文章
-
java高并发系列 - 第13天:JUC中的Condition对象
本文目标: synchronized中实现线程等待和唤醒 Condition简介及常用方法介绍及相关示例 使用Condition实现生产者消费者 使用Condition实现同步阻塞队列 Object对 ...
-
跟着阿里p7一起学java高并发 - 第19天:JUC中的Executor框架详解1,全面掌握java并发核心技术
这是java高并发系列第19篇文章. 本文主要内容 介绍Executor框架相关内容 介绍Executor 介绍ExecutorService 介绍线程池ThreadPoolExecutor及案例 介 ...
-
java高并发系列 - 第12天JUC:ReentrantLock重入锁
java高并发系列 - 第12天JUC:ReentrantLock重入锁 本篇文章开始将juc中常用的一些类,估计会有十来篇. synchronized的局限性 synchronized是java内置 ...
-
java高并发系列 - 第15天:JUC中的Semaphore,最简单的限流工具类,必备技能
这是java高并发系列第15篇文章 Semaphore(信号量)为多线程协作提供了更为强大的控制方法,前面的文章中我们学了synchronized和重入锁ReentrantLock,这2种锁一次都只能 ...
-
java高并发系列 - 第16天:JUC中等待多线程完成的工具类CountDownLatch,必备技能
这是java高并发系列第16篇文章. 本篇内容 介绍CountDownLatch及使用场景 提供几个示例介绍CountDownLatch的使用 手写一个并行处理任务的工具类 假如有这样一个需求,当我们 ...
-
java高并发系列 - 第17天:JUC中的循环栅栏CyclicBarrier常见的6种使用场景及代码示例
这是java高并发系列第17篇. 本文主要内容: 介绍CyclicBarrier 6个示例介绍CyclicBarrier的使用 对比CyclicBarrier和CountDownLatch Cycli ...
-
java高并发系列 - 第20天:JUC中的Executor框架详解2之ExecutorCompletionService
这是java高并发系列第20篇文章. 本文内容 ExecutorCompletionService出现的背景 介绍CompletionService接口及常用的方法 介绍ExecutorComplet ...
-
java高并发系列 - 第21天:java中的CAS操作,java并发的基石
这是java高并发系列第21篇文章. 本文主要内容 从网站计数器实现中一步步引出CAS操作 介绍java中的CAS及CAS可能存在的问题 悲观锁和乐观锁的一些介绍及数据库乐观锁的一个常见示例 使用ja ...
-
java高并发系列 - 第22天:java中底层工具类Unsafe,高手必须要了解
这是java高并发系列第22篇文章,文章基于jdk1.8环境. 本文主要内容 基本介绍. 通过反射获取Unsafe实例 Unsafe中的CAS操作 Unsafe中原子操作相关方法介绍 Unsafe中线 ...
随机推荐
-
Myeclipse 不能保存汉字
window-->首选项-->content type-->Text-->Default encoding改为UTF-8,点击update
-
ubuntu 16.04 搭建无线共享热点(PC 无线直连Android移动终端 调试,监控屏幕)
由于android终端usb接口比较松,公司的无线网络使用人过多比较慢,所以想使用PC端无线直连 调试Android终端 配置无线共享 1 网卡要支持 2 安装 plasma-nm sudo apt- ...
-
hdu 4403 dfs
巨麻烦的模拟题orz.... 先确定等号的位置,然后两层dfs,分别算等号前面的和后面的,再比较 话说这题竟然不开long long都能水过 #include <iostream> #in ...
-
hbase命令备忘
http://www.cnblogs.com/linjiqin/archive/2013/03/08/2949339.html HBase 为用户提供了一个非常方便的使用方式, 我们称之为“HBase ...
-
c#中cookies的存取操作
在客户端创建一个username的cookies,其值为gjy,有效期为1天. 方法1: Response.Cookies["username"].Value="zxf& ...
-
CSS应用二
样式中的顺序问题. 如:padding,margin,border,等,都是按照顺时针方向赋值的,及上右下左. Padding:1px 2px 3px 4px;(top:1px;right:2px;b ...
-
2015阿里巴巴安全峰会PPT
有幸参加了阿里巴巴安全峰会,不得不佩服阿里巴巴神盾局,真牛B!然后亲眼目睹了第二天的各大厂商牛(zhuang)B人才上台演讲,有被捧的,有被喷的,呵呵.总的来说,大家的分享精神还是阔以的. 下面是会议 ...
-
liunx驱动----构造和运行模块
以hello world模块为例 #include <linux/init.h> #include <linux/module.h> //在执行 insmod hlello 的 ...
-
Ubuntu快捷键、Ubuntu终端常用命令
Ubuntu快捷键 0.Ctrl + Alt + t 打开终端,在终端命令行操作 1. Ctrl + W: 关闭当前 Nautilus 窗口 2. Ctrl+T: 在 Nautilus 打开新的 Ta ...
-
Zookeeper安装(本地,伪分布式,集群)
概述 ZooKeeper是一个分布式开源框架,提供了协调分布式应用的基本服务,它向外部应用暴露一组通用服务——分布式同步(Distributed Synchronization).命名服务(Namin ...