java并发深入--通信、forkJoin框架、线程安全的学习

　　线程是计算机的一个稀缺资源，在一个应用的开发下，使用到多线程之间的使用，对项目的效率有着明显的提升；但是并不是线程越多越好，在线程的使用的时候还必须保证线程安全的前提下进行的。先前自己在学校的时候对线程总体的学习，但是始终没有用在项目上，现在打算进一步的对线程的深入源码的去理解、去学习，希望可以得到提升。

线程---并发编程的基础

先前对线程已经学习过一次，现在对此做一个基础的总结：

1.cpu核心数和线程数之间的关系：在传统的模式中，核心数和线程数是1:1，在微软加入超线程后，这两者的比例变成了1:2，并且性能上有一个很大的提升。

2.cpu时间片轮转机制：在cpu的调度下，每个线程都有一个生命周期，当生命周期结束时，无论线程的任务是否已经完成，都会暂停当前的任务，cpu调下一个线程进行运行，这称为上下文切换。在多线程运行，都会涉及上下文的切换，如果线程太多，甚至过量，会导致上下文切换比较频繁，使得上下文切换花费的时间占cpu时间的比例会上升，导致工作时间比例下降，效率反而低下，所以并不是线程越多越好。关于优化上下文切换可以参照博客JAVA并发概要。

3.进程和线程的区别：进程：程序运行资源分配的最小单位；线程：是cpu调度的最小单位(本身没有资源，所有线程共享进程中的资源)，线程必须依附于进程，不会单独存在。

4.高并发的优点：①充分利用cpu的资源，避免的cpu资源的浪费；②加快用户响应的时间；③程序模块异步化。但是必须注意的问题就是： 线程安全性问题，资源有限性问题。

5.java里的程序天生的多线程，main函数就是一个线程；创建启动线程的方式：①：继承类Thread；②：实现接口Runable；③：实现接口Callable；④：使用线程池工产类Executors创建或者使用ThreadPoolExecutor自定义创建。

6.怎样才能让java线程安全的停止：

　　传统的线程停止的方法：stop()，suspend()函数，但是这两个方式已经被弃用了，因为这两个方法会导致一系列的安全情况；

　　stop()被调用后，强制暂停线程，线程资源会得不到释放，数据很有可能被使用在一个不正确的情况下。

　　suspend()被调用后，线程不释放占用资源直接进入睡眠，很容易造成死锁(占用且等待)。

造成死锁的四个条件：互斥，占有并且等待，不可剥夺，循环等待。

怎么样才能线程安全的停止呢？

在现在的解决方案里面：interrupt()，interrupted()，isInterrupted()这三个函数来解决的。

interrupt()本质上不会中断线程，只是将线程的中断标志位设置为“true”。

isInterrupted():是static方法的interrupted()，两个都是用来检查中断标记位的。

public class InterruptClass {
    private static class UseInterrupt implements Runnable{
        @Override
        public void run() {
            //但是实际上并没有中断，需要检测中断标识符
            while (!Thread.currentThread().isInterrupted()){
                System.out.println(Thread.currentThread().getName()+" am implements Runnable");
            }
            System.out.println(Thread.currentThread().getName()+" interrupt is "+Thread.currentThread().isInterrupted());
        }
    }
    public static void main(String[] args) throws InterruptedException {
        UseInterrupt useInterrupt=new UseInterrupt();
        Thread thread=new Thread(useInterrupt,"endThread");
        thread.start();
        Thread.sleep(1);
        thread.interrupt();//通过调用函数实现中断
    }
}

测试代码

 

7.线程优先级：Thread.setPriority()；//默认标识是5，但是在有些操作系统中，操作系统会忽略这一个语法，这个函数不可靠，应该使用其他的方式设置线程的优先级。

8.守护线程：Thread.setDaemon(true)，在守护线程中，try-finally中的finally的代码不一定执行。

9.线程之间的状态、以及状态的切换：

线程---线程间的协作通信

线程间的通信有：同步，wait/notify机制，管道通信，Condition。

1.线程间的共享：
synchronized内置锁：在并发的条件下保证原子性；

Volatile关键字：只保证内存的可见性，不保证内存操作的原子性。在高可见低原子性，使用volatile效果很好，不止达到了目的，还避免了锁。

ThreadLocal：每一个线程都独自的拥有一个变量，但是线程之间不是共享的，在ThreadLocal中有一个ThreadLocalMap的内部类，实际上就是map结构，key就是线程，value就是自己的那个变量。

执行结果：

public class UserThreadLocal {

