Java编写程序,分别使用顺序流和并行流计算10,、20、30和40这几个数的阶乘,输出结果及完成计算的时间。

CountDownLatch是一个同步辅助类，犹如倒计时计数器，创建对象时通过构造方法设置初始值，调用CountDownLatch对象的await()方法则处于等待状态，调用countDown()方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行。

　　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后才会被输出一次。

打开Webstorm的setting，可以使用快捷键：“Ctrl+Alt+s”，也可到“Help”-》“FindAction..”里搜索“setting”（在菜单栏一直找不到“setting”选项在哪，）。打开setting之后，在IDESetting中的FileTypes（也可以直接用setting的搜索功能搜索filetypes）中的RecognizedFileTypes框中选择HtmlFiles（因为tpl模板本身就是html文件，所以就用html文件的高亮格式即可），然后在RegisteredPatterns中添加“*.tpl”。最后点击“OK”即可。

how far 用于问距离有多远，how long 用于询问时间或事物有多长。 如： How fardid you walk? 你走了多远? How long are the holidays? 假期有多长？二者在具体询问对象上有本质上的区别。 how long和how far的具体区别 how long和how far在询问路程时的区别为：意思不同、用法不同、侧重点不同。 一、意思不同 1、how long：多长时间。 2、how far：(离…)多远，到什么程度。 二、用法不同 1、how long：基本意思是“长的”，可表示时间和距离的长短或长度，也可表示书籍、信件、故事之类的内容的长短。long在句中可作定语，也可作表语。long用作副词时，其基本意思是“长久地”，主要用于修饰静态动词，表示时间延续之长。 2、how far：far的基本意思是“远”，可指距离的远，也可指时间的远。指距离时，一般用于否定句或疑问句，在肯定句中，多用a long way代替far。但far如位于too或so之后，则可以用于肯定句，与其他副词或介词连用时，也可以用于肯定句。 三、侧重点不同 1、how long：指事物，东西的长短。 2、how far：指距离的长短。

tail

