java多线程加锁以及Condition类的使用实例解析

这篇文章主要介绍了java多线程加锁以及Condition类的使用实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

看了网上非常多的运行代码,很多都是重复的再说一件事,可能对于java老鸟来说,理解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<Integer> 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<E> {
    int size;//阻塞队列最大容量
    ReentrantLock lock = new ReentrantLock(true);
    LinkedList<E> 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);
  }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Java concurrency之Condition条件_动力节点Java学院整理

    Condition介绍 Condition的作用是对锁进行更精确的控制.Condition中的await()方法相当于Object的wait()方法,Condition中的signal()方法相当于Object的notify()方法,Condition中的signalAll()相当于Object的notifyAll()方法.不同的是,Object中的wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的:而Condition

  • Java编程之多线程死锁与线程间通信简单实现代码

    死锁定义 死锁是指两个或者多个线程被永久阻塞的一种局面,产生的前提是要有两个或两个以上的线程,并且来操作两个或者多个以上的共同资源:我的理解是用两个线程来举例,现有线程A和B同时操作两个共同资源a和b,A操作a的时候上锁LockA,继续执行的时候,A还需要LockB进行下面的操作,这个时候b资源在被B线程操作,刚好被上了锁LockB,假如此时线程B刚好释放了LockB则没有问题,但没有释放LockB锁的时候,线程A和B形成了对LockB锁资源的争夺,从而造成阻塞,形成死锁:具体其死锁代码如下:

  • Java多线程之死锁的出现和解决方法

    什么是死锁? 死锁是这样一种情形:多个线程同时被阻塞,它们中的一个或者全部都在等待某个资源被释放.由于线程被无限期地阻塞,因此程序不能正常运行.形象的说就是:一个宝藏需要两把钥匙来打开,同时间正好来了两个人,他们一人一把钥匙,但是双方都再等着对方能交出钥匙来打开宝藏,谁都没释放自己的那把钥匙.就这样这俩人一直僵持下去,直到开发人员发现这个局面. 导致死锁的根源在于不适当地运用"synchronized"关键词来管理线程对特定对象的访问."synchronized"关

  • 详解Java多线程编程中互斥锁ReentrantLock类的用法

    0.关于互斥锁 所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和synchronized机制的主要区别: synchronized机制提供了对与每个对象相关的隐式监视器锁的访问, 并强制所有锁获取和释放均要出现在一个块结构中, 当获取了多个锁时, 它们必须以相反的顺序释放. synchronized机制对锁的释放是

  • java 多线程-锁详解及示例代码

    自 Java 5 开始,java.util.concurrent.locks 包中包含了一些锁的实现,因此你不用去实现自己的锁了.但是你仍然需要去了解怎样使用这些锁. 一个简单的锁 让我们从 java 中的一个同步块开始: public class Counter{ private int count = 0; public int inc(){ synchronized(this){ return ++count; } } } 可以看到在 inc()方法中有一个 synchronized(th

  • Java多线程编程中使用Condition类操作锁的方法详解

    Condition的作用是对锁进行更精确的控制.Condition中的await()方法相当于Object的wait()方法,Condition中的signal()方法相当于Object的notify()方法,Condition中的signalAll()相当于Object的notifyAll()方法.不同的是,Object中的wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的:而Condition是需要与"互斥

  • Java编程中实现Condition控制线程通信

    java中控制线程通信的方法 1.传统的方式:利用synchronized关键字来保证同步,结合wait(),notify(),notifyAll()控制线程通信.不灵活. 2.利用Condition控制线程通信,灵活. 3.利用管道pipe进行线程通信,不推荐 4.利用BlockingQueue控制线程通信 本文就讲解利用Condition控制线程通信,非常灵活的方式. Condition类是用来保持Lock对象的协调调用. 对Lock不了解的可以参考:Java线程同步Lock同步锁代码示例

  • Java多线程产生死锁的必要条件

    线程死锁是指由于两个或者多个线程互相持有对方所需要的资源,导致这些线程处于等待状态,无法前往执行.当线程进入对象的synchronized代码块时,便占有了资源,直到它退出该代码块或者调用wait方法,才释放资源,在此期间,其他线程将不能进入该代码块.当线程互相持有对方所需要的资源时,会互相等待对方释放资源,如果线程都不主动释放所占有的资源,将产生死锁. 死锁是操作系统里里面的一个重要的概念,死锁通常发生在并发的场景里. 死锁是多个进程或线程,彼此争抢资源而陷入僵局的一种情况. 在笔者参加的多次

  • java多线程加锁以及Condition类的使用实例解析

    这篇文章主要介绍了java多线程加锁以及Condition类的使用实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 看了网上非常多的运行代码,很多都是重复的再说一件事,可能对于java老鸟来说,理解java的多线程是非常容易的事情,但是对于我这样的菜鸟来说,这个实在有点难,可能是我太菜了,网上重复的陈述对于我理解这个问题一点帮助都没有.所以这里我写下我对于这个问题的理解,目的是为了防止我忘记. 还是从代码实例开始讲起: 代码 import

  • Java多线程中关于join方法的使用实例解析

    先上代码 新建一个Thread,代码如下: package com.thread.test; public class MyThread extends Thread { private String name; public MyThread(String name) { this.name = name; } @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(name+"[&

  • Java多线程之同步工具类CyclicBarrier

    目录 1 CyclicBarrier方法说明 2 CyclicBarrier实例 3 CyclicBarrier源码解析 CyclicBarrier构造函数 await方法 nextGeneration的源码 breakBarrier源码 isBroken方法 reset方法 getNumberWaiting方法 前言: CyclicBarrier是一个同步工具类,它允许一组线程互相等待,直到达到某个公共屏障点.与CountDownLatch不同的是该barrier在释放线程等待后可以重用,所以

  • Java多线程读写锁ReentrantReadWriteLock类详解

    目录 ReentrantReadWriteLock 读读共享 写写互斥 读写互斥 源码分析 写锁的获取与释放 读锁的获取与释放 参考文献 真实的多线程业务开发中,最常用到的逻辑就是数据的读写,ReentrantLock虽然具有完全互斥排他的效果(即同一时间只有一个线程正在执行lock后面的任务),这样做虽然保证了实例变量的线程安全性,但效率却是非常低下的.所以在JDK中提供了一种读写锁ReentrantReadWriteLock类,使用它可以加快运行效率. 读写锁表示两个锁,一个是读操作相关的锁

  • 教你如何使用Java多线程编程LockSupport工具类

    LockSupport类 用于创建锁和其他同步类的基本线程阻塞原语,此类与使用它的每个线程关联一个许可.如果获得许可,将立即返回对park的调用,并在此过程中消耗掉它:否则may会被阻止.调用unpark可使许可证可用(如果尚不可用).(不过与信号量不同,许可证不会累积.最多只能有一个.) 方法park和unpark提供了有效的阻塞和解阻塞线程的方法,这些线程不会遇到导致已弃用的方法Thread.suspend和Thread.resume无法用于以下问题:由于许可,在调用park的一个线程与试图

  • Java多线程之同步工具类Exchanger

    目录 1 Exchanger 介绍 2 Exchanger 实例 exchange等待超时 3 实现原理 1 Exchanger 介绍 前面分别介绍了CyclicBarrier.CountDownLatch.Semaphore,现在介绍并发工具类中的最后一个Exchange. Exchanger 是一个用于线程间协作的工具类,Exchanger用于进行线程间的数据交换,它提供一个同步点,在这个同步点,两个线程可以交换彼此的数据.这两个线程通过exchange 方法交换数据,如果第一个线程先执行e

  • Java多线程之同步工具类CountDownLatch

    前言: CountDownLatch是一个同步工具类,它允许一个或多个线程一直等待,直到其他线程执行完后再执行.例如,应用程序的主线程希望在负责启动框架服务的线程已经启动所有框架服务之后执行. 1 CountDownLatch主要方法 void await():如果当前count大于0,当前线程将会wait,直到count等于0或者中断. PS:当count等于0的时候,再去调用await() , 线程将不会阻塞,而是立即运行.后面可以通过源码分析得到. boolean await(long t

  • Java原子变量类原理及实例解析

    这篇文章主要介绍了Java原子变量类原理及实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.原子变量类简介 为何需要原子变量类 保证线程安全是 Java 并发编程必须要解决的重要问题.Java 从原子性.可见性.有序性这三大特性入手,确保多线程的数据一致性. 确保线程安全最常见的做法是利用锁机制(Lock.sychronized)来对共享数据做互斥同步,这样在同一个时刻,只有一个线程可以执行某个方法或者某个代码块,那么操作必然是原子性

  • java多线程中执行多个程序的实例分析

    我们知道多线程因为同时处理子线程的能力,对于程序运行来说,能够达到很高的效率.不过很多人对于多线程的执行方法还没有尝试过,本篇我们将为大家介绍创建线程的方法,在这个基础上,对程序执行多条命令的方法进行展示.下面我们就来看看具体的操作步骤吧. 1.创建线程对象我们需要用到Thread类,该类是java.lang包下的一个类,所以调用时不需要导入包.下面我们先创建一个新的子类来继承Thread类,然后通过重写run()方法(将需要同时进行的任务写进run()方法内),来达到让程序同时做多件事情的目的

  • Java编程线程同步工具Exchanger的使用实例解析

    本文研究的主要是Java编程线程同步工具Exchanger的使用,下面看看具体内容. 如果两个线程在运行过程中需要交换彼此的信息,比如一个数据或者使用的空间,就需要用到Exchanger这个类,Exchanger为线程交换信息提供了非常方便的途径,它可以作为两个线程交换对象的同步点,只有当每个线程都在进入 exchange ()方法并给出对象时,才能接受其他线程返回时给出的对象. 每次只能两个线程交换数据,如果有多个线程,也只有两个能交换数据.下面看个通俗的例子:一手交钱一首交货! public

随机推荐