    static ThreadLocal<Integer> threadLocal=new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue(){
            return 1;
        }
    };
    public void startThreadArray(){
        Thread[] runs=new Thread[3];
        for(int i=0;i<runs.length;i++){
            runs[i]=new Thread(new TestThread(i));
        }
        for (int i=0;i<runs.length;i++){
            runs[i].start();
        }
    }
    private static class TestThread implements Runnable{
        int id;

        public TestThread(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+":Start ");
            Integer s=threadLocal.get();
            s=s+id;
            threadLocal.set(s);
            System.out.println(Thread.currentThread().getName()+" : "+threadLocal.get());
        }
    }

    public static void main(String[] args){
        UserThreadLocal userThreadLocal=new UserThreadLocal();
        userThreadLocal.startThreadArray();
    }

}

 

 

2.等待通知：wait()，notify/notifyAll,等待超时模式，

join()方法：控制线程的执行顺序，等待执行join的线程执行完成后，再执行其他的内容。

yield()方法：调用时，当前线程执行锁，不释放锁。

sleep()方法：调用时，不释放锁、占有资源。

wait()方法：调用时，释放锁和占有资源。

notify()/notifyAll，调用前持有锁；包含notify()的方法结束后，锁才会被释放。

关于wait和notify的列子如下：我们现在有一个快递系统，定义一个快递的实体类，里有km里程数和site站点。我们需要当快递到达目的地时要提醒用户，实现如下：waitKm这个锁一直被阻塞了的，当changeKm被修改的时候，唤醒waitKm这个锁。

 

关于notify和notifyAll的使用问题：notify是唤醒其中的一个wait但是不能确定唤醒的是哪一个wait，所以都是使用的是notifyAll。

 

package main.java.Thread.UserThread.wn;

/**
 * @author yangxin
 * @time 2019/2/28  11:55
 */
public class Express {
    public final static String city="Shanghai";
    private int km;
    private String site;

    public Express() {
    }

    public Express(int km, String site) {
        this.km = km;
        this.site = site;
    }

    public synchronized void changeKm(){
        this.km=101;
        notifyAll();
    }

    public synchronized void changeSite(){
        this.site="BeiJing";
        notifyAll();
    }