(一)潜水电泵的特点是什么？ (1)、潜水电泵体积小,重量轻,结构简单紧凑。安装使用方便,适应性强,是当今一种节能、高效新产品,其性能指标较为先进。 9635626002、潜水电泵的使用条件是什么？ ⑴、电源：适用于频率为50赫兹的三相交流电,额定电压380伏,允许变动范围：±5%。 ⑵、水温：水温不得高于+20℃；水中含砂量不大于0.01%(重量比)；水中的酸碱度PH值为6.5～8.5；水中不含有油类；该电泵在正常工作时保证完全浸在水中,严禁脱水运转。 9635626003、潜水电泵型号各代表什么? 200QJ50?D39/3,其中：200代表适用最小井径为200毫米；QJ代表形式特征：井用潜水泵；50代表流量为50吨/小时；39代表总扬程为39米；3代表级数为3级。 9635626004、潜水泵的使用范围是什么？ 200QJ型潜水电泵适用农田灌溉和解决山区人、畜用水,并可用于工厂、矿山排、给水。 250QJ型潜水电泵适用于深井、河渠、水库。 9635626005、潜水电泵的结构特点是什么？ ⑴、电动机为密封充水式,电机充满清水但不与电机外的水交换,电机底部装有橡皮调压膜可自动调整由于电机升温引起的机内水体的胀缩压力。 ⑵、为了防止水中砂石进入电机内,在上端装有甩砂环和两个油封组成防砂结构,水泵采用离心水泵叶轮,结构简单、紧凑。 ⑶、采用了水润滑轴承,结构简单,防腐防锈性能好。 ⑷、电机采用新型耐水防锈和涂漆工艺。 ⑸、电机绕组采用聚乙烯绝缘尼龙护套绕线组又称耐水绕线组,确保绝缘、防水。 9635626006、潜水电泵安装有什么要求？ ⑴、电机底部距井底不得小于3米。 ⑵、水泵的吸水网在工作中必须淹没在动水位水面以下。 ⑶、电路必须安装电流、电压测量仪表及短路保护,否则不得运行使用,以免发生故障烧坏电机。 9635626007、潜水电泵安装前的准备工作是什么？ ⑴、检查水泵各部件有无损坏,紧固件有无松动,引出电缆有无破坏。 ⑵、检查电源电压、水井的井径、出水量、动水位是否符合使用条件。 ⑶、卸下滤水网,从进水节处转动主轴、转动应灵活。 ⑷、拧下注水螺塞,向电机内灌满清水,放上橡皮圈、拧紧螺塞。浸水24小时,如电机内冷却水无渗漏可测定电机绕组对地的绝缘电阻(用500伏摇表),其值不低于50兆欧时,把潜水电泵直立放稳向水泵轴内灌水瞬时起动电泵(不超过1秒),观察转向与转面牌一致后装好滤水网,准备下井。 9635626008、潜水电泵安装前需准备的工具是什么？ ⑴起重吊链一个。 ⑵、三角架一个。 ⑶、能承受电泵重量的吊缆两根。 ⑷、常用电工及维修工具等。 ⑸、安装卡箍两付。 9635626009、潜水电泵怎样安装？ ⑴、水泵在下井前必须按以下规定接好电缆密封接头。 a、清理接头,使其接触良好。 b、将接头附近的电缆清理干净,不得有泥沙、油污、水痕等。然后用乳胶带半叠包两层。 c、半叠包聚乙烯粘胶带2?D3层(两端要超出乳胶带10毫米)。 d、将接头完全浸入水中24小时后用表测定其绝缘电阻,整条电缆(包括接头)的绝缘电阻值应低于电机对地绝缘电阻；否则必须重包,以防漏水。 e、再检查其它地方电缆有无断开、破裂现象,发现有损坏及时进行密封或调换后方可使用。 ⑵、向泵内灌水,润滑轴承。 ⑶、电泵下井安装顺序如下： a、在井口平行放好两块垫木,再用卡箍甲卡紧水泵,并用吊链吊起,慢慢系入井中,直至卡箍可靠地搭于井口,卸下吊链,用卡箍乙卡紧一节输水管,并用吊链吊起,慢慢系下使泵管法兰盘与电泵的法兰盘连紧接固,用吊链吊起,卸下卡箍甲,慢慢放入井中,到卡箍乙可靠地搭在井口后,松开吊链取下挂勾。 b、用卡箍甲夹紧第二根水管,与已下井的输水管可靠连接后吊起,然后松开卡箍乙......。最后将卡箍可靠地固定井口上。 c、水泵在安装中,电缆应与管平行向上并在每节输水管上用塑料带或耐水绳索系牢。 9635626010、潜水电泵安装时应注意什么？ ⑴、水泵入井时,如发现受卡现象,要转动或搬运长输水管,克服卡住点,若各种措施无效,切不可强行下泵入井,以免造成电泵和井壁卡死事故。 ⑵、安装时,输水管胶垫要垫平,螺栓均匀对称拧紧。 ⑶、要求电机下端距井底不少于3米。 ⑷、潜水电泵入水深度(静水位以后)不超过60米,动水位距进水节不少于1?D1.5米,否则容易损坏水泵橡胶轴承和烧毁潜水电机。 (二)潜水电泵运行管理与故障排查 9635626011、潜水电泵运转中应注意什么？ 潜水电泵运转时出水应连续均匀,电流平稳,电泵应无不正常振动和不正常噪音,如有异常现象应立即进行调整,如发现下列情况应立即停机排除故障后再运转。 ⑴电流增大超过额定值的120%； ⑵、在三相电压平衡的条件下,电机工作电流三相不平衡时,任一相与三相平均值的偏差大于三相平均值的10%或停机后再次起动困难的。 ⑶、电机运转期间三相电流产生不规则摆动时。 ⑷、电机对地热态绝缘电阻(工作4小时后)低于0.5兆欧时。 ⑸、电机缺相运转时。 9635626012、潜水电泵起动时应注意什么？ ⑴、开关起动时必须先关闭闸阀,以防起动负荷过大烧毁电机,起动后缓慢开起闸阀。 ⑵、水泵两次起动间隔不得少于5分钟,以防输水管内水柱尚未完全回流入井,二次起动时,功率突然增大、烧毁电机。 9635626013、潜水电泵停车时应该注意什么？ 停车时,先关闸阀后停车,以防停车回水损坏电泵,长期停泵、停用阶段,可每周运转20?D30分钟。 9635626014、潜水电泵不出水或出水不太足怎么办？ ⑴、电机是否反转,如反转,调换任意两相接头。 ⑵、滤水网是否被堵塞,如堵塞,清除杂物。 ⑶、水泵连接部分是否破裂,如破裂,拆开修整。 ⑷、水泵接头是否漏水,如漏水,加垫拧紧。 ⑸、水源不足进水节是否露出水面,如进水节露出水面,下降电泵。 ⑹、密封环或叶轮是否严重磨损,如果是,更换密封环和叶轮。 9635626015、潜水电泵频繁跳闸怎么办？ ⑴、检查电机是否超载,如果超载,调整流量、电源电压、或停用。 ⑵、检查保护开关的额定电流是否过小,如果是电流过小,适当调整额定电流。 ⑶、检查电机一相是否烧损,如果是,更换绕组。 ⑷、检查电压是否过低,如果是电压过低,调整电源电压。 9635626016、潜水电泵电机绕组烧坏怎么办？ ⑴、检查保护开关是否失灵,如果开关失灵,检修开关或调换。 ⑵、检查保护开关额定电流是否过大,如果是电流过大,重新调整额定电流。 9635626017、潜水电泵机组剧烈振动怎么办？ ⑴、检查叶轮是否平衡,如果不平衡,校正叶轮的平衡。 ⑵、检查电机转子是否平衡,如果不平衡,校正转子的平衡。 ⑶、检查泵半轴是否弯曲或单边摩擦,如果是半轴弯曲或单边摩擦,将轴校直或换新。 ⑷、检查水泵轴与电机轴是否同心,如果不同心,重新组装调整。 ⑸、检查橡胶轴承是否严重磨损,如果是更新橡胶轴承。 9635626018、潜水电泵电机不转的原因和排除方法是什么？ ⑴、电压过低,调整电压或停用。 ⑵、输电线过细电压降过大。重换粗线。 ⑶、叶轮与导流壳磨损。重新调整叶轮位置。 ⑷、电机转子与定子磨损。重新组装检查泵导轴承。 ⑸、止推轴承磨损,主轴下降,至使叶轮与口环磨损。上调环面支柱或更新止推轴承。 ⑹、水泵轴和橡胶轴承不同心。重新组装调整。 ⑺、电机绕组单相烧毁,重新调换烧毁绕组。 ⑻、泵轴与泵导轴承不同心,重新组装调整。 ⑼、水泵与电机内已锈蚀或积砂过多,清理砂或锈污。 ⑽、橡胶轴承抱轴。修复或更新橡胶轴承。 9635626019、潜水电泵起动时电机不转有嗡嗡声的原因及排除的方法是什么？ ⑴、绕组接头接错。找出各相首尾重新接头。 ⑵、单相保险丝烧断或绕组损坏,重新接保险丝或更新绕组。 ⑶、泵轴与泵导轴承不同心或配合间隙过大。重新调整或检修轴承。 ⑷、橡胶轴承咬死,重接调整。 9635626020、潜水电泵绝缘电阻下降的原因及排除方法是什么？ ⑴、电机电缆接头破损。重接电缆接头。 ⑵、电机绕组绝缘破损,重绕绕组。 ⑶、电缆被磨损,用粘胶带或胶水补修。 9635626021、如何对潜水电泵进行维护与保养？ 为延长潜水电泵的使用寿命,电泵在工作中应随时监视电源电压、工作电流是否符合电泵标牌上所规定的数值。否则应停止工作进行检修或调整。(清理内部脏物、检查各部件是否完好,根据损伤情况要分别进行修复和更换)。 ⑴、电泵机组的拆卸 ①、卸掉管路部分 ②、拆离电缆 ③、旋下放水螺栓,放出清水 ④、拆卸：首先拆去滤水网,拧下潜水螺丝及紧固联接段的四个螺母,从进水节往上整体拿下,依次拆下导流壳、锥形套、叶轮、导流壳、锥形套、叶轮……、水泵轴。 电机部分的拆卸：底座、下导、转子、连接段、上导、定子、推力盘。 ⑵、电泵机组的装配 装配前仔细清理各部件的铁锈、油泥污垢,各配合面和紧固件应涂上黄油。其装配程序如下：装配电机定子组装横放在木架上顺序：定子、转子、下端盖、上端盖、进水节、联轴器、泵轴、叶轮、锥形套、导流壳、叶轮、锥形套、导流壳、叶轮、锥形套、导流壳。 装配好的机组、用手扳动应转动均匀,无卡住现象。将电机内灌满清水、拧紧灌水螺丝,进行绝缘检查,试车后安装好滤水网,接好电缆,投入使用。 9635626022、潜水电泵如何保存？ 新购或检修好而不及时使用时应入库保存,库内应清洁干净,无化学腐蚀物,室温不得高于40℃,不准露天存放。水泵吊出长期不用时,应放净电机内的水,将各水管和加工面水迹、锈蚀除净并涂防腐油。按要求检修后存入库房。参数定义： 1.流量：(flowrate, capacity, discharge)单位时间内泵排出液体的体积叫流量,流量用Q表示,计量单位：立方米/小时(m3/h),升/秒(l/s), L/s=3.6 m3/h=0.06 m3/min=60L/min,立方米(Cubic meter),升(lite). 2.扬程：(Lifting)水泵的扬程是指水泵能够扬水的高度,通常用H表示,单位是m。离心泵的扬程以叶轮中心线为基准,分由两部分组成。从水泵叶轮中心线至水源水面的垂直高度,即水泵能把水吸上来的高度,叫做吸水扬程,简称吸程；从水泵叶轮中心线至出水池水面的垂直高度,即水泵能把水压上去的高度,叫做压水扬程,简称压程。 即 水泵扬程= 吸水扬程+压水扬程,应当指出,铭牌上标示的扬程是指水泵本身所能产生的扬程,它不含管道水流受摩擦阻力而引起的损失扬程。在选用水泵时,注意不可忽略。否则,将会抽不上水来. 3.转速:(pump speed)转速是指水泵轴或叶轮每分钟旋转的次数。通常用符号n表示,单位为转每分(r/min)。水泵的转速与其它的性能参数有着密切的关系,一定的转速,产生一定的流量、扬程,并对应一定的轴功率,当转速改变时,将引起其它性能参数发生相应的变化。 水泵是按一定转速设计的,因此配套的动力机除功率应满足水泵运行的工况要求外,在转速上也应与水泵转速相一致。 目前,我国常用的水泵转速为：中、小型离心泵一般在730~2950r/min的范围；中、小型轴流泵一般在250~1450r/min的范围,大型的轴流泵的转速则更低,在100~250 r/min的范围。 4.电机功率:(matched power of motive power machine)动力机配套功率为与水泵配套的原动机的输出功率,考虑到水泵运行时可能出现超负荷情况,所以动力机的配套功率通常选择得比水泵轴功率大。 5.轴功率:(shaft power,input power)轴功率是指动力机经过传动设备后传递给水泵主轴上的功率,亦即水泵的输入功率。通常水泵铭牌上所列的功率均指的是水泵轴功率。 6.效率:(efficiency)水泵传递能量的有效程度称为效率。水泵的输入功率(即轴功率P),由于机械损失、水力损失和容积损失,不可能全部传递给液体,液体经过水泵只能获得有效功率Pe.效率是用来反映泵内损失功率的大小及衡量轴功率P的有效利用程度的参数,即有效功率Pe与轴功率P之比的百分数. 7.必须气蚀余量：(net positive suction head required)必须气蚀余量和允许吸上真空高度(permitted suction vacuum lift)是表征水泵在标准状态下的汽蚀性能(吸入性能)的参数,水泵工作时,常因装置设计或运行不当,会出现水泵进口处压力过低,导致汽蚀发生,造成水泵性能下降甚至流动间断、振动加剧的现象。泵内出现汽蚀现象后,水泵便不能正常工作,汽蚀严重时甚至不能工作。为了避免水泵汽蚀的发生,就必须通过泵的汽蚀性能参数来正确确定泵的几何安装高度和设计水泵装置系统。

