JAVA高并发程序设计笔记

第二章 Java并行程序基础

1、join()的本质是让调用线程wait()在当前线程的对象上

2、Thread.yiedl()会使当前线程让出CPU

3、volatile保证可见性，无法保证原子性（如i++，JAVA高并发程序设计P51）

4、synchronized作用是实现线程间的同步是没一次只有一个线程进入同步块，从而保证线程间的安全性；

     synchroized不能对Interger加锁，interger属于不变对象，i++实际在执行时变成了i=Interger.valueOf(i.intValue()+1)),Interger.valueOf()实际是一个工厂方法，会创建一个新的Integer对象（JAVA高并发程序设计P68）

第三章 JDK并发包

5、synchronized增强版 ReentrantLock，常用方法如下

     lock()：获得锁，如果锁已经被占用，则等待

     lockInterruptibly()：获得锁，优先相应中断

     tryLock()：尝试获得锁，不等待

     tryLock（long time，TimeUnit unit）：给定实际内尝试获得锁

     ublock()：释放锁

6、重入锁搭档Condition

public class ReenterLockCondition implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();

    @Override
    public void run() {

        try {
            lock.lock();
            condition.await();
            System.out.println("Thread is going on");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

7、信号量（semaphore）可以指定多个线程同事访问某一个资源

public class SemapDemo implements Runnable {
    final Semaphore semp = new Semaphore(5);

    @Override
    public void run() {
        try {
            semp.acquire();
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getId() + ":done!");
            semp.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 总共20个线程,系统会以5个线程一组为单位,依次执行并输出
     *
     * @param args
     */
    public static void main(String args[]) {
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        final SemapDemo demo = new SemapDemo();
        for (int i = 0; i < 20; i++) {
            executorService.submit(demo);
        }
    }
}

8、读写锁 ReadWriteLock

9、倒计时器：CountDownLatch

public class CountDownLatchDemo implements Runnable {
    static final CountDownLatch end = new CountDownLatch(10);
    static final CountDownLatchDemo demo = new CountDownLatchDemo();

    @Override
    public void run() {

        try {
            Thread.sleep(new Random().nextInt(3) * 1000);
            System.out.println("check complete");
            end.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String args[]) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.submit(demo);
        }
        //等待检查
        end.await();
        //发射火箭
        System.out.println("Fire!");
        executorService.shutdown();
    }
}

9、循环栅栏 CyclicBarrier，指计算器可以反复使用，接收一个参数作为barrierAction，当计数器一次计数完成后，系统执行barrierAction

10、Locksupport 线程阻塞工具，可以在线程内任意位置让线程阻塞

线程池

11、四大线程池

　　（1） newFixeThreadPool（）：返回一个固定线程数量的线程池，该线程池的线程数量始终不变，当有一个新的任务提交时，线程池中若有空闲线程，则立即执行，若没有，　　　　　则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务

　　（2） newSingleThreadExecutor（）：返回一个只有一个线程的线程池，，若多个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序　　　　　执行队列中的任务

　　（3）newCachedThrePool（）：返回一个可管局实际情况调整线程数量的线程池，线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程，若所有线　　　　  程均在工作，又有新的任务提交，则会创建新的线程处理任务，所有线程在当前任务执行完毕后，将返回线程池进行复用

　　（4）newSingleThreadScheduledExecutorService：返回一个ScheduledExecutor对象，线程池大小为1，周期性执行某个任务

详解：http://www.cnblogs.com/dolphin0520/p/3932921.html

12、submit与execute的区别

　　（1）如果提交的任务不需要一个结果的话直接用execute()会提升很多性能

　　（2）submit返回执行结果，用get接收；execute不返回结果，可打印堆栈信息

13、fork/join 框架

14、JDK并发容器

　　（1） ConcurrentHashMap

　　（2）CopyOnWiteArryList

　　（3） ConcurrentLinkedQueue