×

cyclicbarrier 字符

cyclicbarrier(Java获取字符串中字母出现的个数)

admin admin 发表于2022-09-05 01:39:33 浏览116 评论0

抢沙发发表评论

本文目录

Java获取字符串中字母出现的个数


import java.util.HashMap;
import java.util.Set;
import java.util.concurrent.CyclicBarrier;
public class TestStrNumber {
private static String str1 = “sdfg,hellozx,sdfcv-waadfa,fsasdfxcvdf“;
public static void main(String args) {
String ss=getUnmatchStr(“hello“);
getCharNum(ss);
}
public static void getCharNum(String ss){
String sb=““;
for (int i = 0; i 《 ss.length(); i++) {
if (ss.charAt(i)!=’-’&&ss.charAt(i)!=’,’) {
sb+=ss.charAt(i);
}
}
char cs=sb.toCharArray();
int oldNum=0;
HashMap《Character, Integer》 map = new HashMap《Character, Integer》();
for (char c : cs) {
if (map.containsKey(c)) {
oldNum=map.get(c);
map.put(c, oldNum+1);
}else {
map.put(c, 1);
}
}
Set《Character》 keys = map.keySet();
for(Character c:keys){
System.out.print(c+“(出现“+map.get(c)+“次)“);
}
}
public static String getUnmatchStr(String s){
String str2=““;
int startIndex=0;
int endIndex=0;
if (str1.contains(s)) {
startIndex = str1.indexOf(s);
endIndex=startIndex+s.length();
}
str2 = str1.substring(0, startIndex)+str1.substring(endIndex, str1.length());
return str2;
}
}

java中cyclicbarrier 和 countdownlatch有什么不同


cyclibarriar 就是栅栏,顾名思义:就是一个拦截的装置。多个线程start后,在栅栏处阻塞住,一般定义栅栏的时候会定义有多少个线程。比如定义为4个,那么有三个线程到栅栏处,就阻塞住,如果没有第四个,就会一直阻塞,知道启动第四个线程到栅栏

java并发包有哪些类


1、CyclicBarrier

一个同步辅助类,允许一组线程相互等待,直到这组线程都到达某个公共屏障点。该barrier在释放等待线程后可以重用,因此称为循环的barrier。

来个示例:

[java] view plain copy

  • package test;  

  • import java.util.concurrent.CyclicBarrier;  

  • import java.util.concurrent.ExecutorService;  

  • import java.util.concurrent.Executors;  

  • public class Recipes_CyclicBarrier {  

  • public static CyclicBarrier barrier = new CyclicBarrier(10);  

  • public static void main(String args){  

  • ExecutorService executor = Executors.newCachedThreadPool();//FixedThreadPool(10);  

  • for(int i=1;i《=10;i++){  

  • executor.submit(new Thread(new Runner(i+“号选手“)));  

  • }  

  • executor.shutdown();  

  • }  

  • }  

  • class Runner implements Runnable{  

  • private String name;  

  • public Runner(String name){  

  • this.name = name;  

  • }  

  • @Override  

  • public void run() {  

  • System.out.println(name + “准备好了。“);  

  • try {  

  • Recipes_CyclicBarrier.barrier.await();  //此处就是公共屏障点,所有线程到达之后,会释放所有等待的线程  

  • } catch (Exception e) {  

  • }  

  • System.out.println(name + “起跑!“);  

  • }  

  • }  

  • 2、CountDownLatch

    CountDownLatch和CyclicBarrier有点类似,但是还是有些区别的。CountDownLatch也是一个同步辅助类,它允许一个或者多个线程一直等待,直到正在其他线程中执行的操作完成。它是等待正在其他线程中执行的操作,并不是线程之间相互等待。CountDownLatch初始化时需要给定一个计数值,每个线程执行完之后,必须调用countDown()方法使计数值减1,直到计数值为0,此时等待的线程才会释放。-cyclicbarrier

    来个示例:

    [java] view plain copy

  • package test;  

  • import java.util.concurrent.CountDownLatch;  

  • import java.util.concurrent.CyclicBarrier;  

  • import java.util.concurrent.ExecutorService;  

  • import java.util.concurrent.Executors;  

  • public class CountDownLatchDemo {  

  • public static CountDownLatch countDownLatch = new CountDownLatch(10);//初始化计数值  

  • public static void main(String args){  

  • ExecutorService executor = Executors.newCachedThreadPool();//FixedThreadPool(10);  

  • for(int i=1;i《=10;i++){  

  • executor.submit(new Thread(new Runner1(i+“号选手“)));  

  • }  

  • executor.shutdown();  

  • }  

  • }  

  • class Runner1 implements Runnable{  

  • private String name;  

  • public Runner1(String name){  

  • this.name = name;  

  • }  

  • @Override  

  • public void run() {  

  • System.out.println(name + “准备好了。“);  

  • CountDownLatchDemo.countDownLatch.countDown();  //计数值减1  

  • try {  

  • CountDownLatchDemo.countDownLatch.await();  

  • } catch (Exception e) {  

  • }  

  • System.out.println(name + “起跑!“);  

  • }  

  • }  

  • 3、CopyOnWriteArrayList & CopyOnWriteArraySet

    CopyOnWriteArrayList & CopyOnWriteArraySet是并发容器,适合读多写少的场景,如网站的黑白名单设置。缺点是内存占用大,数据一致性的问题,CopyOnWrite容器只能保证数据最终的一致性,不能保证数据实时一致性。鉴于它的这些缺点,可以使用ConcurrentHashMap容器。-字符

    实现原理:新增到容器的数据会放到一个新的容器中,然后将原容器的引用指向新容器,旧容器也会存在,因此会有两个容器占用内存。我们也可以用同样的方式实现自己的CopyOnWriteMap。

    4、ConcurrentHashMap

    ConcurrentHashMap同样是一个并发容器,将同步粒度最小化。

    实现原理:ConcurrentHashMap默认是由16个Segment组成,每个Segment由多个Hashtable组成,数据变更需要经过两次哈希算法,第一次哈希定位到Segment,第二次哈希定位到Segment下的Hashtable,容器只会将单个Segment锁住,然后操作Segment下的Hashtable,多个Segment之间不受影响。如果需要扩容不是对Segment扩容而是对Segment下的Hashtable扩容。虽然经过两次哈希算法会使效率降低,但是比锁住整个容器效率要高得多。-cyclicbarrier

    5、BlockingQueue

    BlockingQueue只是一个接口,它的实现类有ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQueue、DelayQueue、LinkedBlockingDeque。-字符

    ArrayBlockingQueue:由数据支持的有界阻塞队列。

    LinkedBlockingQueue:基于链接节点、范围任意的阻塞队列。

    PriorityBlockingQueue:无界阻塞队列。

    SynchronousQueue:一种阻塞队列,其中每个插入操作必须等待另一个线程的对应移除操作。

    DelayQueue:Delayed元素的一个无界阻塞队列。

    LinkedBlockingDeque:基于链接节点、范围任意的双端阻塞队列,可以在队列的两端添加、移除元素。

    6、Lock

    Lock分为公平锁和非公平锁,默认是非公平锁。实现类有ReetrantLock、ReetrantReadWriteLock,都依赖于AbstractQueuedSynchronizer抽象类。ReetrantLock将所有Lock接口的操作都委派到Sync类上,Sync有两个子类:NonFairSync和FaiSync,通过其命名就能知道分别处理非公平锁和公平锁的。AbstractQueuedSynchronizer把所有请求构成一个CLH队列,这里是一个虚拟队列,当有线程竞争锁时,该线程会首先尝试是否能获取锁,这种做法对于在队列中等待的线程来说是非公平的,如果有线程正在Running,那么通过循环的CAS操作将此线程增加到队尾,直至添加成功。-cyclicbarrier

    7、Atomic包

    Atomic包下的类实现了原子操作,有对基本类型如int、long、boolean实现原子操作的类:AtomicInteger、AtomicLong、AtomicBoolean,如果需要对一个对象进行原子操作,也有对对象引用进行原子操作的AtomicReference类,还有对对象数组操作的原子类:AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray。原子操作核心思想是CAS操作,然后调用底层操作系统指令来实现。-字符


cyclicbarrier 怎么知道 最后一个线程


  首先,CyclicBarrier可以多次使用,CountDownLatch只能用一次(为0后不可变)
  其次,
  Barrier是等待指定数量线程到达再继续处理;
  Latch是等待指定事件变为指定状态后发生再继续处理,对于CountDown就是计数减为0的事件,但你也可以实现或使用其他Latch就不是这个事件了…
  Barrier是等待指定数量任务完成,Latch是等待其他任务完成指定状态的改变再继续……
-cyclicbarrier

CountDownLatch和CyclicBarrier的区别