系统不一样，如WIN7，DELPHI日期分隔： DateSeparator := "-";WIN7运动正常，到WIN10这条就会提示identifier expected错误了以上是我遇到的问题，希望对你有所帮助

窃窃私语的意思成语解释 【拼音】： qiè qiè sī yǔ 【解释】： 背地里小声说话。 【出处】： 唐·韩愈《顺宗实录·永贞五年》：“虽叛两使事，未尝以簿书为意，日引其党屏人切切细语，谋夺官者兵，以制四海之命。” 窃窃私语意思相近的四字成语 【成语】： 窃窃私议 【拼音】： qiè qiè sī yì 【解释】： 背地里小声议论。 【出处】： 唐·韩愈《顺宗实录·永贞五年》：“虽叛两使事，未尝以簿书为意，日引其党屏人切切细语，谋夺官者兵，以制四海之命。” 用窃窃私语造句子写一句话 倾听鸟儿的窃窃私语，那是唧唧喳喳的快乐;倾听溪水的涓涓潺潺，那是哗哗啦啦的快乐;倾听清风的袅袅亭亭，那是淅淅沙沙的快乐;倾听自己的心跳，那是心醉的声音! 夏日的夜晚山里静悄悄的，只有昆虫在窃窃私语。 大家正在窃窃私语,但是,他进来就都不说了。 山村的夜晚，周遭是那么宁静，为少有灯光的村庄，带来了几份神秘的色彩。小河边的草丛中，偶而会传来几声欢娱的蛙鸣，间或几声虫儿的窃窃私语，仿佛是大自然为我们演奏的小夜曲儿，令人顿感心旷神怡。 在苇塘里，鸳鸯常将脖子伸得长长的，两翅展开拍击水面。一对对色彩斑斓绚丽的鸳鸯在水中嬉戏追逐并肩畅游，时而发出“咕枣咕枣咕”的低沉而柔美的叫声，好像情侣在窃窃私语。 宁静的夜晚，像被施了黑色的咒语，漆黑，只有那天上的星星在窃窃私语。 蜜蜂在粉红的杏花间闹着，艳丽夺目的蝴蝶也在枝头上翩翩起舞，金翅鸟们在嫩嫩的榕树上窃窃私语，山鸡在初醒的山岗上欢笑。真是春光融融春潮滚滚的时候啊! 开大会时要注意听讲，不要在下面窃窃私语。 宁静的夜晚，只有那天上的星星在窃窃私语。 我倾听山溪的倾诉，倾听那溪流柔美的嗓音，倾听它和山的窃窃私语;我倾听书的倾诉，倾听书的谆谆教诲;我倾听着黑夜的倾诉，倾听那恬静的天籁之声。 小学生一年级用窃窃私语写一段话 举目远望，无边无际的大海好像与天连接在一起。海面上，成群结队的海鸥正在飞翔。他们有的在海面上展翅高飞，有的在海面上蜻蜓点水，有的在海面上窃窃私语，还有的在海面上兴致勃勃地捕鱼……一只只海鸥成了海面上快乐的音符。 开始，雪花还伴着雨点，可能是小雪花怕孤单，所以就约上了小雨点儿，我仿佛看见它们在空中嬉戏聊天。雪花飞舞纷纷扬扬，细一听，就能听见“沙沙沙”的声音，仿佛小雪花和小雨点儿在窃窃私语呢!雪下了整整一夜。 可是家里的人们早上都在交头接耳，窃窃私语说，他们听到他深夜走上楼去，待在那里待在房间里，直到太阳升起为止。 宁静的夜晚里，只有那天上的星星在窃窃私语。 厂长的话还没说完，台下已经交头接耳，窃窃私语起来。 人家的窃窃私语与你何干。让人家去说长道短;要像一座卓立的塔，绝不因为暴风而倾斜。 即使这样，朋友聚在一起窃窃私语的摸样满让我感动的。一同守着秘密的几个死党彼此不时使使眼色，颇有一种精彩 *** 的 *** 。 宁静的夜晚，只有那天上的星星正在窃窃私语。 五阳台上那些道貌岸然可尊可敬的先生们彼此一阵交头接耳，贝灵汉总督表达了这阵窃窃私语的主旨，他说话时语气庄重威严，不过仍含有对他招呼着的那年轻牧师的尊敬。 海底的动物常常在窃窃私语。 朋友般的窃窃私语，手足间的循循善诱，亲子式的谆谆嘱咐……温馨的故事里，学生老师是出色的主人公，师生情则是永恒的主旋律。 一群小女孩在操场一角窃窃私语,不时还用眼睛瞅瞅周,看是不是有人注意她们。 窃窃私语英文造句子，带有中英文写一句话 在无意间看到了繁星点点的天空。天上的星星漂亮极了：有的一闪即逝：有的五成群的在做游戏;有的两个在一起窃窃私语;有的像闪闪发光的钻石;有的孤零零的……我总是一遍一遍好奇地数着。星星们眨着眼睛，好象在笑我傻。 I saw the starry sky by accident. The stars in the sky are very beautiful: some are fleeting: some are playing games in five groups; some are whispering together; some are like sparkling diamonds; some are alone I always count curiously over and over. The stars blinked as if they were laughing at me. 花朵有的含苞待放，像一支支白蜡烛;有的争芳斗艳，花骨朵中散发着浓郁的香味;有的倒挂枝头;有的好像是一对情人在一旁窃窃私语;有的像白蝴蝶面对蓝天振翅欲飞。 Some flowers are in bud, like a white candle; some are competing for fragrance, with strong fragrance in the flowers; some are hanging on the branches; some are like a couple of lovers whispering; some are like white butterflies fluttering in the face of the blue sky. 蝶飞蜂狂开始劳作牵媒拉妁，我心桃花开，心弦被轻轻地拨动，抖擞在桃花盛开的地方，笑看着人间笑看着人生。少女魔般地依花妆靓。纷纷地花瓣窃窃私语着谁是最美丽的。 Butterfly fly bee crazy began to work to lead the matchmaker, my heart peach blossom, the heartstrings were gently stirred, vibrant in the peach blossom place, laughing at the world, laughing at life. The girl is enchanted by the flowers. Petals whispered about who was the most beautiful. 当众窃窃私语是没有教养的表现。托尔斯泰 Whispering in public is a sign of ill breeding. Tolstoy 上化学课时她俩窃窃私语。 They whispered in chemistry class. 耳畔的窃窃私语，一个小小的轻吻，一个轻轻的拥抱，都能勾起你的心动，今生今世，你是幸福的，别让这样的幸福错过了你爱情的季节。 Whispers, a *** all kiss, a hug, can arouse your heart. In this life, you are happy. Don"t let such happiness miss your love season. 扩展阅读：窃窃私语的各国语言翻译解释 （窃窃私语）英文意思解释怎么说，怎么写 背地里小声说话 Whisper behind your back （窃窃私语）日语意思解释怎么说，怎么写 背地里小声说话 阴で小声で话す 窃窃私语日语造句子写一句话 有时，他会在书架之间走来走去，口中不时窃窃私语，念叨着他最喜爱的书籍。多年来，有些书他都不忍心打开，生怕就此回忆起不堪回首的过去。 彼は时々本棚の间を行ったり来たりします。彼の一番好きな本を嗫いています。彼は长年にわたって开けられない本があるので、これについて振り返るに堪えない过去を思い出してしまうのではないかと心配しています。 傍晚公园里的长椅上，坐满了窃窃私语的恋人。 夕方の公园のベンチには、ひそひそとした恋人が座っていた。 大家看到市长望而生畏，平民首次见到他还有人在窃窃私语。 市长が怖がるのを见て、庶民は初めて彼を见ました。 在考场上,他们俩窃窃私语,被老师发现了。 试験会场で彼ら二人はひそひそと话していますが、先生に见つけられました。 耳朵灵敏的人，能听到弱肉强食处周的绿叶从中，蝈蝈在窃窃私语。 耳が锐い人は、弱肉强食の青叶を中から闻き、キリギリスが嗫いている。 他们俩在树荫下时而谈笑风生，时而窃窃私语，好不惬意。 彼ら二人は木阴で时々谈笑したり，ひそひそ话したりして，とても心地よい。 秋天的阳光，闪着水银的色彩，小草匍匐在绿叶上，一种沉醉和清馨绕着你不肯离去，红色的星星，枫叶在秋天里窃窃私语，阳光透过森林照在地上，让人向往，很是美丽。 秋の太阳の光、水银の色が辉いています。草が绿の叶の上に腹ばいになっています。一种の陶酔と清馨があなたを取り囲んで离れたくないです。赤い星、红叶が秋に嗫いています。太阳の光は森林を通して地上に照らしています。

