Java并发编程:CountDownLatch、CyclicBarrier和Semaphore

用scons编译STM32F103工程 想用vscode来实现代码的编辑与调试代码,原先这个工程是用STM32CUBEIDE建立的,参照STM32CUBEIDE的编译过程,编写了下面的scons脚本,scons是初次了解,既然是python脚本,那么会什么就怎么写吧。 import os import sys import glob cross_compiler_prefix = 'arm-none-eabi-' CC = cross_compiler_prefix+'gcc' CXX = cross_compiler_prefix+'g+ 阅读详情

Java并发编程:CountDownLatch、CyclicBarrier和Semaphore

  在java 1.5中,提供了一些非常有用的辅助类来帮助我们进行并发编程,比如CountDownLatch,CyclicBarrier和Semaphore,今天我们就来学习一下这三个辅助类的用法。

  以下是本文目录大纲:

  一.CountDownLatch用法

  二.CyclicBarrier用法

  三.Semaphore用法

  若有不正之处请多多谅解,并欢迎批评指正。

  请尊重作者劳动成果,转载请标明原文链接:

  http://www.cnblogs.com/dolphin0520/p/3920397.html

  

一.CountDownLatch用法

  CountDownLatch类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。

  CountDownLatch类只提供了一个构造器:

1
public  CountDownLatch( int  count) {  };   //参数count为计数值

   然后下面这3个方法是CountDownLatch类中最重要的方法:

1
2
3
public  void  await()  throws  InterruptedException { };    //调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行
public  boolean  await( long  timeout, TimeUnit unit)  throws  InterruptedException { };   //和await()类似,只不过等待一定的时间后count值还没变为0的话就会继续执行
public  void  countDown() { };   //将count值减1

   下面看一个例子大家就清楚CountDownLatch的用法了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public  class  Test {
      public  static  void  main(String[] args) {   
          final  CountDownLatch latch =  new  CountDownLatch( 2 );
          
          new  Thread(){
              public  void  run() {
                  try  {
                      System.out.println( "子线程" +Thread.currentThread().getName()+ "正在执行" );
                     Thread.sleep( 3000 );
                     System.out.println( "子线程" +Thread.currentThread().getName()+ "执行完毕" );
                     latch.countDown();
                 }  catch  (InterruptedException e) {
                     e.printStackTrace();
                 }
              };
          }.start();
          
          new  Thread(){
              public  void  run() {
                  try  {
                      System.out.println( "子线程" +Thread.currentThread().getName()+ "正在执行" );
                      Thread.sleep( 3000 );
                      System.out.println( "子线程" +Thread.currentThread().getName()+ "执行完毕" );
                      latch.countDown();
                 }  catch  (InterruptedException e) {
                     e.printStackTrace();
                 }
              };
          }.start();
          
          try  {
              System.out.println( "等待2个子线程执行完毕..." );
             latch.await();
             System.out.println( "2个子线程已经执行完毕" );
             System.out.println( "继续执行主线程" );
         }  catch  (InterruptedException e) {
             e.printStackTrace();
         }
      }
}

   执行结果:

复制代码
线程Thread-0正在执行
线程Thread-1正在执行
等待2个子线程执行完毕...
线程Thread-0执行完毕
线程Thread-1执行完毕
2个子线程已经执行完毕
继续执行主线程
复制代码

二.CyclicBarrier用法

  字面意思回环栅栏,通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后,CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier,当调用await()方法之后,线程就处于barrier了。

  CyclicBarrier类位于java.util.concurrent包下,CyclicBarrier提供2个构造器:

1
2
3
4
5
public  CyclicBarrier( int  parties, Runnable barrierAction) {
}
 
public  CyclicBarrier( int  parties) {
}

  参数parties指让多少个线程或者任务等待至barrier状态;参数barrierAction为当这些线程都达到barrier状态时会执行的内容。

  然后CyclicBarrier中最重要的方法就是await方法,它有2个重载版本:

1
2
public  int  await()  throws  InterruptedException, BrokenBarrierException { };
public  int  await( long  timeout, TimeUnit unit) throws  InterruptedException,BrokenBarrierException,TimeoutException { };

   第一个版本比较常用,用来挂起当前线程,直至所有线程都到达barrier状态再同时执行后续任务;

  第二个版本是让这些线程等待至一定的时间,如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

  下面举几个例子就明白了:

  假若有若干个线程都要进行写数据操作,并且只有所有线程都完成写数据操作之后,这些线程才能继续做后面的事情,此时就可以利用CyclicBarrier了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public  class  Test {
     public  static  void  main(String[] args) {
         int  N =  4 ;
         CyclicBarrier barrier  =  new  CyclicBarrier(N);
         for ( int  i= 0 ;i<N;i++)
             new  Writer(barrier).start();
     }
     static  class  Writer  extends  Thread{
         private  CyclicBarrier cyclicBarrier;
         public  Writer(CyclicBarrier cyclicBarrier) {
             this .cyclicBarrier = cyclicBarrier;
         }
 
         @Override
         public  void  run() {
             System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );
             try  {
                 Thread.sleep( 5000 );       //以睡眠来模拟写入数据操作
                 System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕,等待其他线程写入完毕" );
                 cyclicBarrier.await();
             }  catch  (InterruptedException e) {
                 e.printStackTrace();
             } catch (BrokenBarrierException e){
                 e.printStackTrace();
             }
             System.out.println( "所有线程写入完毕,继续处理其他任务..." );
         }
     }
}

   执行结果:

复制代码
线程Thread-0正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2写入数据完毕,等待其他线程写入完毕
线程Thread-0写入数据完毕,等待其他线程写入完毕
线程Thread-3写入数据完毕,等待其他线程写入完毕
线程Thread-1写入数据完毕,等待其他线程写入完毕
所有线程写入完毕,继续处理其他任务...
所有线程写入完毕,继续处理其他任务...
所有线程写入完毕,继续处理其他任务...
所有线程写入完毕,继续处理其他任务...
复制代码

  从上面输出结果可以看出,每个写入线程执行完写数据操作之后,就在等待其他线程写入操作完毕。

  当所有线程线程写入操作完毕之后,所有线程就继续进行后续的操作了。

  如果说想在所有线程写入操作完之后,进行额外的其他操作可以为CyclicBarrier提供Runnable参数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public  class  Test {
     public  static  void  main(String[] args) {
         int  N =  4 ;
         CyclicBarrier barrier  =  new  CyclicBarrier(N, new  Runnable() {
             @Override
             public  void  run() {
                 System.out.println( "当前线程" +Thread.currentThread().getName());   
             }
         });
         
         for ( int  i= 0 ;i<N;i++)
             new  Writer(barrier).start();
     }
     static  class  Writer  extends  Thread{
         private  CyclicBarrier cyclicBarrier;
         public  Writer(CyclicBarrier cyclicBarrier) {
             this .cyclicBarrier = cyclicBarrier;
         }
 
         @Override
         public  void  run() {
             System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );
             try  {
                 Thread.sleep( 5000 );       //以睡眠来模拟写入数据操作
                 System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕,等待其他线程写入完毕" );
                 cyclicBarrier.await();
             }  catch  (InterruptedException e) {
                 e.printStackTrace();
             } catch (BrokenBarrierException e){
                 e.printStackTrace();
             }
             System.out.println( "所有线程写入完毕,继续处理其他任务..." );
         }
     }
}

   运行结果:

复制代码
线程Thread-0正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2正在写入数据...
线程Thread-3正在写入数据...
线程Thread-0写入数据完毕,等待其他线程写入完毕
线程Thread-1写入数据完毕,等待其他线程写入完毕
线程Thread-2写入数据完毕,等待其他线程写入完毕
线程Thread-3写入数据完毕,等待其他线程写入完毕
当前线程Thread-3
所有线程写入完毕,继续处理其他任务...
所有线程写入完毕,继续处理其他任务...
所有线程写入完毕,继续处理其他任务...
所有线程写入完毕,继续处理其他任务...
复制代码

  从结果可以看出,当四个线程都到达barrier状态后,会从四个线程中选择一个线程去执行Runnable。

   下面看一下为await指定时间的效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public  class  Test {
     public  static  void  main(String[] args) {
         int  N =  4 ;
         CyclicBarrier barrier  =  new  CyclicBarrier(N);
         
         for ( int  i= 0 ;i<N;i++) {
             if (i<N- 1 )
                 new  Writer(barrier).start();
             else  {
                 try  {
                     Thread.sleep( 5000 );
                 }  catch  (InterruptedException e) {
                     e.printStackTrace();
                 }
                 new  Writer(barrier).start();
             }
         }
     }
     static  class  Writer  extends  Thread{
         private  CyclicBarrier cyclicBarrier;
         public  Writer(CyclicBarrier cyclicBarrier) {
             this .cyclicBarrier = cyclicBarrier;
         }
 
         @Override
         public  void  run() {
             System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );
             try  {
                 Thread.sleep( 5000 );       //以睡眠来模拟写入数据操作
                 System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕,等待其他线程写入完毕" );
                 try  {
                     cyclicBarrier.await( 2000 , TimeUnit.MILLISECONDS);
                 }  catch  (TimeoutException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }  catch  (InterruptedException e) {
                 e.printStackTrace();
             } catch (BrokenBarrierException e){
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName()+ "所有线程写入完毕,继续处理其他任务..." );
         }
     }
}

   执行结果:

复制代码
线程Thread-0正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2写入数据完毕,等待其他线程写入完毕
线程Thread-0写入数据完毕,等待其他线程写入完毕
线程Thread-1写入数据完毕,等待其他线程写入完毕
线程Thread-3正在写入数据...
java.util.concurrent.TimeoutException
Thread-1所有线程写入完毕,继续处理其他任务...
Thread-0所有线程写入完毕,继续处理其他任务...
    at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
    at java.util.concurrent.CyclicBarrier.await(Unknown Source)
    at com.cxh.test1.Test$Writer.run(Test.java:58)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
    at java.util.concurrent.CyclicBarrier.await(Unknown Source)
    at com.cxh.test1.Test$Writer.run(Test.java:58)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
    at java.util.concurrent.CyclicBarrier.await(Unknown Source)
    at com.cxh.test1.Test$Writer.run(Test.java:58)
Thread-2所有线程写入完毕,继续处理其他任务...
java.util.concurrent.BrokenBarrierException
线程Thread-3写入数据完毕,等待其他线程写入完毕
    at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
    at java.util.concurrent.CyclicBarrier.await(Unknown Source)
    at com.cxh.test1.Test$Writer.run(Test.java:58)
Thread-3所有线程写入完毕,继续处理其他任务...
复制代码

  上面的代码在main方法的for循环中,故意让最后一个线程启动延迟,因为在前面三个线程都达到barrier之后,等待了指定的时间发现第四个线程还没有达到barrier,就抛出异常并继续执行后面的任务。

  另外CyclicBarrier是可以重用的,看下面这个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public  class  Test {
     public  static  void  main(String[] args) {
         int  N =  4 ;
         CyclicBarrier barrier  =  new  CyclicBarrier(N);
         
         for ( int  i= 0 ;i<N;i++) {
             new  Writer(barrier).start();
         }
         
         try  {
             Thread.sleep( 25000 );
         }  catch  (InterruptedException e) {
             e.printStackTrace();
         }
         
         System.out.println( "CyclicBarrier重用" );
         
         for ( int  i= 0 ;i<N;i++) {
             new  Writer(barrier).start();
         }
     }
     static  class  Writer  extends  Thread{
         private  CyclicBarrier cyclicBarrier;
         public  Writer(CyclicBarrier cyclicBarrier) {
             this .cyclicBarrier = cyclicBarrier;
         }
 
         @Override
         public  void  run() {
             System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );
             try  {
                 Thread.sleep( 5000 );       //以睡眠来模拟写入数据操作
                 System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕,等待其他线程写入完毕" );
             
                 cyclicBarrier.await();
             }  catch  (InterruptedException e) {
                 e.printStackTrace();
             } catch (BrokenBarrierException e){
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName()+ "所有线程写入完毕,继续处理其他任务..." );
         }
     }
}

   执行结果:

复制代码
线程Thread-0正在写入数据...
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1写入数据完毕,等待其他线程写入完毕
线程Thread-3写入数据完毕,等待其他线程写入完毕
线程Thread-2写入数据完毕,等待其他线程写入完毕
线程Thread-0写入数据完毕,等待其他线程写入完毕
Thread-0所有线程写入完毕,继续处理其他任务...
Thread-3所有线程写入完毕,继续处理其他任务...
Thread-1所有线程写入完毕,继续处理其他任务...
Thread-2所有线程写入完毕,继续处理其他任务...
CyclicBarrier重用
线程Thread-4正在写入数据...
线程Thread-5正在写入数据...
线程Thread-6正在写入数据...
线程Thread-7正在写入数据...
线程Thread-7写入数据完毕,等待其他线程写入完毕
线程Thread-5写入数据完毕,等待其他线程写入完毕
线程Thread-6写入数据完毕,等待其他线程写入完毕
线程Thread-4写入数据完毕,等待其他线程写入完毕
Thread-4所有线程写入完毕,继续处理其他任务...
Thread-5所有线程写入完毕,继续处理其他任务...
Thread-6所有线程写入完毕,继续处理其他任务...
Thread-7所有线程写入完毕,继续处理其他任务...
复制代码

  从执行结果可以看出,在初次的4个线程越过barrier状态后,又可以用来进行新一轮的使用。而CountDownLatch无法进行重复使用。

三.Semaphore用法

  Semaphore翻译成字面意思为 信号量,Semaphore可以控同时访问的线程个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可。

  Semaphore类位于java.util.concurrent包下,它提供了2个构造器:

1
2
3
4
5
6
public  Semaphore( int  permits) {           //参数permits表示许可数目,即同时可以允许多少线程进行访问
     sync =  new  NonfairSync(permits);
}
public  Semaphore( int  permits,  boolean  fair) {     //这个多了一个参数fair表示是否是公平的,即等待时间越久的越先获取许可
     sync = (fair)?  new  FairSync(permits) :  new  NonfairSync(permits);
}

   下面说一下Semaphore类中比较重要的几个方法,首先是acquire()、release()方法:

1
2
3
4
public  void  acquire()  throws  InterruptedException {  }      //获取一个许可
public  void  acquire( int  permits)  throws  InterruptedException { }     //获取permits个许可
public  void  release() { }           //释放一个许可
public  void  release( int  permits) { }     //释放permits个许可

  acquire()用来获取一个许可,若无许可能够获得,则会一直等待,直到获得许可。

  release()用来释放许可。注意,在释放许可之前,必须先获获得许可。

  这4个方法都会被阻塞,如果想立即得到执行结果,可以使用下面几个方法:

1
2
3
4
public  boolean  tryAcquire() { };     //尝试获取一个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public  boolean  tryAcquire( long  timeout, TimeUnit unit)  throws  InterruptedException { };   //尝试获取一个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false
public  boolean  tryAcquire( int  permits) { };  //尝试获取permits个许可,若获取成功,则立即返回true,若获取失败,则立即返回false
public  boolean  tryAcquire( int  permits,  long  timeout, TimeUnit unit)  throws  InterruptedException { };  //尝试获取permits个许可,若在指定的时间内获取成功,则立即返回true,否则则立即返回false

   另外还可以通过availablePermits()方法得到可用的许可数目。

  下面通过一个例子来看一下Semaphore的具体使用:

  假若一个工厂有5台机器,但是有8个工人,一台机器同时只能被一个工人使用,只有使用完了,其他工人才能继续使用。那么我们就可以通过Semaphore来实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public  class  Test {
     public  static  void  main(String[] args) {
         int  N =  8 ;             //工人数
         Semaphore semaphore =  new  Semaphore( 5 );  //机器数目
         for ( int  i= 0 ;i<N;i++)
             new  Worker(i,semaphore).start();
     }
     
     static  class  Worker  extends  Thread{
         private  int  num;
         private  Semaphore semaphore;
         public  Worker( int  num,Semaphore semaphore){
             this .num = num;
             this .semaphore = semaphore;
         }
         
         @Override
         public  void  run() {
             try  {
                 semaphore.acquire();
                 System.out.println( "工人" + this .num+ "占用一个机器在生产..." );
                 Thread.sleep( 2000 );
                 System.out.println( "工人" + this .num+ "释放出机器" );
                 semaphore.release();           
             }  catch  (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
}

    执行结果:

  View Code

  

  下面对上面说的三个辅助类进行一个总结:

  1)CountDownLatch和CyclicBarrier都能够实现线程之间的等待,只不过它们侧重点不同:

    CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后,它才执行;

    而CyclicBarrier一般用于一组线程互相等待至某个状态,然后这一组线程再同时执行;

    另外,CountDownLatch是不能够重用的,而CyclicBarrier是可以重用的。

  2)Semaphore其实和锁有点类似,它一般用于控制对某组资源的访问权限。

  参考资料:

  《Java编程思想》

  http://www.itzhai.com/the-introduction-and-use-of-a-countdownlatch.html

  http://leaver.me/archives/3220.html

  http://developer.51cto.com/art/201403/432095.htm

  http://blog.youkuaiyun.com/yanhandle/article/details/9016329

  http://blog.youkuaiyun.com/cutesource/article/details/5780740

  http://www.cnblogs.com/whgw/archive/2011/09/29/2195555.html

AUTOSAR进阶图解==>AUTOSAR_EXP_VFB AUTOSAR虚拟功能总线(VFB)摘要 AUTOSAR虚拟功能总线(VFB)是汽车开放系统架构中的核心抽象概念,为分布式电子系统提供统一通信模型。VFB允许软件组件在不了解底层物理通信机制的情况下交互,通过运行时环境(RTE)实现组件间的数据交换。系统配置过程将抽象的VFB视图转换为具体实现,包括组件到ECU的映射和通信机制选择。VFB采用"last-is-best"语义进行数据通信,并支持模式管理机制,使组件能根据系统状态调整行为。此外,VFB还支持与非AUTOSAR系统的交互,通常 阅读详情

相关推荐

CMap数据库学习及结果可视化

CMap是一个生物信息学数据库和工具,旨在通过比较基因表达谱来揭示药物、基因和疾病之间的潜在关联。CMap数据库主要用于寻找药物、化合物和生物过程之间的关系,并用于药物重定位(drug repurposing)和疾病机制研究。

zfyyzhys的博客 5603

JAVA中J.U.C 包下并发类的应用

JUC包中的锁应用 Lock接口及ReentrantLock对象分析及应用? 并发编程领域,有两大核心问题:一个是互斥,即同一时刻只允许一个线程访问共享资源;另一个是同步,即线程之间如何通信、协作。这两大问题,在Java SDK 并发包可通过 Lock 和 Condition 两个接口来实现,其中Lock 用于解决互斥问题,Condition 用于解决同步问题。Java SDK 并发包里的 Lock 接口中,不仅有支持类似 synchronized 的隐式加锁方法,还支持超时、非阻塞、可中断的方式获取锁,

雨田说码 1743

TruckSim与Simulink联合仿真中的车轮转角精确控制策略

本文深入探讨了TruckSim与Simulink联合仿真中实现车轮转角精确控制的关键策略。针对多轴车辆路径跟踪时转角指令失灵的常见问题,核心在于正确配置TruckSim转向轴的外部输入模式(Advanced Settings),并确保仿真接口的稳定搭建。文章详细解析了从单轴到多轴协同转向的配置方法,并提供了提升MPC路径跟踪精度的实战技巧与调试经验。

weixin_29035147的博客 372

简述CyclicBarrier、CountDownLatch和Semaphore

文章目录前言一. 概念篇1.1 CyclicBarrier1.2. CountDownLatch1.3. Semaphore二. 案例篇2.1. CyclicBarrier2.2. CountDownLatch2.3. Semaphore三. 深入篇3.1. CyclicBarrier3.2. CountDownLatch3.3. Semaphore3.4. CAS3.5. AQS 前言

米二的博客 3760

从零到一:手把手教你用海康VisionMaster完成第一个字符识别项目(附完整流程与避坑点)

本文详细介绍了如何使用海康VisionMaster完成首个字符识别项目,涵盖从环境搭建、图像预处理到系统集成的完整流程。特别分享了Blob分析配置、字符识别优化等实战技巧,帮助开发者避开常见陷阱,快速掌握VisionMaster的基本操作,提升工业自动化场景下的字符识别效率。

weixin_29313423的博客 672

【学习体会】Lighttools8.4.0:矩形阵列光源+条形光源的光学仿真分析

在solidworks中设计了条形光源的基本结构: 由32*6个矩形led组成矩形光源阵列,如下所示 另存为step文件后,导入lighttools中,这里要设置模型的光学属性为:吸收体(机械) 因为我们设计的光源模型是一个整体,我们不能单个面的设置光源,比如说, 这样做的话并不会是这个面设置为光源,而是会把做一个模型都变成一个光源,如下 这显然不是我们想要的 那么,我们就在led位置上放置一个矩形面光源, 这样我们就放置好了一个面光源, 但是问题是,还有191...

LeonJin的博客 1万+

Semaphore CyclicBarrier ReentrantLock

ReentrantLock Semaphore CyclicBarrier

一个想交朋友的陌生人 974

使用Android GPS api 实现一个轨迹记录的小功能

引入 市场上的跑步软件已经是非常多了,如咕咚和悦跑圈还有其他,很多大厂也在涉足这个方面。而最简单的运动跑步,最近几年也因简单,不限场地,运动效果出众备受大众喜欢。 我的这篇文章的内容很多也是从网上学习其他的博客内容,外加利用android自身的提供的api实现的,希望能对有这方面需求的朋友有所帮助。 介绍 先上两张图,界面比较丑,不过一些数据基本都有了,这个图片是临时要用截取的,所以轨迹线很短,之前

尝试着去了解代码 1万+

Java并发编程第9讲——CountDownLatch、CyclicBarrier和Semaphore(万字详解)

在JDK的并发包(JUC)里提供了几个非常有用的并发工具类。CountDownLatch、CyclicBarrier和Samaphore工具类提供了一种并发流程控制的手段,这同样也是面试和工作中的一个重要知识点,本文将从它们的定义、常用方法、代码示例及核心源码的分析等几个要点详细介绍一下。

让~学习~成为一种习惯(橡 皮 人の技术博客) 2877

基于ART算法和SIRT算法的超声CT反演及MATLAB代码实现

在超声CT中,反演算法起着至关重要的作用,它通过从测量数据中恢复出目标物体的内部结构。本文将介绍基于ART算法(Algebraic Reconstruction Technique)和SIRT算法(Simultaneous Iterative Reconstruction Technique)的超声CT反演方法,并提供相应的MATLAB代码实现。本文介绍了基于ART算法和SIRT算法的超声CT反演方法,并提供了相应的MATLAB代码示例。基于ART算法和SIRT算法的超声CT反演及MATLAB代码实现。

2301_79326510的博客 569

实例详解C++程序的五大内存分区

本文详细讲述C++程序在运行时的5大内存分区。 下面使用日常开发中的编程实例,详细介绍一下这5个分区,以便大家能更深刻的理解这5大内存分区。 1、栈内存区 栈内存区是我们用的最多的分区,只要有函数的地方都会使用到这个分区。栈分区是用来存放函数参数及函数局部变量值的内存区,是由编译器在编译时自动分配和释放的。 函数中的参数与函数中的局部变量占用的内存是代码执行到函数(进入函数)是分配的,在............

dvlinker的技术专栏 1万+

JAVA并发编程: CountDownLatch,CyclicBarrier 和 Semaphore

CyclicBarrier CountDownLatch Semaphore Reference / 参考: https://www.fangzhipeng.com/javainterview/2019/03/21/latch-barrier-semaphore.html

村里的原振侠的博客 364

论文阅读:ICLR 2026 Breaking and Fixing Defenses Against Control-Flow Hijacking in Multi-Agent Systems

该论文首先系统阐述了控制流劫持攻击的核心机理。此类攻击通过操纵多智能体系统的编排机制,诱导系统执行非安全操作,进而实现敏感信息窃取。攻击者将恶意指令伪装成环境错误信息,借助可信代理传递至系统编排器,利用"困惑副手"漏洞绕过传统安全防线。该论文指出,现有防御方案如LlamaFirewall所依赖的对齐检查机制存在根本性局限——安全目标与功能需求之间存在不可调和的内在冲突。该论文的核心贡献体现在攻防两个维度。

CSPhD-winston的博客 495
上一篇: java多态继承中需要特别注意的点
下一篇: String,StringBuffer,StringBuilder的区别。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值