countdownlatch

给你一个初始地址 startUrl 和一个 HTML 解析器接口 HtmlParser，请你实现一个 多线程的网页爬虫，用于获取与 startUrl 有 相同主机名 的所有链接。 以 任意 顺序返回爬虫获取的路径。 爬虫应该遵循： 从 startUrl 开始 调用 HtmlParser.getUrls(url) 从指定网页路径获得的所有路径。 不要抓取相同的链接两次。 仅浏览与 startUrl 相同主机名 的链接。 如上图所示，主机名是 example.org 。简单起见，你可以假设所有链接都采用 http 协议，并且没有指定 端口号。举个例子，链接 http://leetcode.com/problems 和链接 http://leetcode.com/contest 属于同一个 主机名， 而 http://example.org/test 与 http://example.com/abc 并不属于同一个 主机名。 HtmlParser 的接口定义如下： interface HtmlParser { // Return a list of all urls from a webpage of given url. // This is a blocking call, that means it will do HTTP request and return when this

在学习go语言时,用到了“sync”包中的WaitGourp结构,来达到控制任务的完成。 由于WaitGroup是结构，所有需要通过 sync.WaitGroup{} 来创建 很类似与 Shoper/JAVA并发库之倒记时锁存器CountDownLatch 中的CountDownLatch类。 Add()，Done()，Wait()。其中Done()是Add(-1)的别名。简单的来说，使用Add()添加计数，Done()减掉一个计数，计数不为0, 阻塞Wait()的运行。 package main import ( "fmt" "runtime" "sync" ) func main() { runtime.GOMAXPROCS(runtime.NumCPU()) waitGourp := sync.WaitGroup{} waitGourp.Add(10) for i := 0; i < 10; i++ { go Go(&waitGourp, i) } waitGourp.Wait() } func Go(wg *sync.WaitGroup, index int) { sum := 0 for i := 0; i < 100000000; i++ { sum += i } fmt.Println(index, sum) wg.Done() } PS：由于之前用的是java

OutOfMemoryError: unable to create new native thread 这个错误是由于创建了太多的线程导致的。创建线程的数量可以由下面公式计算出来： (MaxProcessMemory - JVMMemory - ReservedOsMemory) / (ThreadStackSize) = Number of threads MaxProcessMemory：进程最大寻址空间。 JVMMMEMORY：jvm的内存空间（堆+永久区）-Xmx大小 (应该是实际分配大小) ReservedOsMemory：操作系统预留内存 ThreadStackSize：-Xss大小 计算过程请参考： https://segmentfault.com/a/1190000004694232 重现该异常如下， import java.util.concurrent.CountDownLatch; class TestThread extends Thread { CountDownLatch count = new CountDownLatch(1); public TestThread() { this.setDaemon(true); } /** * 线程一直等待 */ @Override public void run() { try { count.await()

一、CountDownLatch 1.背景： 　　(1)countDownLatch是在java1.5被引入，跟它一起被引入的工具类还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue。 　　(2)存在于java.util.cucurrent包下。 2.概念 　　(1)countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。 　　(2)是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。 3.源码 　　(1)countDownLatch类中只提供了一个构造器： //参数count为计数值 public CountDownLatch(int count) { }; 　　(2)类中有三个方法是最重要的： //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行 public void await() throws InterruptedException { }; //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行 public boolean await(long timeout, TimeUnit unit)

CountDownLatch复杂点的例子 public class CountDownLatchTest2 { private static Random random = new Random(System.currentTimeMillis()); static class Event { int id; Event(int id) { this.id = id; } } static class TaskBatch { private CountDownLatch latch; private EventBatch eventBatch; private Table table; TaskBatch(Table table, int size, EventBatch eventBatch) { latch = new CountDownLatch(size); this.eventBatch = eventBatch; this.table = table; } public void done() { latch.countDown(); if (latch.getCount() == 0) { System.out.println("the table " + table.name + " has finished [ " + table + " ]");

countdownlatch 一个线程等待其他线程完成了再接着往下执行 public class CountDownLatchExample { private static ExecutorService executorService = Executors.newFixedThreadPool(2); private static Random random = new Random(System.currentTimeMillis()); private static CountDownLatch countDownLatch = new CountDownLatch(10); public static void main(String[] args) throws InterruptedException { //(1) int[] data = query(); //(2) for (int i = 0; i < data.length; i++) { executorService.execute(new SimRunnable(data, i, countDownLatch)); } //(3) countDownLatch.await(); System.out.println("all of work have finished");

1.定义一个连接池接口 import java.sql.Connection; /** * 数据库连接池接口 */ public interface DbPool { /** * 连接池初始化 */ void init(); /** * 获取一个连接 * * @return */ Connection getConnection(); /** * 释放一个连接 * * @param connection */ void releaseConnection(Connection connection); /** * 销毁连接池 */ void destroy(); } 2.定义一个连接池的实现 import org.springframework.scheduling.annotation.Scheduled; import java.sql.Connection; import java.sql.SQLException; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; /** * 数据库连接池实现 */ public class DbPoolImpl

1.cas 它的实现很简单，就是用一个预期的值和内存值进行比较，如果两个值相等，就用预期的值替换内存值，并返回 true。否则，返回 false。 2. synchronized的三种应用方式 Java中每一个对象都可以作为锁，这是synchronized实现同步的基础： 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁 3. ReenTrantLock 实现接口Lock ReentrantLock 是一个互斥锁，也是一个 可重入锁 （Reentrant就是再次进入的意思）。 ReentrantLock 锁在同一个时间点只能被一个线程锁持有，但是它可以被单个线程多次获取，每获取一次 AQS 的 state 就加1，每释放一次 state 就减1。还记得 synchronized 嘛，它也是可重入的，一个同步方法调用另外一个同步方法是没有问题的。 废话不多说，上代码： 1 public static void main(String[] args)throws Exception { 2 CountDownLatch countDownLatch = new CountDownLatch(1)

Java并发工具包 1.并发工具类 提供了比synchronized更加高级的各种同步结构：包括CountDownLatch、CyclicBarrier、Semaphore等，可以实现更加丰富的多线程操作。 2.并发容器 提供各种线程安全的容器：最常见的ConcurrentHashMap、有序的ConcurrentSkipListMap,实现线程安全的动态数组CopyOnWriteArrayList等。 3.并发队列 各种BlockingQueue的实现：常用的ArrayBlockingQueue、SynchorousQueue或针对特定场景的PriorityBlockingQueue。 4.Executor框架 可以创建各种不同类型的线程池，调度任务运行等，绝大部分情况下，不再需要自己从头实现线程池和任务调度器。 Java常用的并发容器 1.ConcurrentHashMap 经常使用的并发容器，JDK 1.7和1.8的底层数据结构发生了变化(后续文章会详解)，这里可以建议学习顺序如下：从Java7 HashMap -> Java7 ConcurrentHashMap -> Java8 HashMap -> Java8 ConcurrentHashMap，这样可以更好的掌握这个并发容器，毕竟都是从HashMap进化而来。 2.ConcurrentSkipListMap 在乎顺序