要求：模拟200个设备，尽量瞬间并发量达到200。

思路

第一种：线程池模拟200个线程——wait等待线程数达200——notifyAll唤醒所有线程

第二种：线程池模拟200个线程——阻塞线程——达到200条件释放

比较

两种方案都可以实现瞬时高并发的模拟，但是建议使用第二种方案。

第一种方案中，压测过程中，wait状态下的线程已经释放对象上的锁定，唤醒时会极大的消耗CPU资源。压测程序可能直接导致机器崩溃

第二种方案，由于阻塞过程中，线程不会释放掉目前持有的对象资源，因此等待条件释放不会造成资源的过度消耗。

但是应当选择好阻塞方式，避免线程操作时的死锁。同时实现线程之间的通信。

wait-notifyAll

代码较简单，通过线程池启动1000个线程，通过synchronized保证线程可见性，和安全性。

当线程数量未达到1000时，wait使线程退出CPU，释放锁。

当线程数量达到1000时，notifyAll通知等待集上的线程，唤醒线程。

代码如下：

/**

* @author:     irvingyuan

* @since       2017年1月22日 下午4:51:51

* @version:

*/

public class Parallellimit {

public static void main(String[] args) {

ExecutorService pool = Executors.newCachedThreadPool();

Counts count = new Counts();  //共享操作该计数变量,不能使用int或者integer，Java无法对非对象、和包装类进行加锁wait

count.num = 0;

for(int i=0;i<10000;i++){     //启动线程

MyRunnable runnable = new MyRunnable(count);

pool.execute(runnable);

}

pool.shutdown();     //关闭线程池,无法加入新线程任务,但不影响现有线程

}

}

public class MyRunnable implements Runnable{

private Counts count ;

/**

* 通过构造方法传入初值，避免set和get时线程的不安全性

*/

public MyRunnable(Counts count){

this.count = count;

}

public void run() {

try {

/**

* 加锁,保证线程可见性和安全性

*/

synchronized (count) {

count.num++;

if(count.num<10000){

System.out.println(count.num);

count.wait();//一定要调用count对象的wait,默认对this,无法持有线程的锁，抛出异常

}

/**

* 达到10000时唤醒所有线程

*/

if(count.num == 10000){

count.notifyAll();

}

System.out.println("并发量 count="+count.num);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

测试结果

并发唤醒1000个线程时，CPU瞬时使用率瞬时增长17%左右。可见CPU负担很大。

继续增大线程数，JVM抛OOM异常退出，需要修改启动参数

block阻塞方式

同步代码块持有count的锁，保证创建出正确的线程数量。判断不够并发量时，使用while阻塞线程。

当达到并发量时，阻塞条件失效，线程继续运行。

代码如下：

/**

* 阻塞方式创建瞬时高并发

* @author:     irvingyuan

* @since       2017年1月23日 下午4:45:56

* @version:

*/

public class BlockRunnable implements Runnable{

private Counts count ;

/**

* 通过构造方法传入初值，避免set和get时线程的不安全性

*/

public BlockRunnable(Counts count){

this.count = count;

}

public void run() {

/**

* this肯定失效，this调用处为runnable对象

* 此时加锁表示多个线程只能有一个线程在某时刻操作该runnable

* new出来了n个线程，自己调用自己的，this必定失效

* synchronized (this) {

*/

synchronized (count) {

count.num++;

System.out.println("Thread count = "+count.num);

}

/**

* 注意synchronized的粒度

* while放在代码快中会导致线程一直持有锁等待，下一个线程无法生成和进行

*/

while(count.num<100);

//并发操作

System.out.println("concurrency count = "+count.num);

}

}

测试效果

100个线程瞬时的CPU使用率居然激增到了100%，和资料说的完全想法，更加损耗系统资源。(是不是因为while？)

//原文使用sleep,个人认为时间不好掌握,用while直接长时间做条件阻塞

CountDownLatch

Java提供的实现阻塞和释放线程的类，尝试是否符合推荐的规律。

其中主要包含三个方法

countDownLatch(100)     类通过构造方法传入计数数量。

countDown()     方法会减少一个计数值

await()     方法自动阻塞线程，直到count的值变为0

执行过程中，同步操作count后，开始等待，直到100个线程全部创建后并发执行

代码如下

public class Parallellimit {

public static void main(String[] args) {

ExecutorService pool = Executors.newCachedThreadPool();

Counts count = new Counts();

count.num = 0;

CountDownLatch cdl = new CountDownLatch(100);

for(int i=0;i<100;i++){

CountRunnable runnable = new CountRunnable(cdl);

pool.execute(runnable);

}

}

}

/**

* 〈countDownlatch实现高并发〉

* @author:     irvingyuan

* @since       2017年1月23日 下午5:45:59

* @version:

*/

public class CountRunnable implements Runnable {

private CountDownLatch countDownLatch;

public CountRunnable(CountDownLatch countDownLatch){

this.countDownLatch = countDownLatch;

}

public void run() {

try {

/**

* 不加锁也可以支持，虽然打印出的值不对，但最后计算次数却是100次

* 说明确实是执行了整整100次才并发，计算次数正确

*/

synchronized (countDownLatch) {

/**

* 每次减少一个容量

*/

countDownLatch.countDown();

System.out.println("thread counts = "+(countDownLatch.getCount()));

}

/**

* 阻塞线程，直到countDown至0

*/

countDownLatch.await();

System.out.println("concurrency counts = "+(100-countDownLatch.getCount()));

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

测试结果

CPU增长率大约10%左右，相对于wait-notify方式要减少约一半。

综上，阻塞似乎是最坑爹的一种方式