    public synchronized void waitKm(){
        while (this.km<100){
            try {
                wait();
                System.out.println("check km Thream["+Thread.currentThread().getName()
                        +"] is be notify");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("this km is "+this.km+",I will change db");
    }

    public synchronized  void waitSite(){
        while (this.site.equals(city)){
            try {
                wait();
                System.out.println("check km Thream["+Thread.currentThread().getName()
                        +"] is be notify");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("this is site"+this.site+",I will change db");
    }
}

 

package main.java.Thread.UserThread.wn;

/**
 * @author yangxin
 * @time 2019/2/28  11:55
 */
public class TestWn {
    private static Express express=new Express(0,Express.city);

    private static class chenkKm extends Thread{
        @Override
        public void run() {
            express.waitKm();
        }
    }

    private static class checkSite extends  Thread{
        @Override
        public void run() {
            express.waitSite();
        }
    }

    public static void main(String[] args) throws InterruptedException{
        for(int i=0;i<1;i++){
            new checkSite().start();
        }
        for(int i=0;i<1;i++){
             new chenkKm().start();
        }
        Thread.sleep(1000);
        express.changeKm();
    }
}

 

 

3.Fork/join框架

fork/join框架就是在必要的情况下，将一个大任务，进行拆分成一个个小任务，当在不可拆时，再将任务计算的结果一个个的合成，得出最后的结果，显然就是一个分而治之的思路。

Fork/Join相关的类和使用的标准范式：ForkJoinTask，ForkJoinPool。使用ForkJoinTask实现后将代码交给ForkJoinPool里。

在ForkJoinTask的派生子类主要有：RecursiveTask和RecursiveAction；RecursiveTask表示计算的任务有返回值；RecursiveAction表示计算的任务没有返回值；一般的使用方法是自定义一个类来继承这两个子类，覆盖compute方法，然后在这个方法里进行任务的执行和拆分。

①：遍历电脑D盘统计文件个数；②：遍历电脑D盘寻找.txt文件的个数。

遍历电脑D盘统计个数

 

运行结果(部分截图)：

public class ForkAndJoinFramework extends RecursiveTask<Integer> {
    private File path;//文件路径
    public ForkAndJoinFramework(File path) {
        this.path = path;
    }
    @Override
    protected Integer compute() {
        int count=0;//文件个数的计数器
        int dircount=0;//目录计数器
        List<ForkAndJoinFramework> listTask=new ArrayList<>();//子目录任务容器
        File[] files=path.listFiles();
        if(files!=null){
            for(File file:files){
                if(file.isDirectory()){
                    listTask.add(new ForkAndJoinFramework(file));
                    dircount++;
                }else{
                    count++;
                }
            }
        }
        System.out.println("目录："+path.getAbsolutePath()+" 包含的子目录个数"+dircount
                +" 包含的文件个数"+count);
        if(!listTask.isEmpty()){
            for(ForkAndJoinFramework forkAndJoinFramework:invokeAll(listTask)){
                count+=forkAndJoinFramework.join();
            }
        }
        return count;
    }

    public static void main(String[] args){
        ForkJoinPool forkJoinPool=new ForkJoinPool();
        ForkAndJoinFramework forkAndJoinFramework=new ForkAndJoinFramework(new File("D:/"));
        forkJoinPool.invoke(forkAndJoinFramework);
        System.out.println("File Count ="+forkAndJoinFramework.join());
    }
}

遍历电脑D盘统计个数

 

 

 

遍历电脑D盘寻找.txt文件：因为是查找出.txt所以我们优先选择继承RecursiveAction没有返回值的。

运行结果：

 

public class FornJoinFramework extends RecursiveAction {
    private File path;
    public FornJoinFramework(File path) {
        this.path = path;
    }
    @Override
    protected void compute() {
        List<FornJoinFramework> listTask=new ArrayList<>();
        File[] files=path.listFiles();
        if(files!=null){
            for(File file:files){
                if(file.isDirectory()){
                    listTask.add(new FornJoinFramework(file));
                }else{
                    if(file.getAbsolutePath().endsWith("txt")){
                        System.out.println("文件："+file.getAbsolutePath());
                    }
                }
            }
        }
        if(!listTask.isEmpty()){
            for(FornJoinFramework fornJoinFramework: invokeAll(listTask)){
                fornJoinFramework.join();
            }
        }
    }
    public static void main(String[] args){
        ForkJoinPool forkJoinPool=new ForkJoinPool();
        FornJoinFramework fornJoinFramework=new FornJoinFramework(new File("D:/"));
        forkJoinPool.execute(fornJoinFramework);
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("I am ok ");
        fornJoinFramework.join();
        System.out.println("work finish ");
    }
}

 

 

4.CountDownLatch(闭锁)：允许一个或者多个线程等待其他线程完成操作后继续自己的操作，类似加强版的Join。

/**
 * @author yangxin
 * @time 2019/2/28  15:30
 *
 * 类说明：5个线程执行6个初始化任务,使用CountDownLatch。
 */
public class UseCountDownLatch {
    static CountDownLatch countDownLatch=new CountDownLatch(6);

    private static class initThread implements Runnable{

        @Override
        public void run() {
            System.out.println("Thread:"+Thread.currentThread().getName()+"初始化中....");
            countDownLatch.countDown();
            System.out.println("Thread:"+Thread.currentThread().getName()+"初始化完成，执行其他操作中...");
        }
    }

    private static class BussThread implements Runnable{

        @Override
        public void run() {
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread:"+Thread.currentThread().getName()+"业务逻辑工作++++++");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread:"+Thread.currentThread().getName()+"初始化111");
                countDownLatch.countDown();
                System.out.println("Thread:"+Thread.currentThread().getName()+"初始化222");
                countDownLatch.countDown();
            }
        }).start();
        new Thread(new BussThread()).start();
        for(int i=0;i<=3;i++){
            Thread thread=new Thread(new initThread());
            thread.start();
        }

        countDownLatch.await();
        System.out.println("Main work finish");
    }

}

 

 

5.CyclicBarrier(屏障)：让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时才被放行，所有被屏障拦截的线程才会继续执行。可以在一组线程到达屏障时，优先执行某一个操作，方便处理更复杂的业务逻辑。关于闭锁和屏障可以参考JAVA并发 闭锁、同步屏障、信号量总结。

 

线程---线程安全

1.怎么能够保证线程安全：让类不可变，volatile保证内存可见性，加锁，CAS类控制线程的执行顺序。

2.死锁：是指两个或者两个以上的进程在执行的过程中，由于资源竞争或者彼此通信而造成的一种拥塞现象，如果没有外力的情况下，将一直保持这种状态。怎么解决死锁？控制线程之间的加锁顺序。

3.活锁：在try-Local模式下造成的情况。在try-Local中，如果线程已经锁定了A锁，在尝试获取B锁的时候，发现已经被占有，于是释放自己占有的A锁；在此同时另一个线程已经锁定了B锁，在尝试获取A锁的时候发现已经被占有，于是释放自己占有的B锁，于是两个线程都在相互等待，这种称为活锁。

4.线程饥饿：在线程优先级的情况下，有可能出现这种情况，优先级高的线程一直持有锁，优先级低的线程一直都会得不到锁，就是线程饥饿。

5.性能：在加锁的情况上，尽量只加锁关键性代码，尽量不要对没必要的代码段加锁。

显示锁Lock接口：

①、尝试非阻塞获取锁，②、可以被中断的获取锁，③、超时获取锁。(synchronized 是隐式锁，固化了加锁和释放锁)。

Lock接口的核心方法：lock()加锁,unlock()释放锁,trylock()有一个返回值，如果获取到锁返回true，否则返回false；

Lock的实现ReentrantLock和标准用法：排它锁：就是在任何情况下同一时刻只允许一个线程允许访问，例子如下：

ReadWriteLock接口和读写锁ReentrantReadWriteLock：因为在排他锁，在任何情况下，同一时刻都只允许一个线程访问，但是在很多情况下，读多写少的情况下就非常的低效，因为读可以不用加锁，所以就出现了读写锁，他读写分离。同时都是读的 时候他们都是并发的执行。

如下来对比Synchronized和ReentrantReadWriteLock的效率对比：

Synchronized加锁：

 

运行效率如下：

 

ReentrantReadWriteLock锁：

 

运行的效率：

两者的对比可知，在读多写少的情况下，ReentrantReadWriteLock锁更高效。

代码有点多：如果要源代码访问github：https://github.com/fireshoot/LearningAndTest/tree/master/src/main/java/Thread/UserThread。在rw包下的就是这部分的代码，整个java包下是本篇博客的代码。

Condition接口

　　Condition接口提供方法，signal()/signalAll()和await()，这两个方法的作用和wait-notify一样。

使用如下：

 

public class ConditionClass {
    Lock kmLock=new ReentrantLock();
    Condition condition1=kmLock.newCondition();