这两天写多线程时,用到了CyclicBarrier,下意识的认为CyclicBarrier和CountDownLatch作用很像,就翻阅资料查了一下,说一下他们的区别吧
CyclicBarrier和CountDownLatch 都位于java.util.concurrent 这个包下
CountDownLatch CyclicBarrier
减计数方式 加计数方式
计算为0时释放所有等待的线程 计数达到指定值时释放所有等待线程
计数为0时,无法重置 计数达到指定值时,计数置为0重新开始
调用countDown()方法计数减一
调用await()方法只进行阻塞
对计数没任何影响 调用await()方法计数加1
若加1后的值不等于构造方法的值
则线程阻塞
不可重复利用 可重复利用
-字符

java多线程如何实现等待多个信号的功能


栅栏(CyclicBarrier)

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CycTest
{
    
    public static void main(String args)
    {
        ExecutorService executorpool = Executors.newFixedThreadPool(3);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        
        CycWork work1 = new CycWork(cyclicBarrier, “张三“);
        CycWork work2 = new CycWork(cyclicBarrier, “李四“);
        CycWork work3 = new CycWork(cyclicBarrier, “王五“);
        
        executorpool.execute(work1);
        executorpool.execute(work2);
        executorpool.execute(work3);
        
        executorpool.shutdown();
        
    }
    
}
/**
 * Runnable 线程类
 */
class CycWork implements Runnable
{
    
    private CyclicBarrier cyclicBarrier;
    
    private String name;
    
    public CycWork(CyclicBarrier cyclicBarrier, String name)
    {
        this.name = name;
        this.cyclicBarrier = cyclicBarrier;
    }
    
    @Override
    public void run()
    {
        
        System.out.println(name + “正在打桩,毕竟不轻松。。。。。“);
        
        try
        {
            Thread.sleep(5000);
            System.out.println(name + “不容易,终于把桩打完了。。。。“);
            
            cyclicBarrier.await();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        
        System.out.println(name + “:其他逗b把桩都打完了,又得忙活了。。。“);
        
    }
    
}
-cyclicbarrier

Java中用CyclicBarrier以及CountDownLatch和join相比有什么不同


  • 您好,很高兴为您解答。
    第一个:用Thread.join只能部分的实现CountDownLatch的功能. 这个看看CountDownLatch的java doc就可以了.
    第二个:Thread.join用了Object.wait/notify机制. java.lang.Thread.join(long millis) java doc里写道:
    This implementation uses a loop of this.wait calls conditioned on
    this.isAlive. As a thread terminates the this.notifyAll method is
    invoked. It is recommended that applications not use wait, notify,
    or notifyAll on Thread instances.
    Effective Java第二版里说的很好, wait/nofify 和java.util.concurrent提供的功能比起来, 就好像是 并发汇编语言(concurrency assembly language) 一样. 更难用而且也更容易出bug.-字符


Java中线程怎么同步


1、使用线程类自带的join方法,将子线程加入到主线程,在子线程执行完之后,在执行主线程逻辑。

例如

[java] view plain copy  

  • public static void joinDemo()  

  • throws InterruptedException  

  • {  

  • System.out.println(“=========Test with join=====“);  

  • JoinWorker worker1 = new JoinWorker(“worker1“);  

  • JoinWorker worker2 = new JoinWorker(“worker2“);  

  • worker1.start();  

  • worker2.start();  

  • worker1.join();  

  • worker2.join();  

  • doSuperWork();  

  • }  


  • 2、使用JDK的并发包中的CountDownLatch类, 使用CountDownLatch,每个线程调用其countDown方法使计数器-1,主线程调用await方法阻塞等待,直到CountDownLatch计数器为0时继续执行,例如
  • 首先,定义子线程

    [java] view plain copy  

  • static class CountDownLatchWorker extends Thread  

  • {  

  • String workerName;  

  • CountDownLatch latch;  

  • public CountDownLatchWorker(String workerName, CountDownLatch latch)  

  • {  

  • this.workerName = workerName;  

  • this.latch = latch;  

  • }  

  • public void run()  

  • {  

  • System.out.println(“Sub Worker “ + workerName + “ do work begin at “  

  • + sdf.format(new Date()));  

  • new ThreadWaitDemo().doSomeWork();// 做实际工作  

  • System.out.println(“Sub Worker “ + workerName + “ do work complete at “  

  • + sdf.format(new Date()));  

  • latch.countDown();// 完成之后,计数器减一  

  • }  

  • }  


  • 主线程中调研await方法阻塞等待,直到所有线程完成
  • [html] view plain copy  

  • public static void countDownLatchDemo()  

  • throws InterruptedException  

