countdownlatch的await超时时间设置多少合适

我、提、供、编、码。

　　ArrayList和Vector有什么区别？HashMap和HashTable有什么区别？StringBuilder和StringBuffer有什么区别？这些都是Java面试中常见的基础问题 面对这样的问题 回答是 ArrayList是非线程安全的 Vector是线程安全的 HashMap是非线程安全的 HashTable是线程安全的 StringBuilder是非线程安全的 StringBuffer是线程安全的 因为这是昨晚刚背的《Java面试题大全》上面写的 此时如果继续问 什么是线程安全？线程安全和非线程安全有什么区别？分别在什么情况下使用？这样一连串的问题 一口老血就喷出来了… 　　非线程安全的现象模拟 　　这里就使用ArrayList和Vector二者来说明 　　下面的代码 在主线程中new了一个非线程安全的ArrayList 然后开 个线程分别向这个ArrayList里面添加元素 每个线程添加 个元素 等所有线程执行完成后 这个ArrayList的size应该是多少？应该是 个？ 　　[java] 　　public class Main 　　{ 　　public static void main(String[] args) 　　{ 　　// 进行 次测试 　　for(int i = ; i < ; i++) 　　{ 　　test(); 　　} 　　} 　　public static void test() 　　{ 　　// 用来测试的List 　　List<Object> list = new ArrayList<Object>(); 　　// 线程数量( ) 　　int threadCount = ; 　　// 用来让主线程等待threadCount个子线程执行完毕 　　CountDownLatch countDownLatch = new CountDownLatch(threadCount); 　　// 启动threadCount个子线程 　　for(int i = ; i < threadCount; i++) 　　{ 　　Thread thread = new Thread(new MyThread(list countDownLatch)); 　　thread start(); 　　} 　　try 　　{ 　　// 主线程等待所有子线程执行完成 再向下执行 　　countDownLatch await(); 　　} 　　catch (InterruptedException e) 　　{ 　　e printStackTrace(); 　　} 　　// List的size 　　System out println(list size()); 　　} 　　} 　　class MyThread implements Runnable 　　{ 　　private List<Object> list; 　　private CountDownLatch countDownLatch; 　　public MyThread(List<Object> list CountDownLatch countDownLatch) 　　{ 　　this list = list; 　　untDownLatch = countDownLatch; 　　} 　　public void run() 　　{ 　　// 每个线程向List中添加 个元素 　　for(int i = ; i < ; i++) 　　{ 　　list add(new Object()); 　　} 　　// 完成一个子线程 　　untDown(); 　　} 　　} 　　public class Main 　　{ 　　public static void main(String[] args) 　　{ 　　// 进行 次测试 　　for(int i = ; i < ; i++) 　　{ 　　test(); 　　} 　　} 　　public static void test() 　　{ 　　// 用来测试的List 　　List<Object> list = new ArrayList<Object>(); 　　// 线程数量( ) 　　int threadCount = ; 　　// 用来让主线程等待threadCount个子线程执行完毕 　　CountDownLatch countDownLatch = new CountDownLatch(threadCount); 　　// 启动threadCount个子线程 　　for(int i = ; i < threadCount; i++) 　　{ 　　Thread thread = new Thread(new MyThread(list countDownLatch)); 　　thread start(); 　　} 　　try 　　{ 　　// 主线程等待所有子线程执行完成 再向下执行 　　countDownLatch await(); 　　} 　　catch (InterruptedException e) 　　{ 　　e printStackTrace(); 　　} 　　// List的size 　　System out println(list size()); 　　} 　　} 　　class MyThread implements Runnable 　　{ 　　private List<Object> list; 　　private CountDownLatch countDownLatch; 　　public MyThread(List<Object> list CountDownLatch countDownLatch) 　　{ 　　this list = list; 　　untDownLatch = countDownLatch; 　　} 　　public void run() 　　{ 　　// 每个线程向List中添加 个元素 　　for(int i = ; i < ; i++) 　　{ 　　list add(new Object()); 　　} 　　// 完成一个子线程 　　untDown(); 　　} 　　} 　　上面进行了 次测试（为什么要测试 次？因为非线程安全并不是每次都会导致问题） 　　输出结果 　　 　　 　　 　　 　　 　　 　　 　　 　　 　　 　　上面的输出结果发现 并不是每次测试结果都是 有好几次测试最后ArrayList的size小于 甚至时不时会抛出个IndexOutOfBoundsException异常 （如果没有这个现象可以多试几次） 　　这就是非线程安全带来的问题了 上面的代码如果用于生产环境 就会有隐患就会有BUG了 　　再用线程安全的Vector来进行测试 上面代码改变一处 test()方法中 　　[java] 　　List<Object> list = new ArrayList<Object>(); 　　List<Object> list = new ArrayList<Object>();改成 　　[java] 　　List<Object> list = new Vector<Object>(); 　　List<Object> list = new Vector<Object>(); 　　再运行程序 　　输出结果 　　 　　 　　 　　 　　 　　 　　 　　 　　 　　 　　再多跑几次 发现都是 没有任何问题 因为Vector是线程安全的 在多线程操作同一个Vector对象时 不会有任何问题 　　再换成LinkedList试试 同样还会出现ArrayList类似的问题 因为LinkedList也是非线程安全的 　　二者如何取舍 　　非线程安全是指多线程操作同一个对象可能会出现问题 而线程安全则是多线程操作同一个对象不会有问题 　　线程安全必须要使用很多synchronized关键字来同步控制 所以必然会导致性能的降低 　　所以在使用的时候 如果是多个线程操作同一个对象 那么使用线程安全的Vector 否则 就使用效率更高的ArrayList 　　非线程安全!=不安全 　　有人在使用过程中有一个不正确的观点 我的程序是多线程的 不能使用ArrayList要使用Vector 这样才安全 　　非线程安全并不是多线程环境下就不能使用 注意我上面有说到 多线程操作同一个对象 注意是同一个对象 比如最上面那个模拟 就是在主线程中new的一个ArrayList然后多个线程操作同一个ArrayList对象 　　如果是每个线程中new一个ArrayList 而这个ArrayList只在这一个线程中使用 那么肯定是没问题的 　　线程安全的实现 　　线程安全是通过线程同步控制来实现的 也就是synchronized关键字 　　在这里 我用代码分别实现了一个非线程安全的计数器和线程安全的计数器Counter 并对他们分别进行了多线程测试 　　非线程安全的计数器 　　[java] 　　public class Main 　　{ 　　public static void main(String[] args) 　　{ 　　// 进行 次测试 　　for(int i = ; i < ; i++) 　　{ 　　test(); 　　} 　　} 　　public static void test() 　　{ 　　// 计数器 　　Counter counter = new Counter(); 　　// 线程数量( ) 　　int threadCount = ; 　　// 用来让主线程等待threadCount个子线程执行完毕 　　CountDownLatch countDownLatch = new CountDownLatch(threadCount); 　　// 启动threadCount个子线程 　　for(int i = ; i < threadCount; i++) 　　{ 　　Thread thread = new Thread(new MyThread(counter countDownLatch)); 　　thread start(); 　　} 　　try 　　{ 　　// 主线程等待所有子线程执行完成 再向下执行 　　countDownLatch await(); 　　} 　　catch (InterruptedException e) 　　{ 　　e printStackTrace(); 　　} 　　// 计数器的值 　　System out println(counter getCount()); 　　} 　　} 　　class MyThread implements Runnable 　　{ 　　private Counter counter; 　　private CountDownLatch countDownLatch; 　　public MyThread(Counter counter CountDownLatch countDownLatch) 　　{ 　　unter = counter; 　　untDownLatch = countDownLatch; 　　} 　　public void run() 　　{ 　　// 每个线程向Counter中进行 次累加 　　for(int i = ; i < ; i++) 　　{ 　　counter addCount(); 　　} 　　// 完成一个子线程 　　untDown(); 　　} 　　} 　　class Counter 　　{ 　　private int count = ; 　　public int getCount() 　　{ 　　return count; 　　} 　　public void addCount() 　　{ 　　count++; 　　} 　　} 　　public class Main 　　{ 　　public static void main(String[] args) 　　{ 　　// 进行 次测试 　　for(int i = ; i < ; i++) 　　{ 　　test(); 　　} 　　} 　　public static void test() 　　{ 　　// 计数器 　　Counter counter = new Counter(); 　　// 线程数量( ) 　　int threadCount = ; 　　// 用来让主线程等待threadCount个子线程执行完毕 　　CountDownLatch countDownLatch = new CountDownLatch(threadCount); 　　// 启动threadCount个子线程 　　for(int i = ; i < threadCount; i++) 　　{ 　　Thread thread = new Thread(new MyThread(counter countDownLatch)); 　　thread start(); 　　} 　　try 　　{ 　　// 主线程等待所有子线程执行完成 再向下执行 　　countDownLatch await(); 　　} 　　catch (InterruptedException e) 　　{ 　　e printStackTrace(); 　　} 　　// 计数器的值 　　System out println(counter getCount()); 　　} 　　} 　　class MyThread implements Runnable 　　{ 　　private Counter counter; 　　private CountDownLatch countDownLatch; 　　public MyThread(Counter counter CountDownLatch countDownLatch) 　　{ 　　unter = counter; 　　untDownLatch = countDownLatch; 　　} 　　public void run() 　　{ 　　// 每个线程向Counter中进行 次累加 　　for(int i = ; i < ; i++) 　　{ 　　counter addCount(); 　　} 　　// 完成一个子线程 　　untDown(); 　　} 　　} 　　class Counter 　　{ 　　private int count = ; 　　public int getCount() 　　{ 　　return count; 　　} 　　public void addCount() 　　{ 　　count++; 　　} 　　} 　　上面的测试代码中 开启 个线程 每个线程对计数器进行 次累加 最终输出结果应该是 　　但是上面代码中的Counter未进行同步控制 所以非线程安全 　　输出结果 　　 　　 　　 　　 　　 　　 　　 　　 　　 　　 　　稍加修改 把Counter改成线程安全的计数器 　　[java] 　　class Counter 　　{ 　　private int count = ; 　　public int getCount() 　　{ 　　return count; 　　} 　　public synchronized void addCount() 　　{ 　　count++; 　　} 　　} 　　class Counter 　　{ 　　private int count = ; 　　public int getCount() 　　{ 　　return count; 　　} 　　public synchronized void addCount() 　　{ 　　count++; 　　} 　　} 　　上面只是在addCount()方法中加上了synchronized同步控制 就成为一个线程安全的计数器了 再执行程序 　　输出结果 　　 　　 　　 　　 　　 　　 　　 　　 　　 lishixinzhi/Article/program/Java/gj/201311/27519

不可重入锁，与可重入锁相反，不可递归调用，递归调用就发生死锁。看到一个经典的讲解，使用自旋锁来模拟一个不可重入锁，代码如下import java.util.concurrent.atomic.AtomicReference;public class UnreentrantLock {private AtomicReference<Thread> owner = new AtomicReference<Thread>();public void lock() {Thread current = Thread.currentThread();//这句是很经典的“自旋”语法，AtomicInteger中也有for (;;) {if (!owner.compareAndSet(null, current)) {return;}}}public void unlock() {Thread current = Thread.currentThread();owner.compareAndSet(current, null);}}代码也比较简单，使用原子引用来存放线程，同一线程两次调用lock()方法，如果不执行unlock()释放锁的话，第二次调用自旋的时候就会产生死锁，这个锁就不是可重入的，而实际上同一个线程不必每次都去释放锁再来获取锁，这样的调度切换是很耗资源的。

Redisson的Github地址： https://github.com/redisson/redisson/wiki/Table-of-Content 基于Redis的Redisson分布式可重入锁RLock对象实现了java.util.concurrent.locks.Lock接口。 大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个 监控锁的看门狗 ，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。 在RedissonLock类的renewExpiration()方法中，会启动一个定时任务每隔30/3=10秒给锁续期。如果业务执行期间，应用挂了，那么不会自动续期，到过期时间之后，锁会自动释放。 另外Redisson还提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。 如果指定了锁的超时时间，底层直接调用lua脚本，进行占锁。如果超过leaseTime，业务逻辑还没有执行完成，则直接释放锁，所以在指定leaseTime时，要让leaseTime大于业务执行时间。RedissonLock类的tryLockInnerAsync()方法 分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。在读写锁中，读读共享、读写互斥、写写互斥。 读写锁测试类，当访问write接口时，read接口会被阻塞住。 Redisson的分布式信号量与的用法与java.util.concurrent.Semaphore相似 现在redis中保存semaphore的值为3 然后在TestController中添加测试方法： 当访问acquireSemaphore接口时，redis中的semaphore会减1；访问releaseSemaphore接口时，redis中的semaphore会加1。当redis中的semaphore为0时，继续访问acquireSemaphore接口，会被阻塞，直到访问releaseSemaphore接口，使得semaphore>0，acquireSemaphore才会继续执行。 CountDownLatch作用：某一线程，等待其他线程执行完毕之后，自己再继续执行。 在TestController中添加测试方法，访问close接口时，调用await()方法进入阻塞状态，直到有三次访问release接口时，close接口才会返回。

1、当在匿名类中用this时，这个this则指的是匿名类或内部类本身。2、this.i=i 是指 当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。（this是当前对象自己）

你能说下目的吗。可以加个navtice变量，子线程完成后设为true, 主线程加个while循环，当这个变更为true时，结束循环，也就自动结束了

设置一个计数器，每个线程执行完后计数器加一然后查看计数器是否已满（任务都完成），没有的话就阻塞，是的话就唤醒其他所有线程，大家一起来执行下一次任务。要注意公用的计数器的线程安全！

java 有一个CountDownLatch类，是专门处理这种问题的。.net好像没有这样的类，你搜一下.net CountDownLatch，然后会出现模拟这个类的一些代码。原理基本上就是一开始定义一个CountDownLatch计数器，比如你有两个子线程，那么这个计数器就为2，然后每个子线程执行完之后，计数器-1，直到到0位置，两个子线程外面需要用 await()方法来阻塞，这样当计数器为0的时候，主线程就能继续执行了。我在java里写的代码，你可以参照网上的例子模拟一个CountDownLatch类。final CountDownLatch lock = new CountDownLatch(1);//验证文件服务器是否运行是否正常new Thread(new Runnable() { public void run() { startCheck(lock); } }).start();lock.await();等待//主线程继续执行startCheck方法里边如果执行完了之后，只需要调用lock.countDown();就行了。

public static void main(String[] args) throws Exception { ConnectingIOReactor ioReactor = new DefaultConnectingIOReactor(); PoolingNHttpClientConnectionManager cm = new PoolingNHttpClientConnectionManager(ioReactor); cm.setMaxTotal(100); CloseableHttpAsyncClient httpAsyncClient = HttpAsyncClients.custom().setConnectionManager(cm).build(); httpAsyncClient.start(); String[] urisToGet = { "http://www.chinaso.com/", "http://www.so.com/", "http://www.qq.com/", }; final CountDownLatch latch = new CountDownLatch(urisToGet.length); for (final String uri: urisToGet) { final HttpGet httpget = new HttpGet(uri); httpAsyncClient.execute(httpget, new FutureCallback<HttpResponse>() { public void completed(final HttpResponse response) { latch.countDown(); System.out.println(httpget.getRequestLine() + "->" + response.getStatusLine()); } public void failed(final Exception ex) { latch.countDown(); System.out.println(httpget.getRequestLine() + "->" + ex); } public void cancelled() { latch.countDown(); System.out.println(httpget.getRequestLine() + " cancelled"); } }); } latch.await();

学习没有捷径，但要有好的方法提高效率

1、jdk1.8广义上来说，可以说是1.7的增强版，即1.8的功能更加强大，如：1.8中Switch语句支持string类型 、 Try-with-resource语句 、5 数字类型的下划线表示 更友好的表示方式、在可变参数方法中传递非具体化参数,改进编译警告和错误 ；这个太多了，2、 需要注意的是，你用1.8版本开发的程序如果换到其余的1.7版本下可能会报错，即无法运行，而1.7版本下开发的程序，在1.8版本下应该可以正常的运行。 因为版本是自上而下兼容，而自下而上，可能会出问题3、所以建议在真正的开发过程中建议使用1.6或1.7版本（1.8还不是很普遍）

常见错误日志如下：org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode = ConnectionLoss1. 原因：是因为ZooKeeper建立连接时采用异步操作，连接操作后并不能保证ZK连接已成功。如果在ZK连接成功前的这个小时间窗口去访问ZK，就会碰到如上错误。2. 解决思路我们在新建ZK连接后要等一段时间，保证连接成功后再访问ZK。3. 网上比较赞同的解决方案:主要利用两个Java类：（1）java.util.concurrent.CountDownLatch：一个同步辅助类，类似倒数计数，直到计数器为0时才能对资源“解锁”。未解锁前等待该资源的进程只能被阻塞。主要方法：public CountDownLatch(int count); /* 构造函数,参数指定计数次数 */public void countDown(); /* 当前线程调用此函数，则计数减一 */public void await() throws InterruptedException; /* 此函数会一直阻塞当前线程，直到计时器的值为0为止 */（2）org.apache.zookeeper.WatcherZooKeeper有一个很有用的功能，就是集群上每一个变化都可以通知到自定义的Watchcer。

你能说下目的吗。可以加个navtice变量，子线程完成后设为true,主线程加个while循环，当这个变更为true时，结束循环，也就自动结束了

最近写小玩具的时候用到了 CountDownLatch 计数器，然后顺便想了想判断线程池全部结束有多少种方法。 在网上搜了下，可能有些没找到，但是我找到的有（所有方法都是在 ThreadPoolExecutor 线程池方法下测试的）： 好嘞，现在开始一个一个介绍优缺点和简要原理； 先创建一个 static 线程池，后面好几个例子就不一一创建了，全部用这个就行了： 然后再准备一个通用的睡眠方法： 这个方法就是为了测试的时候区分线程执行完毕的下顺序而已。 好嘞，准备完毕，现在开始。 首先贴上测试代码： 这一种方式就是在主线程中进行循环判断，全部任务是否已经完成。 这里有两个主要方法： 通俗点讲，就是在执行全部任务后，对线程池进行 shutdown() 有序关闭，然后循环判断 isTerminated() ，线程池是否全部完成。 类似方法扩展： 还是一样，贴上代码： 还是一样在主线程循环判断，主要就两个方法： 这个好理解，总任务数等于已完成任务数，就表示全部执行完毕。 其他 ： 最后扯两句，因为我用 main 方法运行的，跑完后 main 没有结束，是因为非守护线程如果不终止，程序是不会结束的。而线程池 Worker 线程里写了一个死循环，而且被设置成了非守护线程。 这种方法是我比较常用的方法，先看代码： 这种方法，呃，应该是看起来比较高级的，我也不知道别的大佬怎么写的，反正我就用这个。 这个方法需要介绍下这个工具类 CountDownLatch 。先把这种方式的优缺点写了，后面再详细介绍这个类。 CountDownLatch 是 JDK 提供的一个同步工具，它可以让一个或多个线程等待，一直等到其他线程中执行完成一组操作。 常用的方法有 countDown 方法和 await 方法， CountDownLatch 在初始化时，需要指定用给定一个整数作为计数器。 当调用 countDown 方法时，计数器会被减1；当调用 await 方法时，如果计数器大于0时，线程会被阻塞，一直到计数器被 countDown 方法减到0时，线程才会继续执行。 计数器是无法重置的，当计数器被减到0时，调用 await 方法都会直接返回。 这种方式其实和 CountDownLatch 原理类似。 先维护一个静态变量 然后在线程任务结束时，进行静态变量操作： 其实就是加锁计数，循环判断。 Future 是用来装载线程结果的，不过，用这个来进行判断写代码总感觉怪怪的。 因为 Future 只能装载一条线程的返回结果，多条线程总不能用 List 在接收 Future 。 这里就开一个线程做个演示： 这种方式就不写优缺点了，因为 Future 的主要使用场景并不是用于判断任务执行状态。

t2这部分不会被运行了countDownLatch 根本就没有执行过countDown的调用你可以首先把countDown变成类的静态成员变量，或者把countDown作为参数带入到类Calc 中，在run方法结束的时候执行countDownLatch.countDown();如果不执行countDownLatch.countDown();操作，计数器不会产生变化，线程跑完了以后程序就停在countDownLatch.await(); 傻等着了........

要实现这个情况，必须知道以下几点1、java中线程的结束是由run方法运行完成后自动结束的2、在main线程(主线程)中，需要得到所有线程的引用。3、知道jdk提供的CountDownLatch的用法例子如下：public static void main(String[] args) throws InterruptedException {//CountDownLatch作为计数器纪录有几个线程，例如有2个线程CountDownLatch latch=new CountDownLatch(2);Worker worker1=new Worker( latch);Worker worker2=new Worker(latch);worker1.start();// 启动线程worker2.start();////等待所有工人完成工作latch.await();System.out.println("all work done at "+sdf.format(new Date()));} class Worker extends Thread{private CountDownLatch latch;public Worker(CountDownLatch latch){this.latch = latch;}public void run(){xxxxx//在run方法结束之前，讲线程计数器减一latch.countDown();}}

用java.util.concurrent下面的类实现线程池就可以

可以使用Thread类的joint()方法来确保所有程序创建的线程在main()方法退出前结束。可以多了解一些关于Thread类的joint()方法。

是线程安全的，这个类设计的目的就是多线程直接的同步合作。试想，如果它不是线程安全的，那岂不是错误的实现~无论有几个线程在操作countdownlatch实例，调用countdownlatch.await()的线程A会被阻塞，除非其他线程BCD...调用countdownlatch.countdown()并且计数器至0.你可以参考这个回答:

这未必的~~~

要实现这个情况，必须知道以下几点1、java中线程的结束是由run方法运行完成后自动结束的2、在main线程(主线程)中，需要得到所有线程的引用。3、知道jdk提供的CountDownLatch的用法例子如下：public static void main(String[] args) throws InterruptedException { //CountDownLatch作为计数器纪录有几个线程，例如有2个线程CountDownLatch latch=new CountDownLatch(2);Worker worker1=new Worker( latch); Worker worker2=new Worker(latch); worker1.start();// 启动线程worker2.start();// //等待所有工人完成工作 latch.await();System.out.println("all work done at "+sdf.format(new Date())); } class Worker extends Thread{private CountDownLatch latch;public Worker(CountDownLatch latch){this.latch = latch;}public void run(){xxxxx//在run方法结束之前，讲线程计数器减一latch.countDown();}}

观公孙大娘弟子舞剑器行(杜甫)[6]

java.util.concurrent.CountDownLatch 这个类可以实现你所要的功能例如：CountDownLatch latch = new CountDownLatch(5) //声明计数器为5个Thread t = new Thread() {public void run() {try {//TODO 你的应用} catch (Exception e) {//TODO 异常处理}finally {latch.countDown(); //这句是关键System.out.println("ok"); //5个线程都跑完后输出}}};t.start();然后让以上操作循环五次(就是说同时开5个线程)，那么这个"ok"就会在等到这5个线程都ok后才会被输出一次。

要实现这个情况，必须知道以下几点1、java中线程的结束是由run方法运行完成后自动结束的2、在main线程(主线程)中，需要得到所有线程的引用。3、知道jdk提供的CountDownLatch的用法例子如下：public static void main(String[] args) throws InterruptedException { //CountDownLatch作为计数器纪录有几个线程，例如有2个线程CountDownLatch latch=new CountDownLatch(2);Worker worker1=new Worker( latch); Worker worker2=new Worker(latch); worker1.start();// 启动线程worker2.start();// //等待所有工人完成工作 latch.await();System.out.println("all work done at "+sdf.format(new Date())); } class Worker extends Thread{private CountDownLatch latch;public Worker(CountDownLatch latch){this.latch = latch;}public void run(){xxxxx//在run方法结束之前，讲线程计数器减一latch.countDown();}}

常见错误日志如下：org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode = ConnectionLoss1. 原因：是因为ZooKeeper建立连接时采用异步操作，连接操作后并不能保证ZK连接已成功。如果在ZK连接成功前的这个小时间窗口去访问ZK，就会碰到如上错误。2. 解决思路我们在新建ZK连接后要等一段时间，保证连接成功后再访问ZK。3. 网上比较赞同的解决方案: 主要利用两个Java类： （1）java.util.concurrent.CountDownLatch： 一个同步辅助类，类似倒数计数，直到计数器为0时才能对资源“解锁”。未解锁前等待该资源的进程只能被阻塞。 主要方法： public CountDownLatch(int count); /* 构造函数,参数指定计数次数 */ public void countDown(); /* 当前线程调用此函数，则计数减一 */ public void await() throws InterruptedException; /* 此函数会一直阻塞当前线程，直到计时器的值为0为止 */ （2）org.apache.zookeeper.Watcher ZooKeeper有一个很有用的功能，就是集群上每一个变化都可以通知到自定义的Watchcer。

本文使用 ReentrantLock 和 CountDownLatch 演示独占锁和共享锁的实现。 独占锁 获取锁 释放锁 共享锁 通过status标识锁 ReentrantLock使用排他锁。AQS的status>0表示加锁，thread是当前获取锁的线程。该锁时可重入锁，所以status>0。 CountDownLatch 使用共享锁。AQS的status为共享锁的标记位，status>0就是加锁，等于0就是释放锁。每调用一次countDown()，status减1。 线程会阻塞在await()，直到countDown()将status置为0

你可以百度搜一下sleep(0)，道理一样

java.util.concurrent.CountDownLatch 这个类可以实现你所要的功能例如：CountDownLatch latch = new CountDownLatch(5) //声明计数器为5个Thread t = new Thread() {public void run() {try {//TODO 你的应用} catch (Exception e) {//TODO 异常处理}finally {latch.countDown(); //这句是关键System.out.println("ok"); //5个线程都跑完后输出}}};t.start();然后让以上操作循环五次(就是说同时开5个线程)，那么这个"ok"就会在等到这5个线程都ok后才会被输出一次。

可以使用CountDownLatch， 设定线程数量，然后在每个线程完成的是，latch.countDown()在轮询主线程中使用latch.await(), 这个函数会等待所有线程执行完成后继续允许，即你在轮询前记录一个时间，latch.await() 后面记录完成时间

public class SyncFuture<T> implements Future<T> { // 因为请求和响应是一一对应的，因此初始化CountDownLatch值为1。 private CountDownLatch latch = new CountDownLatch(1); // 需要响应线程设置的响应结果 private T response; // Futrue的请求时间，用于计算Future是否超时 private long beginTime = System.currentTimeMillis(); public SyncFuture() { } @Override public boolean cancel(boolean mayInterruptIfRunning) { return false; } @Override public boolean isCancelled() { return false; } @Override public boolean isDone() { if (response != null) { return true; } return false; } // 获取响应结果，直到有结果才返回。 @Override public T get() throws InterruptedException { latch.await(); return this.response; } // 获取响应结果，直到有结果或者超过指定时间就返回。 @Override public T get(long timeout, TimeUnit unit) throws InterruptedException { if (latch.await(timeout, unit)) { return this.response; } return null; } // 用于设置响应结果，并且做countDown操作，通知请求线程 public void setResponse(T response) { this.response = response; latch.countDown(); } public long getBeginTime() { return beginTime; }}

多线程，并不能使一个方法执行得更快，只是可以“并发”让多个任务同步干活，是整体上快了。

首先，需要将以下代码编译成jar包，然后在flume中使用，代码转自这里 （如果发现需要依赖的工具类神马的，请在相同目录下的scala文件中找一找） package org.apache.spark.streaming.flume.sinkimport java.net.InetSocketAddressimport java.util.concurrent._import org.apache.avro.ipc.NettyServerimport org.apache.avro.ipc.specific.SpecificResponderimport org.apache.flume.Contextimport org.apache.flume.Sink.Statusimport org.apache.flume.conf.{Configurable, ConfigurationException}import org.apache.flume.sink.AbstractSink/** * A sink that uses Avro RPC to run a server that can be polled by Spark"s * FlumePollingInputDStream. This sink has the following configuration parameters: * * hostname - The hostname to bind to. Default: 0.0.0.0 * port - The port to bind to. (No default - mandatory) * timeout - Time in seconds after which a transaction is rolled back, * if an ACK is not received from Spark within that time * threads - Number of threads to use to receive requests from Spark (Default: 10) * * This sink is unlike other Flume sinks in the sense that it does not push data, * instead the process method in this sink simply blocks the SinkRunner the first time it is * called. This sink starts up an Avro IPC server that uses the SparkFlumeProtocol. * * Each time a getEventBatch call comes, creates a transaction and reads events * from the channel. When enough events are read, the events are sent to the Spark receiver and * the thread itself is blocked and a reference to it saved off. * * When the ack for that batch is received, * the thread which created the transaction is is retrieved and it commits the transaction with the * channel from the same thread it was originally created in (since Flume transactions are * thread local). If a nack is received instead, the sink rolls back the transaction. If no ack * is received within the specified timeout, the transaction is rolled back too. If an ack comes * after that, it is simply ignored and the events get re-sent. * */class SparkSink extends AbstractSink with Logging with Configurable { // Size of the pool to use for holding transaction processors. private var poolSize: Integer = SparkSinkConfig.DEFAULT_THREADS // Timeout for each transaction. If spark does not respond in this much time, // rollback the transaction private var transactionTimeout = SparkSinkConfig.DEFAULT_TRANSACTION_TIMEOUT // Address info to bind on private var hostname: String = SparkSinkConfig.DEFAULT_HOSTNAME private var port: Int = 0 private var backOffInterval: Int = 200 // Handle to the server private var serverOpt: Option[NettyServer] = None // The handler that handles the callback from Avro private var handler: Option[SparkAvroCallbackHandler] = None // Latch that blocks off the Flume framework from wasting 1 thread. private val blockingLatch = new CountDownLatch(1) override def start() { logInfo("Starting Spark Sink: " + getName + " on port: " + port + " and interface: " + hostname + " with " + "pool size: " + poolSize + " and transaction timeout: " + transactionTimeout + ".") handler = Option(new SparkAvroCallbackHandler(poolSize, getChannel, transactionTimeout, backOffInterval)) val responder = new SpecificResponder(classOf[SparkFlumeProtocol], handler.get) // Using the constructor that takes specific thread-pools requires bringing in netty // dependencies which are being excluded in the build. In practice, // Netty dependencies are already available on the JVM as Flume would have pulled them in. serverOpt = Option(new NettyServer(responder, new InetSocketAddress(hostname, port))) serverOpt.foreach(server => { logInfo("Starting Avro server for sink: " + getName) server.start() }) super.start() } override def stop() { logInfo("Stopping Spark Sink: " + getName) handler.foreach(callbackHandler => { callbackHandler.shutdown() }) serverOpt.foreach(server => { logInfo("Stopping Avro Server for sink: " + getName) server.close() server.join() }) blockingLatch.countDown() super.stop() } override def configure(ctx: Context) { import SparkSinkConfig._ hostname = ctx.getString(CONF_HOSTNAME, DEFAULT_HOSTNAME) port = Option(ctx.getInteger(CONF_PORT)). getOrElse(throw new ConfigurationException("The port to bind to must be specified")) poolSize = ctx.getInteger(THREADS, DEFAULT_THREADS) transactionTimeout = ctx.getInteger(CONF_TRANSACTION_TIMEOUT, DEFAULT_TRANSACTION_TIMEOUT) backOffInterval = ctx.getInteger(CONF_BACKOFF_INTERVAL, DEFAULT_BACKOFF_INTERVAL) logInfo("Configured Spark Sink with hostname: " + hostname + ", port: " + port + ", " + "poolSize: " + poolSize + ", transactionTimeout: " + transactionTimeout + ", " + "backoffInterval: " + backOffInterval) } override def process(): Status = { // This method is called in a loop by the Flume framework - block it until the sink is // stopped to save CPU resources. The sink runner will interrupt this thread when the sink is // being shut down. logInfo("Blocking Sink Runner, sink will continue to run..") blockingLatch.await() Status.BACKOFF } private[flume] def getPort(): Int = { serverOpt .map(_.getPort) .getOrElse( throw new RuntimeException("Server was not started!") ) } /** * Pass in a [[CountDownLatch]] for testing purposes. This batch is counted down when each * batch is received. The test can simply call await on this latch till the expected number of * batches are received. * @param latch */ private[flume] def countdownWhenBatchReceived(latch: CountDownLatch) { handler.foreach(_.countDownWhenBatchAcked(latch)) }}/** * Configuration parameters and their defaults. */private[flume]object SparkSinkConfig { val THREADS = "threads" val DEFAULT_THREADS = 10 val CONF_TRANSACTION_TIMEOUT = "timeout" val DEFAULT_TRANSACTION_TIMEOUT = 60 val CONF_HOSTNAME = "hostname" val DEFAULT_HOSTNAME = "0.0.0.0" val CONF_PORT = "port" val CONF_BACKOFF_INTERVAL = "backoffInterval" val DEFAULT_BACKOFF_INTERVAL = 200} 　　然后在你的streaming中使用如下的代码package org.apache.spark.examples.streaming import org.apache.spark.SparkConfimport org.apache.spark.storage.StorageLevelimport org.apache.spark.streaming._import org.apache.spark.streaming.flume._import org.apache.spark.util.IntParamimport java.net.InetSocketAddress/** * Produces a count of events received from Flume. * * This should be used in conjunction with the Spark Sink running in a Flume agent. See * the Spark Streaming programming guide for more details. * * Usage: FlumePollingEventCount <host> <port> * `host` is the host on which the Spark Sink is running. * `port` is the port at which the Spark Sink is listening. * * To run this example: * `$ bin/run-example org.apache.spark.examples.streaming.FlumePollingEventCount [host] [port] ` */object FlumePollingEventCount { def main(args: Array[String]) { if (args.length < 2) { System.err.println( "Usage: FlumePollingEventCount <host> <port>") System.exit(1) } StreamingExamples.setStreamingLogLevels() val Array(host, IntParam(port)) = args val batchInterval = Milliseconds(2000) // Create the context and set the batch size val sparkConf = new SparkConf().setAppName("FlumePollingEventCount") val ssc = new StreamingContext(sparkConf, batchInterval) // Create a flume stream that polls the Spark Sink running in a Flume agent val stream = FlumeUtils.createPollingStream(ssc, host, port) // Print out the count of events received from this server in each batch stream.count().map(cnt => "Received " + cnt + " flume events." ).print() ssc.start() ssc.awaitTermination() }}

可以使用CountDownLatch， 设定线程数量，然后在每个线程完成的是，latch.countDown()在轮询主线程中使用latch.await(), 这个函数会等待所有线程执行完成后继续允许，即你在轮询前记录一个时间，latch.await() 后面记录完成时间

oncurrent包里面的CountDownLatch其实可以把它看作一个计数器，只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。 CountDownLatch的一个非常典型的应用场景是:有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

5个人去上厕所，一个个接着进去，每个人都要蹲一分钟才能拉出来，那你说谁会先拉出来？

@Slf4jpublic class FixedThreadPool {/** 请求总数**/private static int clientTotal = 100;public static AtomicInteger atomicInteger = new AtomicInteger(0);public static void main(String[] args) throws Exception {ExecutorService executorService = Executors.newFixedThreadPool(10);final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);for (int i = 0; i < clientTotal; i++) { //这里clientTotal你换成你的list的sizeatomicInteger.incrementAndGet();while (atomicInteger.get() > 4){Thread.sleep(10);}executorService.execute(() -> {consoleLog();countDownLatch.countDown();atomicInteger.decrementAndGet();});}countDownLatch.await();executorService.shutdown();log.info("全部执行完毕");}private static void consoleLog(){try {log.info("hello");Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}

java.util.concurrent.CountDownLatch 这个类可以实现你所要的功能例如：CountDownLatch latch = new CountDownLatch(5) //声明计数器为5个Thread t = new Thread() {public void run() {try {//TODO 你的应用} catch (Exception e) {//TODO 异常处理}finally {latch.countDown(); //这句是关键System.out.println("ok"); //5个线程都跑完后输出}}};t.start();然后让以上操作循环五次(就是说同时开5个线程)，那么这个"ok"就会在等到这5个线程都ok后才会被输出一次。

how far 多远？没有见过what far 的用法。what 什么用来问是什么，叫什么，做什么等What"s your name? 你叫什么名字？waht colour is your bag? 你的书包是什么颜色？how 怎样;如何（后接形容词或副词）多少，多么，多大;多少，多么，多大;以任何方式How does it work?它运转得怎么样？ How are you? 你好吗？How many people were there?有多少人？

众所周知 Jetbrains 系列的产品强大且好用. 但是对Vue的支持是出了名的不好 在编写Vue项目的时候, 往往只能使用Atom等编辑器 我这种 Jetbrains 粉表示不服, 一定有办法使用的. 在设置中选择plugin(插件), 选择 Browse repositories, 左上角搜索Vue 在设置中, 将 *.vue 添加进入Vue.js Template 中. 若提示冲突, 点击移除原来的即可 在设置中搜索JavaScript, 将JS版本选择为ECMAScript 6 在设置中搜索Unterminated statement, 将 Unterminated statement 的勾去掉 3.####防止node_modules使IDEA卡死 在IDEA开启的时候, 右下角全局设置 转到file types 同一个窗口下的 三个选项去除 正常使用 IDEA是无法是别的 要用这样的模式 目前没有完美的方法. 但是谁能阻止程序员的黑科技呢?

tail中文翻译是：作名词时意为：尾巴；踪迹辫子；燕尾服；作形容词时意为：从后面而来的，尾部的；作及物动词时意为：尾随；装上尾巴；作不及物动词时意为：跟踪；变少或缩小。双语例句1、The tail unit comprised an all-metal cantilever tailplane.尾翼单元包括一个全金属张臂式水平尾翼。2、The dog tucked in its tail, and, whimpering, limped off.那条狗夹起尾巴，呜咽着一瘸一拐地走开了。3、For a dog, an erect tail indicates aggression.对于狗来说，竖直的尾巴暗示着进攻。4、The dog wagged its tail.狗摇了摇尾巴。5、The horse flicked its tail.那匹马甩动着尾巴。短语补充a pony tail 马尾辫；on your tail 尾随；to turn tail 掉头逃跑；with your tail between your legs （由于失败或羞愧）夹着尾巴，垂头丧气。

　POS（Pointofsales）的中文意思是“销售点”，是一种配有条码）或OCR码（Opticalcharacterrecognition光字符码）终端阅读器，有现金或易货额度出纳功能。品种有有线和无线两种或有、无线兼用。POS机与广告易货交易平台的结算系统相联，其主要任务是对商品与媒体交易提供数据服务和管理功能，并进行非现金结算。　　什么是POS结算　　通过POS系统结算时应通过下列步骤：　　（1）地方易货代理或特约客户的易货出纳系统，将买方会员的购买或消费金额输入到POS终端；　　（2）读卡器（POS机）读取广告易货卡上磁条的认证数据、买方会员号码（密码）；　　（3）结算系统将所输入的数据送往中心的监管账户；　　（4）广告易货出纳系统对处理的结算数据确认后，由买方会员签字。买卖会员及易货代理或特约商户各留一份收据存根，易货代理或特约商户将其收据存根邮寄到易货公司；　　（5）易货公司确认买方已收到商品或媒体服务后，结算中心划拨易换额度。完成结算过程

u200b《合金装备5:幻痛》是由KONAMI工作室研发的一款开放世界动作冒险类游戏。已于2015年9月1日在家用机PS4、PS3、XBOX ONE、XBOX 360和PC平台同期发售 。 游戏将会作为早前发售游戏《合金装备5:原爆点》的续作，并附带多人游戏《合金装备Online 3》。游戏设定一个在架空的冷战世界，除了对峙中的美国和苏联外，世界的格局还被一种称为"合金装备"的武器所影响着。游戏的主要以传奇佣兵Big Boss在阿富汗和非洲的冒险为主轴，在复仇的怒火和新威胁崛起的时代下改变世界的故事。 《合金装备5》分为两部分，前传《原爆点》和正传《幻痛》。本作标题中的"幻痛"的含义是现实中的一种疾病，学名为"幻肢"。 游戏设定 背景设定 游戏设定一个在架空的冷战世界，除了对峙中的美国和苏联外，世界的格局还被一种称为"合金装备"(日文:メタルギア;英文:Metal Gear)的武器所影响着。《合金装备V:幻痛》发生在1984年，此时的游戏中和现实一样也在进行着阿富汗战争。尽管游戏大体和现实相同，但是玩家可以发现游戏内的武器和科技要远远比现实中的冷战时期先进。不光是"合金装备"本身，其他军事技术诸如外骨骼、双足机甲、光学隐形、全息影像都被各国谍报机关所使用着。其他科学技术诸如纳米技术、克隆、人工智慧也进入了实用化的阶段。玩家还可以在游戏中发现一些陌生却又熟悉的枪械，例如类似AK74突击步枪的SVG-76突击步枪。而性能相对于现实有些夸张、但却让老玩家怀念的"富尔顿地对空回收系统"也重回作品并在游戏内扮演着举足轻重的角色。 游戏中的 同时，游戏还包含制作人小岛秀夫惯有的幽默气息。比如主角Big Boss可以使用的装备中有被称为"终极隐蔽科技"的道具纸箱子。玩家可以藏在纸箱子里进行移动，并突然钻出纸箱子用消音麻醉手枪击倒敌人。 剧情设定 在一手建立的佣兵组织"无界之师"(Militaires Sans Frontières)于《原爆点》结尾被摧毁后，主角大首领(Big Boss)也陷入了长达九年的昏迷。 醒来后，世界发生了翻天覆地的变化，而他重新建立了佣兵组织"钻石狗"(Diamond Dogs)。在名为"毒蛇"(Venom Snake)的代号下，他重新卷入了位于阿富汗的苏联入侵行动中，目的是寻找要为袭击"无界之师"事件而负责的罪人。为了达成复仇，他重新召集了他的劲敌"山猫"(Ocelot)并与一批忠诚的战士们相遇，谱写新的历程。他与米勒(Kazuhira Miller)在复仇的过程中发现了名为"密码"(Cipher)的组织正在开发一款甚至可以超越合金装备的武器，而Big Boss的任务也迅速转变为消灭新的威胁。 指挥官米勒(前左)和大首领(前右) 游戏角色 主要角色 毒蛇(Venom Snake / Big Boss ) 配音演员:基弗·萨瑟兰、大冢明夫 毒蛇是本作的主角，玩家主要扮演他来进行任务。 通常被称为"大首领"(Big Boss)，而"毒蛇"(Venom Snake)是他行动的代号。传奇般的佣兵战士，建立了"无界之师"和"钻石狗"，并且是"钻石狗"的统领。在《原爆点》的结局时被炸弹炸伤，陷入了长达九年的昏迷。在《幻痛》建立了"钻石狗"，并中深入阿富汗和非洲，在阿富汗战争中寻找摧毁了"无界之师"要塞的罪人并予以复仇。 米勒(Kazuhira Miller) 配音演员:Robin Atkin Downes、杉田智和 米勒名字中Kazuhira的含义是"和平"，通常被称为Kaz。和大首领有着相同的理想，与他共同建立了"无界之师"。在《幻痛》中坐上了佣兵部队"钻石狗"的第二把交椅，成为了"钻石狗"的战略指挥官。 山猫(Ocelot) 配音演员:特洛伊·贝克、三上哲 山猫曾是苏联特种战斗小队的指挥官。追随大首领的助手，亦是一生的劲敌，大首领的右眼便是他在以前打伤。《幻痛》中则在大首领的麾下负责"钻石狗"的审问和人事工作。 骷髅脸(Skull Face) 配音演员:詹姆斯·霍兰、土师孝也 骷髅面有着十分悲惨的童年，致使他全身烧伤。在《原爆点》中掌管着秘密间谍部队XOF，并在《幻痛》的年代建立了新的特种部队"寄生部队"(Parasite Unit)。 配角 静(Quiet) 配音演员:Stefanie Joosten 《幻痛》的新人物。参与了阿富汗战争的女性狙击手。在《幻痛》中加入了大首领的"钻石狗"。Quiet为人沉默，她的身体经过实验的改造拥有着超越常人的力量。 帕姿(Paz Ortega Andrade) 配音演员:泰拉·卡伦多芙、水树奈奈 通常被称为Paz。在1974年作为间谍机关"密码"(Cipher)的一员，潜入了"无界之师"，最终导致"无界之师"被捣毁。她身为KGB和CIA的多重间谍，伪装成一位热爱和平的哥斯大黎加少女。在《合金装备5:原爆点》的结局时身亡。 休伊(Huey Emmerich) 配音演员:Chrisher Randolph、田中秀幸 在"无界之师"时期就帮助大首领和米勒研究与开发军事装备。《幻痛》中依旧是"钻石狗"的首席科学家，并拥有自己的私人实验室。 奇科(Ricardo Valenciano Libre) 配音演员:Antony Del Rio 通常被称为Chico，在西班牙语中意为小男孩。少年兵，是哥斯大黎加地方民兵反抗组织"桑地诺民族解放阵线"的一员。有一个叫做阿曼达的姐姐，而他的哥哥则是当地反抗军的头目。在《原爆点》中和Paz一同被捕并被审问。 其他角色 Code Talker(Jay Tavare、阪修) iDroid(唐娜·伯克) Eli(Piers Stubbs、本城雄太郎) Zadornov(史蒂夫·布卢姆) 特色系统 战斗系统 在《幻痛》中，玩家将主要操纵被称为"惩戒之毒蛇"(Punished "Venom" Snake)或"大首领"(Big Boss)的主角。主要的游戏操作和《合金装备5:原爆点》并没有明显的区别。玩家需要在开放世界中锁定敌人的基地，并选择任意的方向和方式 潜入 并完成所规定的目标。躲避并保持未被发现的状态能得到更高的分数，而杀人则对在分数上有所惩罚。主角"毒蛇"每次任务可携带两个主要武器和两个次要武器，四种装备和八种道具。武器和道具的选择超过几百种，包括但不限于望远镜、地图、手枪、突击步枪和爆炸物，并根据其用途分为"致命"、"击晕"和"麻醉"。在《幻痛》中，玩家也有十分多样的载具和枪械可供选择，同时载具和枪械还可以被大幅度的改装。 在移动方面，玩家可以选择缓步前进或急速奔跑。在一些多山的地图还可以用岩体的石缝来攀爬。另外，游戏对于支援方面做了较大的改进。首先玩家可以选择多种多样的方式让直升机来支援自己并敌人，包括机炮和火箭弹。 而游戏还包括了一个全新的 伙伴系统 (Buddy System)，玩家可以给伙伴下达不同的命令使其帮助玩家渡过难关。伙伴包括"钻石马"(D-horse)，其可以携带更多的装备并在平原地区快速移动;"静"(Quiet)是一位沉默的女性狙击手，她可以进行多种多样的侦察与搜刮，还可以和主角"毒蛇"相配合进行各种各样的远距离打击;"D-Walker"，是一款可以进行火力侦察并安静快速的移动到敌人背后的双足机器人;以及"钻石犬"(DD)，能够骚扰甚至击晕敌人并紧紧跟随主角"Big Boss"行动的沙漠狼。 伙伴系统 建设系统 和前作《合金装备:和平行者》一样，《幻痛》也提供了基地建设这一玩法。玩家可以建设自己的要塞" Mother Base "，并在要塞中升级武器和装备。在战场上所有的额外支援也都是由Mother Base提供的。和《和平行者》相同，富尔顿地对空回收系统也再次回归系列。利用富尔顿，玩家可以将敌人运送回基地并训练成己方的一员在接下来的行动中出工出力。也可以直接将场景中的不同物品，例如货柜、车辆等利用富尔顿运送回基地，作为接下来的行动的后备与研发资源。玩家还可以通过手机应用程式来访问自己的Mother Base，随时随地进行建设和升级。 不像《和平行者》中只能从一个二维界面中俯瞰Mother Base并建设，在《幻痛》中，Mother Base是一幅实际的游戏地图，并可被玩家自由探索。随着玩家的建设，Mother Base的占地面积也会变得越来越大并且越来越复杂。 玩家可以在其他玩家的Mother Base偷窃 Mother Base还包含多人对战玩法 "前线作战基地" (英文:Forward Opreating Base，简称FOB)。玩家还可以拓展和建设多个不同的FOB，并邀请其他好友光顾这些FOB。但和Mother Base不同的地方在于，FOB可以被其他玩家所入侵并窃取各类资源和人力。被其他玩家入侵后，玩家可以选择进行报复。为了防止资源被轻易窃取，玩家在建设FOB时可以布置和升级基地的一些防御设备，例如近防炮、摄像头和无人侦察机，这些操作都可以在战役模式中完成。玩家可以将FOB的结构设计的十分复杂，以阻碍其他的玩家能够顺利的潜入。开发者提到FOB入侵功能可在游戏中完全被关闭，以迎合一些不愿意参与多人游戏的玩家。但是打开入侵功能并进行相关的任务可以提高FOB和Mother Base建设的速度。 动态世界 游戏的AI会改进他们的技巧和装备，并随着战况的变化使用这些新的能力。如果玩家持续的使用相同的游戏方式，AI会意识到并针对玩家的行为改变自身的行动。重复的进行同一个人物会导致任务中敌人数量增加，同时每个敌人的应对更严密周到。例如，当玩家总是持续进行爆头击杀时，AI会懂得这种局面并开始装备头盔。 《幻痛》也是合金装备系列第一款支持 实时昼夜 更替的游戏。昼夜的变化会影响敌人的注意力，并且暴露出换班时的防守漏洞。如果玩家想要加快时间的流逝速度，可以使用名为"幻影雪茄"(Phantom Cigar)的电子菸。当玩家使用雪茄时，背景会出现一支半透明的SEIKO电子表来显示时间的流速。这时玩家可以仔细观察被标记敌人的动向，以寻找合适的时机潜入敌人的阵地。 Big Boss正在使用幻影雪茄 除了昼夜外，游戏还有 动态天气 效果。天气将会根据地形随机出现，例如沙漠地区的沙暴、丛林地区的雨。天气也会改变能见度、环境音量。从而为玩家提供了不同的战术可能性。当然，如果玩家想要快速渡过不利的天气，也可以使用"幻影雪茄"加速时间流逝。 基于游戏开放世界的设计，玩家可以自由的选择剧情章节的先后顺序。小岛秀夫提到，即便玩家采用不同的顺序进行任务，但仍然能够在游戏进行到特定时点时理解剧情。玩家可以在不同的位置开始任务，并用不同的手段达到目标地点并完成目标任务。例如，玩家既可以用狙击枪在远距离击杀敌军指挥官，也可以选择先破坏掉敌人的雷达设备，并搭乘武装直升机飞临敌军基地上空进行强攻。 多人游戏 多人游戏方面除了Mother Base外，游戏还附带有传统的6vs6、8vs8式的团队合作对战游戏《合金装备Online》 。《合金装备Online》由小岛工作室洛杉矶分部开发(后改名Konami洛杉矶)，游戏虽然附赠于《幻痛》之中，但是游戏不随《幻痛》一同发售，开发者称主机版本预定于2015年冬季发售，而PC版本则要延期至2016年春季。 一组玩家配合强攻敌人小队 游戏道具 枪械 玩家主要依靠枪械来战斗，主角还可以使用其左手上所装的不同义肢来使用不同的技能，例如可以使敌人陷入昏阙的电击手或可以探测一定范围内生命 *** 置声纳。 主武器(腰部) 突击步枪、霰弹枪、卡宾步枪等中型武器佩戴在这个位置。 主武器(后背) 狙击步枪、机关枪、防暴盾牌等大型武器佩戴在这个位置/ 副武器(腿部) 手枪、冲锋枪等小型武器佩戴在这个位置，搬运物体时也可以使用这个栏位的武器。 副武器(手部) 只有装有义肢的主角可以使用这个栏位。 装备和道具 除了枪械外，游戏还提供不同的装备和道具用于其他的战术用途。例如信号弹、麻醉烟雾弹。夜视仪也重回游戏，但和《原爆点》不同，幻痛的夜视仪拥有电量限制。 服装 玩家游戏可以在游戏中解锁不同的服装。不同的服装拥有不同的防御力和隐蔽程度。例如"Snaking Suit"可以起到很好的隐蔽效果，但是防御力不佳。而"Battle Dress"的防御力很好，但是因为服装体积较大即便躲在墙角后也会被近处的敌人发觉。 配置需求 项目 最低配置需求 推荐配置需求 处理器 Core i5-4460 (3.40GHz)或更好 Core i7-4790 (4.00GHz)或更好 记忆体 4GB 8GB 显示卡 GeForce GTX 650或更好(必须支持Direct X 11) GeForce GTX 760或更好(必须支持Direct X 11) 作业系统 Windows 7(64位版本的作业系统) Windows 7/8/10(64位版本的作业系统) 硬碟空间 35GB空闲空间或更多 表格参考资料: 游戏开发 配音工作 和前代的《合金装备》不同，在本作中，小岛工作室在进行动作捕捉时一直是基于英语配音演员而不是日语配音演员。而面部肌肉动作捕捉还是第一次套用于《合金装备》系列。日语配音则会在英语配音工作完成后再进行，同时，日语配音时也会进行独立的面部肌肉动作捕捉，这让日语版本的游戏人物也有对应声音的嘴型。 在2013年6月6日，科乐美年度E3展前会议上，科乐美确认了配音演员基弗·萨瑟兰将为游戏中的角色"大首领"(Big Boss)配音，以及相关的面部捕捉工作 。而前几部《合金装备》中为Snake配音的David Hayter则不会在这款游戏中献声，而David表示是自己没有被工作室选中 。小岛秀夫在对于回答关于挑选配音演员的问题时说道:"David的确有令人折服的表演能力，并能将微妙的语气表现的惟妙惟肖"，但是，"我们需要一个和David素质一样优秀，然而年龄能有一种人在40岁晚年的感觉。"后来，好莱坞制片人阿维·阿拉德向小岛秀夫推荐了如今被选中的配音员萨瑟兰 。至于日语方面则依旧和前作一样没有任何变动，为大冢明夫。 而其他配音演员则包括为山猫配音的特洛伊·贝克 ;为Code Talker配音的Jay Tavare ;为骷髅面配音的詹姆斯·霍兰;为米勒配音的Robin Atkin Downes，以及为Emmerich博士配音的Chrisher Randolph 。日语方面，则邀请了杉田智和配音米勒;田中秀幸配音Emmerich博士;土师孝也配音骷髅面;三上哲配音山猫;阪修配音Code Talker ;本城雄太郎配音Eli 。 在为Quiet配音的Stefanie Joosten 现居于日本的荷兰裔模特Stefanie Joosten将会为Quiet配音。她本身就会说日语和英语，不过她在游戏中配音的角色没有实际台词，是一个完全沉默的女狙击手。 除了配音外，同时Stefanie Joosten还担任她配音的角色的全身造型模板。 早期宣传 在2012年2月，一个名为"无界开发"且下属于Konami的网站透露了"下一代MGS"的讯息。该网页被证实是用于在同年3月的GDC 2012游戏展前进行宣传活动。 在网站中也透露了游戏将以次世代的"Fox Engine"进行开发。在同一年，大量有关于新引擎的截图和视频也被开发团队透露。 2012年合金装备的 而《合金装备5:原爆点》则在2012年8月30日正式被小岛工作室公布，同时《原爆点》也成为了合金装备系列25周年的庆祝作品。而在2012年Penny Arcade Expo游戏展上，《原爆点》被正式的公开 。制作人小岛秀夫确认了Big Boss将作为《合金装备5》的主角，而且《原爆点》将会作为另一款《合金装备5》作品的前传 。《原爆点》也是首款使用由小岛工作室开发的Fox Engine引擎的作品。 在2013年1月，小岛秀夫透露《原爆点》是合金装备游戏第一次大幅削减过场动画的时间。因为小岛秀夫觉得以前那样非常长的过场动画已经过时了。 在小岛秀夫和国外媒体VG247的访谈中，他提到了对于是否应该发售原爆点的担忧。因为《原爆点》是合金装备系列作品中首次探索限制级和成人化内容的作品，而这种和以往不同的风格给《原爆点》的发售增加了风险。作为游戏创作者，小岛秀夫希望冒险提升游戏的黑暗向核心，并吸引那些更加成熟的客群群体。但是作为制作人，他也不愿意为了销量而负担过大的风险。但最后，他内心"创作者"的部分推动他决定"将游戏创意看的比销量更重要"。 开发历程 在2012年的Spike游戏典礼上，瑞典的Moby Dick工作室公布了一段被称为"幻痛"的影片，并声明影片的画面完全为游戏实际录像。据工作室的Joakim Mogren所说，游戏"将会成为一段无与伦比的体验。" 在演讲过后，很多人发现"幻痛"是最新的合金装备游戏，而视频中的主角即为Big Boss，而所有的画面为Fox Engine即时演算，而在片尾出现的V则在暗示《合金装备5》的"五"。 另外，Joakim Mogren的名字Joakim即是将小岛秀夫(Kojima)的名字打乱顺序得来，而Moby Dick工作室的主页是假的 。之后，小岛秀夫还开玩笑的"谴责"Joakim的灵感全是从自己那里得到的。 最早公布的《合金装备5:幻痛》海报 后来小岛工作室的员工又伪装成Joakim又参加了一次采访，并透露2013年GDC游戏展上会透露更多信息。 在2013年3月27日的GDC 2013游戏展上，小岛秀夫正式确认了2012年的"幻痛"宣传片就是小岛工作室自己做的。他同时还提到《合金装备5》将会分为前传"原爆点"和正传"幻痛"两个部分，同时正传的全名为《合金装备5:幻痛》。 最早的游戏宣传片是在PC上运行的。当问及小岛PC的发售时，他回答道:"我们正在做。"，并且会和PS4、XBOX ONE版本一起发售。但是，他也提到PC版本并不是工作室当前的首要任务 。同时，他提到合金装备5的宣传片将会和最终游戏的实际画面相同，不会有下降。他也提到这一部合金装备将会是系列的最后一作，不像前几作那些以不同副标题出品的外传，这次的幻痛已经到达了系列的尽头。他还提到，Big Boss在宣传片中看到的那只浑身燃烧的巨型蓝鲸是因为幻觉，而寻找现实与虚幻的平衡将是幻痛的主题之一。 在2013年6月10日的E3游戏展上，小岛工作室在微软发布会中展示了新的宣传片。 新的宣传片包含新的游戏系统以及游戏角色。在同年的6月11日，小岛在Konami的官方频道公布了给成年观众观看的未经剪辑的版本。在宣传片的末尾也确认了PS4版本会随XBOX ONE版本发售。尽管该宣传片也是在PC上运行并录制而成的，但是小岛指出片中的纹理和模型是PS3和XBOX360级别的，而未来还会提升到PS4等同代主机的级别。 游戏开发版本在PC上演示的截图 小岛还提及了游戏内容过多以至于难以完成，有"《原爆点》的200(倍大)!" 同时，小岛还希望游戏具有让玩家间实时连线的功能，因此他为游戏加入了"Mother Base"功能，随着游戏的进行，玩家可以收集材料并建设自己的Mother Base，就像一些城市建设游戏一样。同时，玩家还可以亲自造访自己或其它人的Mother Base，保护和偷取自己或他人的资源。小岛还像《原爆点》里一样将游戏中绝大多数的武器和装备虚构化，用于体现Big Boss九年的昏迷时间，外界发生的天翻地覆的变化。 在2014年6月9日的E3 2014游戏展上，游戏在索尼发布会上公布了全新的宣传片，新宣传片主要围绕钻石狗和Big Boss的内心。在宣传片中也透露出了不少游戏画面上的进展，以及Big Boss的人物设计变化 。在2014到2015年间，游戏开始不断的更新不同的演示。E3 2015游戏展上，新的宣传片被公布，背景音乐是由乐团新秩序演奏的"Elegia"。除了宣传片外，Konami官方频道还上传了大量的演示为游戏造势。 在2015年的德国科隆游戏展前，游戏的开发人员在Steam商店的网页上公布了游戏PC版的配置需求，同时提到PC版的发售日期将会提前到与主机平台同时发售 ，但开发人员也透露附带在《幻痛》游戏中的网路对战游戏《合金装备Online 3》将会分别在主机和PC平台延期发售日至2015年年末至2016年年初。而在科隆展第二天，Konami官方频道再次放出了新的宣传片，随后则是全新的"Mother Base"的演示。小岛秀夫也在推特中提到他会在游戏发售时准备一个新的宣传片。 外界评价 《合金装备V:幻痛》发售前，Konami就已经给不同的游戏媒体发放了游戏的完整样本，除了受到保密协定的限制不能播放视频外，游戏媒体可以自由的畅谈除了剧情外游戏所有的细节。绝大部分的外国媒体都给出了接近满分的评价，并几乎没有任何负面的评价。大多数媒体都赞扬游戏的玩法机制、内容丰富度和故事，也有部分媒体夸赞视觉和声音效果。 不过，因为本作取消了过场动画，IGN认为剧情的衔接性不如前作。而Gamespot则在评测结尾表示，Konami寄送给他们的样本中没有多人游戏的部分，而Konami回应称即便购买了《幻痛》游戏，进行多人游戏时还需要额外付费，此前的游戏演示也有提到可以通过付费来加速游戏中道具的取得速度。Gamespot表示，尽管满分已经给出，但类似破坏游戏体验的二次付费和微交易功能可能会在游戏正式发售后迫使他们修改游戏的最终评分。 媒体评分列表 IGN 10/10(满分) Gamespot 10/10(满分) Daily Dot 5/5(满分) Respawn Ninja 100%(满分) Famitsu(Fami通) 40(满分) Destructoid 9/10 Press Start 9/10 EGM 9.5/10 Game Informer 9.25/10 Gametrailers 9.5/10 "《合金装备V:幻痛》的游戏机制是一个奇迹、让玩家能通过自己的智慧和创造力获取成就感--没有多少游戏可以做到这种程度。"(IGN评) "每一个冬粉都会有自己喜爱的《合金装备》作品，可能在这方面玩家没有统一的意见。但是《合金装备5:幻痛》的出现解决了这个问题。《合金装备》系列中没有哪一部作品会如此有深度，会有如此丰富的游戏内容。游戏中的开放世界令整体素质更上一个台阶。《幻痛》无疑是《合金装备》系列中最好的作品。"(Gamespot评) "小岛讲述故事的手法十分智慧，他的故事有很多铺垫。玩家只有事后才能意识到，原来之前的每一个细节都是有意义的。"(Daily Dot评) "尽管游戏有一些小的瑕疵，但《合金装备V:幻痛》感觉像是整部系列的一个巨大的狂欢，并揭开了一个新的篇章。如果这部精彩的作品真的是小岛最后的谢幕，那么可以说一切都被他画上了完美的句点。"(Destructoid评) "《合金装备V:幻痛》是我今年玩过的最佳游戏之一。"(Respawn Ninja评) "让一个游戏系列持久生存下去是离不开改变的，而《合金装备5:幻痛》就是一个勇于冒险的证明。一个开放的世界，一个可自定义的基地，一个多变的任务体系--这些都不曾是传统《合金装备》系列中的元素，但正是这些令《幻痛》如此出色。"(Game Informer评)

形容窃窃私语的成语 【成语】： 窃窃偶语 【拼音】： qiè qiè ǒu yǔ 【解释】： 窃窃：偷偷；语：说话。背地里小声说话。 【成语】： 交头接耳 【拼音】： jiāo tóu jiē ěr 【解释】： 交头：头靠着头；接耳：嘴凑近耳朵。形容两个人凑近低声交谈。 形容窃窃私语的四字词语 低声密谈、 喁喁私语、 切切私语、 窃窃私议、 交头接耳 关于成语（窃窃私语）的成语解释和意思 【拼音】： qiè qiè sī yǔ 【解释】： 背地里小声说话。 【出处】： 唐·韩愈《顺宗实录·永贞五年》：“虽叛两使事，未尝以簿书为意，日引其党屏人切切细语，谋夺官者兵，以制四海之命。” 和成语（窃窃私语）意思相反的四字词语 【成语】： 高谈阔论 【拼音】： gāo tán kuò lùn 【解释】： 高：高深；阔：广阔。多指不着边际地大发议论。 【出处】： 唐·吕岩《徽宗斋会》：“高谈阔论若无人，可惜明君不遇真。” 【成语】： 夸夸其谈 【拼音】： kuā kuā qí tán 【解释】： 形容说话浮夸不切实际。 【出处】： 清·吴敬梓《儒林外史》第十一回：“进了书房门，听见杨执中在内咶咶而谈，知道是他已来了，进去作揖同，同坐下。” 扩展阅读：用成语（窃窃私语）写一句话造句子带有中英文翻译 一、他们俩在一块儿窃窃私语，不知谈论些什么。 1、 They were whispering together, not knowing what to talk about. 二、开大会时要注意听讲，不要在下面窃窃私语。 2、 Pay attention to listening and not whispering under the meeting. 三、夏日的夜晚山里静悄悄的，只有昆虫在窃窃私语。 3、 In the summer night, the mountain is quiet, only insects are whispering. 四、上化学课时她俩窃窃私语。 4、 They whispered in chemistry class. 五、一群小女孩在操场一角窃窃私语,不时还用眼睛瞅瞅四周,看是不是有人注意她们。 5、 A group of little girls are whispering in a corner of the playground. From time to time, they look around to see if they are noticed. 六、大家正在窃窃私语,但是,他进来就都不说了。 6、 Everyone was whispering, but he didn"t speak when he came in. 七、在考场上,他们俩窃窃私语,被老师发现了。 7、 In the examination room, the two of them whispered and were discovered by the teacher.

什么是pos机，pos机是什么意思？pos（pointofsales）的中文意思是“销售点”，是一种配有条码）或ocr码（opticalcharacterrecognition光字符码）终端阅读器，有现金或易货额度出纳功能。品种有有线和无线两种或有、无线兼用。pos机与广告易货交易平台的结算系统相联，其主要任务是对商品与媒体交易提供数据服务和管理功能，并进行非现金结算。pos也称为销售点情报管理系统。过去零售业常规收银机只能处理简单收银，发票，结帐等简单销售作业，得到之管理情报极为有限，仅止于销售总金额，部门销售基本统计资料。对于一般零售卖场少则上千多则上万种商品之基本经营情报：如营业毛利分析，单品销售资料，畅滞销商品，商品库存，回转率...却无法获得。导入pos系统主要是解决上述零售业管理盲点。pos系统基本作业原理是先将商品资料创建于计算机文件内，透过计算机收银机联机架构，商品上之条码能透过收银设备上光学读取设备直接读入后（或由键盘直接输入代号）马上可以显示商品信息（单价，部门，折扣...）加速收银速度与正确性。每笔商品销售明细资料（售价，部门，时段，客层）自动记录下来，再由联机架购传回计算机。经由计算机计算处理即能生成各种销售统计分析信息当为经营管理依据。pos系统除能提供精确销售情报外，透过销售记录能掌握卖场上所有单品库存量供采购部门参考或与eos系统连结。总之pos为现代零售管理必备工具。pos结算通过pos系统结算时应通过下列步骤：（1）地方易货代理或特约客户的易货出纳系统，将买方会员的购买或消费金额输入到pos终端；（2）读卡器（pos机）读取广告易货卡上磁条的认证数据、买方会员号码（密码）；（3）结算系统将所输入的数据送往中心的监管账户；（4）广告易货出纳系统对处理的结算数据确认后，由买方会员签字。买卖会员及易货代理或特约商户各留一份收据存根，易货代理或特约商户将其收据存根邮寄到易货公司；（5）易货公司确认买方已收到商品或媒体服务后，结算中心划拨易换额度。完成结算过程。

本机svn出问题了吧。。

expected,expectant,expectableexpected和expectantexpectant做形容词时后面都是加要修饰的名词的，也就是说做形容词时不单用。expected做形容词是几乎都是不修饰名词的，表示状态。此外expectant还可做名词，表示期望的人或物。expect是动词，表示期望，expected是它的过去式尽力了

1. 对js的开发有长足的支持，那些自动提示，代码主题，调试之类的我就不说了，主要是对流行技术的支持，比如Node.js,less,sass,jq,ext,prototype等框架的支持 。2. 自身对插件的支持，主要体现在webstorm 2.0以后就已经包涵了zencoding了，而如果dw不是完整版的话，zencoding的安装难度可想而知。如果是完整版的话，就不得不忍受一坨无用的插件。3. 团队开发的支持，主要体现在svn,git等版本管理工具，无须引入，直接可用。而且单文件还支持本地历史记录。4. 插件的支持，主要体现在vim，可直接安装插件，还有其它的插件等待着你去挖掘。dw比webstorm的优点，那就是dw的内存占用大概平常80M左右,而webstorm得300M左右，这是我发现唯一dw的长处。如果说,dw是美工偶尔拖拖表格，写写css的小工具的话，那么webstorm是前端开发的必备利器，不只是对html,css的抒写比较强悍，而且对js，jq等其它js框架开发更是完美。简单的说：dw就是一个编辑器，而webstorm是一个IDE。另外一个，dw自从cs4之后，就已经无路可走，本来近几年的js开发如火如荼，看看这帮2B在dw cs5里边添加的那些隔靴搔痒的新功能，想想都笑，用户在不断的成长，市场在不断的变化，而这帮2B还在沉睡，残酷的市场如金的岁月会检验具有竞争力的产品。相比于dw的固步自封，webstorm正在走上坡路。这里不得不提一下另外一款:aptana ，本身在js方面有一定的靓点，可惜现在搞得跟dw一样，没有抓住现下流行的趋势，一直吃老本。看看aptana 3.0那些2B的功能，就能原谅dw现在还是这个样子。当然一分为二的看的话：如果你只是想拖拖表格，搞搞css，dw cs4 是目前市场上比较适合的编辑器。他的html结构自动识别折叠，能很快找到不完整的div,ctrl + d，跳到定义的class位置等等，是其它编辑器所没有的，在加上zencoding的话，写写静态页面足矣！如果你不只是想折腾css，而是想捣鼓捣鼓js,less,sass,node.js等等之类的新玩意，也想试试vim结合传统编辑器的威力，那webstorm绝对是你最佳的选择。如果你是phper，我推荐phpstorm，它包含所有webstorm的功能。

expected 英[ɪkˈspektɪd] adj. （用作定语） 预期要发生的，期待中的; v. 预料; ( expect的过去式和过去分词 ) 期望; 要求; 认为（某事）会发生; 全部释义>>[例句]The talks are expected to continue until tomorrow.预计会谈将持续到明天。

商户申请安装POS机需具备的条件⊙商户没有被列入中国银联或各级政府及相关部门的不良信息系统⊙商户持有工商部门核发的有效营业执照⊙商户持有有效的税务登记证⊙商户已有公章、财务章⊙商户已在银行开立对公结算帐户⊙商户有固定的经营场所⊙商户有一定的经营规模及持续经营能力2、特约商户申请及安装POS机的一般步骤⊙如实反映情况，配合银联客户经理填写好《商户信息调查表》⊙填写《深圳银联公用POS商户入网登记表》⊙填写《特约商户受理银行卡及安装POS设备协议书》⊙填写《委托银行代收款协议书》⊙提供加盖公章的营业执照和税务登记证复印件⊙银联审批阶段（三至五个工作日）⊙终端程序下载、测试⊙银联工作人员装机⊙商户培训⊙填写《装机签收收据》和《商户培训信息反馈表》商家类型不同，手续费也不一样，一般家电卖场最低，甚至有40封顶一说，超市稍高，最高自然是百货商店某网站找到的资料，可以参考一下。按家电专卖、超级市场、百货商店三类比较，上海刷卡手续费率为0.6％、0.5％－0.8％、0.9％；广州为0.8％－1％、0.5％－0.8％、1％；武汉为1％、0.5％、1％；杭州为0.8％、1.5％、2％；厦门为0.8％、1.5％－2％、1.5％－2％；申请POS机不难，但是除了手续费，还有押金（按终端机数目）以及通信费（就是电话费，POS连电话线的）。再强调一下，这是商户和银联之间的结算方式，消费者持银联卡消费无需付出任何手续费（不管本地、外地）,