    Lock siteLock=new ReentrantLock();
    Condition condition2=siteLock.newCondition();

    private String name;
    private int km;
    private String site;

    public void setKm(int km) {
        kmLock.lock();
        try{
            this.km = km;
            condition1.signal();
        }finally {
            kmLock.unlock();
        }
    }

    public void setSite(String site) {
        siteLock.lock();
        try{
            this.site = site;
            condition2.signal();
        }finally {
            siteLock.unlock();
        }
    }

    public void changeKm() throws InterruptedException {
        kmLock.lock();
        try{
            while (this.km<100){
                condition1.await();
                //.....
            }
            //......
        }finally {
            kmLock.unlock();
        }
    }

    public void changeSite() throws InterruptedException {
        siteLock.lock();
        try{
            while (site.equals("BeiJing")){
                condition2.await();
            }
        }finally {
            siteLock.unlock();
        }
    }

    public ConditionClass(String name, int km, String site) {
        this.name = name;
        this.km = km;
        this.site = site;
    }

    public int getKm() {
        return km;
    }

    public String getSite() {
        return site;
    }
}

 

 

 CAS(Compare And Swap)

即比较并替换：三个运算符：一个内存地址V，一个期望的旧值A，一个新值B；在内存地址V上，在期望旧值B的基础上，将新值写入地址V上。

是一种实现并发算法时常用到的技术，Java并发包中的很多类都使用了CAS技术。它能够保证基本类型的变化具有原子性。比如我们常常见到的 i++；这条语句，在平时的开发中并没有感觉原子性的问题，但是在多线程的情况下i++并不具有原子性，i++首先取值，再写值，在并发的条件下有可能已经被多个线程写值了，导致i++增加的异常。怎么解决比如i++的原子性呢，那么就是用CAS的AtomicInteger来代替int，在i++的时候，首先检测该地址上的期望旧值是不是我们i++之前的值，如果是，那么就执行++操作；如果不是，说明其他线程对此已经做出了修改，报异常。

 

CAS存在的问题：

①：ABA问题：内存计算V本来就是A值，但是在其中变化成了B值，但是最后又变化成A，在运行检查的时候发现期望旧值并没有改变，于是进行了操作。解决方法：版本号。

②：往往只能保证一个共享变量的原子操作。

相关的原子操作类：

1. 更新基本类型：AtomicBoolearn，AtomicInteger，AtomicLong，AtomicReference。
   
2. 更新数组类型：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray。
3. 更新引用类型：AtomicReference，AtomicMarkableReference，AtomicStampReference。
4. 原子更新字段类：AtomicReferenceFieldUpdater，AtumicIntegerFieldUpdater,AtomicLongFieldUpdater。

结语

对线程并发编程的基础知识的复习，还对①加深了对 wait-notify/notifyAll的理解和使用；②Fork-Join框架下ForkJoinTask(RecursiveTask，RecursiveAction)和ForkJoinPool的搭配使用，并且实现搜寻文件数量和指定文件的实现方式；③对CountDownLatch、CyclicBarrier、Semaphore、Exchange的复习；④：对显示锁Lock、ReentrantLock、读写锁ReadWriteLock、ReentrantReadWriteLock的使用，读写锁和Synchronized关键字在读多写少的效率比较；⑤ Condition的使用，和Wait-notify的区别；⑥：CAS。

关于本篇博客的源码见github地址：https://github.com/fireshoot/LearningAndTest。注意：我是使用的IDEA开发的，如果导入失败直接复制包类就行了

 

 

 

转载标明地址：java并发深入学习总结