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

主线程等待子线程运行结束再完成的效果如何实现

主线程抛出一个子线程异步处理一些东西，这时主线程要等待子线程运行完成再完成（其实我是为了统计运行时间的）。

这里抛出的子线程可能递归的调用自己，就是再抛一个他的子线程出来，但是到底一共抛多少，事先是不知道的。

应用场景：1）多线程扫描文件夹内的文件，遇到文件夹内有子文件夹，要递归调用扫描线程的，等到全部扫描完成后，返回结果，显示； 2）多线程快速排序，第一次肯定是单线程的，第一次排序完成后，会分两半，这两半多线程排，递归调用了这个排序线程，这两半很有可能，极大有可能再各分两半，也就是会有4个子线程的子线程再排序。

我试过网上的那个 CountDownLatch ，但是他只能实现定义好子线程的数量，但是在以上两种情景下，事先你是不知道会有多少个子线程的！ PS：在某种需求中，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择CyclicBarrier了。

这个貌似也要在开始的时候设定总线程数：CyclicBarrier(int parties) 这个和countDownLatch就差不多了呢！ 你觉得呢 问题补充：niuzai 写道亲，CyclicBarrier可能是你想要的。

PS：在某种需求中，比如一个大型的任务，常常需要分配好多子任务去执行，只有当所有子任务都执行完成时候，才能执行主任务，这时候，就可以选择CyclicBarrier了。

我再来看看~~试试看！ 问题补充：niuzai 写道亲，CyclicBarrier这个东东是可以动态重置个数的，而countDownLatch是一次性的。

只不过大多数例子CyclicBarrier初始化了个数罢了，实质上它是可以动态改变的~ 嗯 我试了下，多线程快排，小数据量还好，顺利执行了，但是数多了后，会建N多线程等待，会outofmemory，呵呵！ 不过证明这个方法是可以的！ 问题补充：niuzai 写道亲，那你就结合线程池操作，设置线程数目上限。

不要每个任务就产生一个线程咯~ 产生新的线程是很耗内存的，线程太多当然就内存溢出咯~嗯 你说的很对！要结合线程池的！

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，此时等待的线程才会释放。

来个示例： [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扩容。

虽然经过两次哈希算法会使效率降低，但是比锁住整个容器效率要高得多。

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操作将此线程增加到队尾，直至添加成功。

7、Atomic包 Atomic包下的类实现了原子操作，有对基本类型如int、long、boolean实现原子操作的类：AtomicInteger、AtomicLong、AtomicBoolean，如果需要对一个对象进行原子操作，也有对对象引用进行原子操作的AtomicReference类，还有对对象数组操作的原子类：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray。

原子操作核心思想是CAS操作，然后调用底层操作系统指令来实现。

obstacle and barrier 他们有什么区别?

1.obstacle指“阻碍前进的东西或状况”,如: Your hesitation is an obstacle to your progress.用法中多为转义 2.barrier 指“阻碍整个通道的阻塞物”,常用于本义

java并发类有哪些

1、常用的并发集合类 ConcurrentHashMap：线程安全的HashMap的实现 CopyOnWriteArrayList：线程安全且在读操作时无锁的ArrayList CopyOnWriteArraySet：基于CopyOnWriteArrayList，不添加重复元素 ArrayBlockingQueue：基于数组、先进先出、线程安全，可实现指定时间的阻塞读写，并且容量可以限制 LinkedBlockingQueue：基于链表实现，读写各用一把锁，在高并发读写操作都多的情况下，性能优于ArrayBlockingQueue 2、原子类 AtomicInteger：线程安全的Integer，基于CAS（无阻塞，CPU原语），优于使用同步锁的Integer 3、线程池 ThreadPoolExecutor：一个高效的支持并发的线程池，可以很容易的讲一个实现了Runnable接口的任务放入线程池执行，但要用好这个线程池，必须合理配置corePoolSize、最大线程数、任务缓冲队列，以及队列满了+线程池满时的回绝策略，一般而言对于这些参数的配置，需考虑两类需求：高性能和缓冲执行。

Executor：提供了一些方便的创建ThreadPoolExecutor的方法。

FutureTask：可用于异步获取执行结果或取消执行任务的场景，基于CAS，避免锁的使用 4、锁 ReentrantLock：与synchronized效果一致，但是又更加灵活，支持公平/非公平锁、支持可中断的锁、支持非阻塞的tryLock(可超时)、支持锁条件等，需要手工释放锁，基于AbstractQueueSynchronizer ReentrantReadWriteLock：与ReentrantLock没有关系，采用两把锁，用于读多写少的情形

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

Java线程死锁需要如何解决，这个问题一直在我们不断的使用中需要只有不断的关键。

不幸的是，使用上锁会带来其他问题。

让我们来看一些常见问题以及相应的解决方法： Java线程死锁 Java线程死锁是一个经典的多线程问题