不用，HS CODE是84141000，进口没有监管证件。我司今年刚进口的。

在NBA五十多年的历史上，黑八奇迹总共出现了四次，分别是1994年的丹佛掘金队击败了当时西部第一的西雅图超音速，1998-1999赛季的纽约尼克斯队击败了当年的东部第一迈阿密热火队，2006-2007赛季拜伦戴维斯率领的金州勇士队4-2淘汰了西部第一的达拉斯小牛队，2010-2011赛季2011年4月30日以扎克·兰多夫（Zac Randolph）领衔的孟菲斯灰熊队（Memphis Grizzles）4-2战胜了拥有GDP组合的西部第一的圣安东尼奥马刺队。

首先，我们点击电脑桌面左下角的微软按钮，弹出的界面，我们滑动鼠标，找到Windows系统，并点击一下； 弹出的界面，我们点击控制面板； 弹出的界面，我们点击程序和功能； 弹出的界面，我们滑动鼠标找到此软件，然后右击选择卸载； 弹出的界面，我们将图示中的两项全部勾选上； 注:勾选上这两项，才能彻底删除。 然后我们点击Uninstall； 之后便会显示卸载的状态； 卸载过程结束后，我们点击close，这样就能彻底卸载了。

pos机使用前先打开电源键，把卡磁条的部分向左下从前往后刷，之后输入消费的金额进行密码确认即可完成交易，具体内容如下：1、打开pos机电源，输入操作号和相应密码。2、输入完毕来到pos机刷卡界面。3、按“确认”后，输入“1”选择消费。4、输入消费金额后，再按“确认”。就会来到“请插卡或刷卡或挥卡”界面。5、先操作刷磁条卡。把银行卡有磁条的一面面向pos机，然后放入pos机右边的槽内，从上往下拉动银行卡。6、随后，pos机便会读出银行卡的卡号，无误后按“确认”。7、输入密码再按“确认”，随后便是在pos机上签名，等待pos机出完纸后便完成交易了。注意事项：1、不要只刷信用卡，偶然也要刷借记卡，信用卡和借记卡需要交替使用，时不时的刷一下借记卡消费一下。2、从理论上来说，同一张信用卡不要在同在一台机器上延续刷卡超过3个月，满3个月可以适当的暂停，过两个月再回来刷，当然如果你使用的是卡呗生活的落地POS机，可以选择无视，自选落地商户，合理规划消费。3、不要把刷卡小票丧失，小票保存，活期扫描留底，以备不时之需。4、信用卡额度超越1W，消费时建议每笔刷卡控制在60%以内。

形容窃窃私语的成语 【成语】： 窃窃偶语 【拼音】： 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.