  • {  

  • System.out.println(“=========Test with CountDownLatch=====“);  

  • CountDownLatch latch = new CountDownLatch(2);  

  • CountDownLatchWorker worker1 = new CountDownLatchWorker(“worker1“, latch);  

  • CountDownLatchWorker worker2 = new CountDownLatchWorker(“worker2“, latch);  

  • worker1.start();  

  • worker2.start();  

  • //主线程阻塞等待  

  • latch.await();  

  • doSuperWork();  

  • }  


  • 3、使用JDK并发包CyclicBarrier,CyclicBarrier类似于CountDownLatch也是个计数器, 不同的是CyclicBarrier的await()方法没被调用一次,计数便会减少1,并阻塞住当前线程。当计数减至0时,阻塞解除,所有在此 CyclicBarrier 上面阻塞的线程开始运行。 在这之后,如果再次调用 await()方法,计数就又会变成 N-1,新一轮重新开始CyclicBarrier初始时还可带一个Runnable的参数,此Runnable任务在CyclicBarrier的数目达到后,所有其它线程被唤醒前被执行。-cyclicbarrier

    示例如下

    [java] view plain copy  

  • public static void cyclicBarrierDemo()  

  • throws InterruptedException, BrokenBarrierException  

  • {  

  • System.out.println(“=========Test with CyclicBarrier=====“);  

  • CyclicBarrier cb = new CyclicBarrier(2, new Runnable()  

  • {  

  • // 将主线程业务放到CyclicBarrier构造方法中,所有线程都到达Barrier时执行  

  • @SuppressWarnings(“static-access“)  

  • public void run()  

  • {  

  • new ThreadWaitDemo().doSuperWork();  

  • }  

  • });// 设定需要等待两个线程  

  • ExecutorService executor = Executors.newFixedThreadPool(2);  

  • CyclicBarrierWorker worker1 = new CyclicBarrierWorker(“worker1“, cb);  

  • CyclicBarrierWorker worker2 = new CyclicBarrierWorker(“worker2“, cb);  

  • executor.execute(worker1);  

  • executor.execute(worker2);  

  • executor.shutdown();  

  • }  


  • 4、使用JDK并发包中的Executors框架,ExecutorService的的invokeAll方法调研callable集合,批量执行多个线程,在invokeAll方法结束之后,再执行主线程其他业务逻辑
  • 示例如下

    [java] view plain copy  

  • public static void callableDemo()  

  • throws InterruptedException  

  • {  

  • System.out.println(“=========Test with Callable=====“);  

  • List《Callable《Integer》》 callList = new ArrayList《Callable《Integer》》();  

  • ExecutorService exec = Executors.newFixedThreadPool(2);  

  • // 采用匿名内部类实现  

  • callList.add(new Callable《Integer》()  

  • {  

  • public Integer call()  

  • throws Exception  

  • {  

  • System.out.println(“Sub Worker worker1 do work begin at “ + sdf.format(new Date()));  

  • new ThreadWaitDemo().doSomeWork();// 做实际工作  

  • System.out.println(“Sub Worker worker1 do work complete at “  

  • + sdf.format(new Date()));  

  • return 0;  

  • }  

  • });  

  • callList.add(new Callable《Integer》()  

  • {  

  • public Integer call()  

  • throws Exception  

  • {  

  • System.out.println(“Sub Worker worker2 do work begin at “ + sdf.format(new Date()));  

  • new ThreadWaitDemo().doSomeWork();// 做实际工作  

  • System.out.println(“Sub Worker worker2 do work complete at “  

  • + sdf.format(new Date()));  

  • return 0;  

  • }  

  • });  

  • exec.invokeAll(callList);  

  • exec.shutdown();  

  • doSuperWork();  

  • }  

  • 5、这种过于恶心,只简单说一下方法,主线程创建一个线程List,将每个子线程保存到列表中,然后定期轮询列表中子线程状态,当所有线程都完成之后,再执行主线程逻辑

cyclicbarrier线程池下使用为什么会死锁


Java线程死锁需要如何解决,这个问题一直在我们不断的使用中需要只有不断的关键。不幸的是,使用上锁会带来其他问题。让我们来看一些常见问题以及相应的解决方法: Java线程死锁 Java线程死锁是一个经典的多线程问题
-字符

尽量把CyclicBarrier和CountDownLatch的区别说通俗点


首先,CyclicBarrier可以多次使用,CountDownLatch只能用一次(为0后不可变) 其次, Barrier是等待指定数量线程到达再继续处理; Latch是等待指定事件变为指定状态后发生再继续处理,对于CountDown就是计数减为0的事件,但你也可以实现或使用其。
-cyclicbarrier