这期内容当中小编将会给大家带来有关Condition类如何在java项目中使用，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。
专注于为中小企业提供成都网站设计、成都做网站、
外贸网站建设服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业
孝感免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上千余家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。
代码
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) throws InterruptedException {
MyBlockingQueue queue = new MyBlockingQueue<>(1);
for (int i = 0; i < 10; i++) {
int data = i;
new Thread(() -> {
try {
queue.enqueue(data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
System.out.println("1111111");
for(int i=0;i<10;i++){
new Thread(() -> {
try {
queue.dequeue();
}catch (InterruptedException e){
e.printStackTrace();
}
}).start();
}
}
public static class MyBlockingQueue {
int size;//阻塞队列大容量
ReentrantLock lock = new ReentrantLock(true);
LinkedList list=new LinkedList<>();//队列底层实现
Condition notFull = lock.newCondition();//队列满时的等待条件
Condition notEmpty = lock.newCondition();//队列空时的等待条件
public MyBlockingQueue(int size) {
this.size = size;
}
public void enqueue(E e) throws InterruptedException {
lock.lock();
try {
while(list.size() ==size)//队列已满,在notFull条件上等待
notFull.await();
list.add(e);//入队:加入链表末尾
System.out.println("入队：" +e);
notEmpty.signal(); //通知在notEmpty条件上等待的线程
} finally {
lock.unlock();
}
}
public E dequeue() throws InterruptedException {
E e;
lock.lock();
try {
while(list.size() == 0)
notEmpty.await();
e = list.removeFirst();//出队:移除链表首元素
System.out.println("出队："+e);
notFull.signal();//通知在notFull条件上等待的线程
return e;
} finally {
lock.unlock();
}
}
}
}主函数启动了20个线程,前10个是入队的后10个是出队的,我们可以看啊可能输出结果,
new Thread(() -> {
try {
queue.enqueue(data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();注意到线程实现,这个是lambda表达式实现Runable接口.
入队：0
出队：0
入队：2
出队：2
入队：1
出队：1
入队：3
出队：3
入队：4
出队：4
入队：5
出队：5
入队：6
出队：6
入队：7
出队：7
入队：8
出队：8
入队：9
出队：9
可以看到1111111在第一个出队之前,队列容量为1,也就是说头10个入队进程只有第一个成功了,其他均被阻塞.
并且出队入队顺序是按照循环顺序的,说明锁是按照请求顺序来获取的,先到先得,这个说的就是公平锁的意思,其实ReentrantLock既可以是公平锁也可以是非公平锁,其初始化的时候,往构造函数里面传入true则为公平锁,false则为非公平锁.
至于什么是可重入锁,可以看看这篇https://www.jb51.net/article/175192.htm,这个是可重入锁的实例.
其中有一行代码很奇怪,lock.lock();对于我这样的萌新很好奇这个一行代码到底发生了什么,网上很多都是说获得锁,但是"获得"这个实在难以太不具体,所以我自己想象了一下,感觉大致上就是这样的一张图:
结合我粗浅的经验猜测:jvm只有一个就绪队列,就绪队列里面的线程按照队列顺序使用cpu资源,若不加锁,那么所有线程都可以按序取得资源,但是由于面向对象了,所以不好直接控制就绪队列里面线程的入队顺序,这个时候就需要加锁来控制线程的运行顺序来保证处理逻辑正确.(其实也不不是那么严格的队列,就绪状态的线程如果是非公平锁一般会随机先后的运行,说是队列而已,其实就是表达就绪状态)
结合代码的lock()方法,如果有线程进入cpu并且调用lock(),如果该锁没有被其他线程获取过,那么这个线程可以使用cpu时间,如果该锁已经被其他线程获取了,那么该线程会给阻塞,进入阻塞队列, 这样来说的话,其实"获取"这个词也没什么难以理解的,其实就是一个标记而已,然后lock()方法其实就只是判断当前线程是使用cpu时间,还是进入阻塞队列而已..
在看看unlock()方法,由上面的图帮助,其实这个也很好理解,其实就是把阻塞队列的队首的线程出队,然后进入就绪队列而已.
可以猜测,如果运行过程中有多个锁实例,那么就会有多少个可能阻塞的线程,那么除了使用用多个锁,其实还有别的方法来增加阻塞线程,就是使用Condition类,需要指出的是condition类的await()方法,会阻塞当前线程,然后自动解除当前线程获取的锁(这点尤其重要),切换线程,如果其他线程中有唤醒,那么这个在被唤醒后线程会从await()的位置继续往下运行,所以一般要配合while循环使用,如果某线程被唤醒,那么它对于它之前获取的锁,也将重新获取,如果此时该锁已经被另外一个线程获取,且还没有解锁,此时的唤醒就会出错,会出现莫名其妙的错误,所以需要设置一个volatile变量来检测线程的运行状态,所以await()方法前后都要检测.
这里提出一道题,来自leetcode,要求使用condition类来写,
题意:
编写一个可以从 1 到 n 输出代表这个数字的字符串的程序，但是：
如果这个数字可以被 3 整除，输出 "fizz"。
如果这个数字可以被 5 整除，输出 "buzz"。
如果这个数字可以同时被 3 和 5 整除，输出 "fizzbuzz"。
例如，当 n = 15，输出： 1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz。
解法:
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
static void printFizz(int x){
System.out.printf("%d:Fizz,\n",x);
}
static void printBuzz(int x){
System.out.printf("%d:Buzz,\n",x);
}
static void printFizzBuzz(int x){
System.out.printf("%d:FizzBuzz,\n",x);
}
static void printaccpt(int x){
System.out.printf("%d,\n",x);
}
static volatile int now=1;
static ReentrantLock lock=new ReentrantLock();
static Condition k1=lock.newCondition();
public static void test(int n) {
new Thread(()->{
while(now<=n){
lock.lock();
try{
while(now%5==0||now%3!=0){
if(now>n) throw new InterruptedException();
k1.await();
if(now>n) throw new InterruptedException();
}
printFizz(now);
now++;
k1.signalAll();
} catch (InterruptedException e) {
break;
//e.printStackTrace();
} finally{
lock.unlock();
}
}
System.out.println("Thread 1 is over");
}).start();
new Thread(()->{
while(now<=n){
lock.lock();
try{
while(now%5!=0||now%3==0) {
if(now>n) throw new InterruptedException();
k1.await();
if(now>n) throw new InterruptedException();
}
printBuzz(now);
now++;
k1.signalAll();
} catch (InterruptedException e) {
break;
// e.printStackTrace();
} finally{
lock.unlock();
}
}
System.out.println("Thread 2 is over");
}).start();
new Thread(()->{
while(now<=n){
lock.lock();
try{
while(now%5!=0||now%3!=0) {
if(now>n) throw new InterruptedException();
k1.await();
if(now>n) throw new InterruptedException();
}
printFizzBuzz(now);
now++;
k1.signalAll();
} catch (InterruptedException e) {
break;
//Thread.interrupted();
//e.printStackTrace();
} finally{
lock.unlock();
}
}
System.out.println("Thread 3 is over");
}).start();
new Thread(()->{
while(now<=n){
lock.lock();
try{
while(now%5==0||now%3==0) {
if(now>n) throw new InterruptedException();
k1.await();
if(now>n) throw new InterruptedException();
}
printaccpt(now);
now++;
k1.signalAll();
}catch (InterruptedException e){
break;
//Thread.interrupted();
//e.printStackTrace();
}
finally{
lock.unlock();
}
}
System.out.println("Thread 4 is over");
}).start();
}
public static void main(String[] args) throws InterruptedException {
test(30);
}
}上述就是小编为大家分享的Condition类如何在java项目中使用了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注创新互联网站建设公司行业资讯频道。
另外有需要云服务器可以了解下创新互联建站www.cdcxhl.com，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。
分享标题：Condition类如何在java项目中使用-创新互联
文章出自：
http://cdkjz.cn/article/dgoeds.html
